数据结构实践.docx

数据结构实践.docx

《数据结构实践.docx》由会员分享，可在线阅读，更多相关《数据结构实践.docx（20页珍藏版）》请在冰豆网上搜索。

数据结构实践

实验

实验一线性表（一顺序表）2

实验二排序3

实验三二分查找4

实验四线性表（二链表）5

实验五栈6

实验六队列7

实验七二叉树的存储与遍历7

实验一线性表（一顺序表）

实验目的

理解线性表的逻辑结构特性是数据元素之间存在着线性关系，掌握顺序表的特点是逻辑上相邻的元素的存储地址也相邻，熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。

实验内容

以顺序表为存储结构，编写程序求解约瑟夫问题。

编号为1，2，···，n的n个人围坐在一圆桌旁，从第s个人开始报数，报到第m的人退席，下一个人又重新从1开始报数，依此重复，直至所有的人都退席

实验要求

顺序表的初始状态可直接赋值，也可将初态置为空表，从键盘（文件）读入数据元素。

输出删除元素的顺序

统计移动元素的次数，分析算法的时间性能

实验实现

实验总结

给出移动次数及算法的时间性能，总结编程中遇到的问题以及解决的方法

publicclassChaRu{

publicstaticvoidmain（String[]args）{

int[]arr1={3,2,1,5,4,8,6,9,7};

int[]arr2=newint[arr1.length];

arr2[0]=arr1[0];

for（inti=0;i

System.out.print（arr1[i]）;

}

for（inti=1;i

intj=i;

arr2[i]=arr1[i];

if（arr2[i]

while（i>0）{

if（arr2[i]

inttemp=arr2[i];

arr2[i]=arr2[i-1];

arr2[i-1]=temp;

i--;

}elsebreak;

}

}

i=j;

}

System.out.println（）;

for（inti=0;i

System.out.print（arr2[i]）;

}

}

}

importjava.util.Scanner;

publicclassMaopao{

publicstaticvoidmain（String[]args）{

Scannerscanner=newScanner（System.in）;

System.out.print（"请第一个数：

"）;

inta1=scanner.nextInt（）;

System.out.print（"请第二个数：

"）;

inta2=scanner.nextInt（）;

System.out.print（"请第三个数：

"）;

inta3=scanner.nextInt（）;

System.out.print（"请第四个数：

"）;

inta4=scanner.nextInt（）;

System.out.print（"请第五个数：

"）;

inta5=scanner.nextInt（）;

int[]a={a1,a2,a3,a4,a5};

for（inti=0;i

System.out.print（a[i]+""）;

}

for（inti=0;i

for（intj=0;j

if（a[j]>a[j+1]）{

inttemp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

}

}

System.out.println（）;

for（inti=0;i

System.out.print（a[i]+""）;

}

}

}

publicclassXuanZe{

publicstaticvoidmain（String[]args）{

int[]arr={9,7,4,1,2,6,8,3,5};

for（inti=0;i

System.out.print（arr[i]）;

}

//排序

for（inti=0;i

intindex=selectMin（arr,i）;

swap（arr,i,index）;

}

System.out.println（）;

for（inti=0;i

System.out.print（arr[i]）;

}

}

//找到最小的数的下标

publicstaticintselectMin（int[]arr,intindex）{

intmin=arr[index];

intmIndex=index;

for（inti=index+1;i

if（arr[i]

min=arr[i];

mIndex=i;

}

}

returnmIndex;

}

//两个数进行交换

publicstaticvoidswap（int[]arr,intx,inty）{

inttemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

}

实验二排序

实验目的掌握排序的概念，了解排序应用范围，掌握排序算法的分析方法

实验内容给定顺序表，采用插入、冒泡或快速三种排序方法的任意两种实现由大到小排序

实验要求1.可以在程序中指定数据表，也可从键盘输入

2.输出最终排序结果

3.可以只输入整数值进行排序，也可利用面向对象思想对不同学生信息按年龄进行排序

“01”，“张三”，“男”，20

“02”，“王民”，“男”，19

“03”，“马雨”，“女”，22

“04”，“孙林”，“男”，18

“05”，“赵名”，“男”，20

“06”，“林南”，“女”，17

实验实现

实验总结

分析得失，在设计中出现什么问题以及如何解决

实验三二分查找

实验目的掌握查找的概念，了解查找应用范围，掌握查找算法的分析方法

实验内容给出一个顺序序列的二分查找实现

实验要求1.利用数组作为存储结构

2.分别给出查找成功和不成功两种例子

实验实现

实验总结

分析得失，在设计中出现什么问题以及如何解决

实验四线性表（二链表）

实验目的

理解线性表的逻辑结构特性是数据元素之间存在着线性关系，掌握链表的特点是用一组任意的存储单元存储线性表的数据元素，熟练掌握链表运算的实现

实验内容

在链表L中插入删除元素

实验要求

初始将链表置空

在链表中插入元素A，E，F

按字母顺序插入D

输出插入元素后的链表

删除E

输出删除元素后的链表

实验实现

实验总结

分析算法的时间性能，总结编程中遇到的问题以及解决的方法

packagelianbiao;

publicclassDemo{

publicstaticvoidmain（String[]args）{

LinkA=newLink（'A'）;

LinkE=newLink（'E'）;

LinkF=newLink（'F'）;

LinkD=newLink（'D'）;

LinkDs=null;

//先初始化，初始将链表置空

LinkDaolink=newLinkDao（）;

//在链表中插入元素A，E，F

link.setHead（A）;

link.setNext（E）;

link.setNext（F）;

Ds=link.getHead（）;

for（inti=0;i

System.out.print（Ds.getData（））;

Ds=Ds.getNext（）;

}

System.out.println（）;

//按字母顺序插入D

link.addAlist（D）;

//输出插入元素后的链表

Ds=link.getHead（）;

for（inti=0;i

System.out.print（Ds.getData（））;

Ds=Ds.getNext（）;

}

System.out.println（）;

//删除E

link.deleNext（E）;

Ds=link.getHead（）;

//输出删除元素后的链表

for（inti=0;i

System.out.print（Ds.getData（））;

Ds=Ds.getNext（）;

}

}

}

packagelianbiao;

publicclassLink{

privatechardata;//存储节点中的元素

privateLinknext;//在链表中引用下一个节点

publicLink（chardata）{

this.data=data;

next=null;

}

publicchargetData（）{

returndata;

}

publicvoidsetData（chardata）{

this.data=data;

}

publicLinkgetNext（）{

returnnext;

}

publicvoidsetNext（Linknext）{

this.next=next;

}

}

packagelianbiao;

publicclassLinkDao{

privateLinkhead,cout;

privateintsize;

publicLinkgetHead（）{

returnhead;

}

publicvoidsetHead（Linkhead）{

this.head=head;

this.cout=head;

size=1;

}

publicintgetSize（）{

returnsize;

}

//插入元素

publicvoidsetNext（Linknext）{

for（inti=0;i

if（i==size-1）{

cout.setNext（next）;

this.size++;

cout=next;

break;

}

}

}

//删除元素

publicvoiddeleNext（Linknext）{

Linkjj=head;

for（inti=0;i

if（next.getData（）==jj.getNext（）.getData（））{

jj.setNext（jj.getNext（）.getNext（））;

size--;

break;

}

jj=jj.getNext（）;

}

}

//按字母插入

publicvoidaddAlist（Linknext）{

Linkjj=head;

inty=0;

for（inti=0;i

if（next.getData（）

next.setNext（jj.getNext（））;

jj.setNext（next）;

size++;

y++;

break;

}

}

if（y==0）{

setNext（next）;

}

}

}

实验五栈

实验目的掌握栈的特点，理解在什么问题中应利用何种结构，熟练掌握在两种存储结构上实现栈的基本运算，特别注意栈满和栈空的条件及它们的描述

实验内容十进制转化成二进制

实验要求1.利用栈实现，存储结构采用顺序或链式均可

2.给定某数，输出对应二进制

实验实现

实验总结

分析得失，在设计中出现什么问题以及如何解决

packagezhan;

publicclassStack{

inttop;

int[]stack;

intmax;

publicStack（intn）{

top=0;

stack=newint[n];

max=n;

}

publicbooleannoEmpty（）{

returntop!

=0;

}

//出栈

publicbooleanpop（）throwsException{

if（top==0）{

thrownewException（"栈已空"）;

}

top--;

returntrue;

}//入栈

publicvoidpush（intnum）{

if（top==max）{

System.out.println（"栈已满"）;

}

stack[top]=num;

top++;

}//获取栈顶元素

publicintgetTop（）throwsException{

if（top==0）{

thrownewException（"栈已空"）;

}

returnstack[top-1];

}

publicintlength（）{

return（top）;

}

}

packagezhan;

publicclasstest1{

publicstaticvoidmain（String[]args）{

Stacks=newStack（8）;

s.push（20）;

s.push（40）;//入站

inta=s.length（）;//元素个数

System.out.println（"元素个数"+a）;

try{

System.out.println（"当前栈顶元素：

"+s.getTop（））;//栈顶元素

}catch（Exceptione1）{

//TODOAuto-generatedcatchblock

e1.printStackTrace（）;

}

try{

s.pop（）;//出栈

}catch（Exceptione）{

//TODOAuto-generatedcatchblock

e.printStackTrace（）;

}

try{

System.out.println（"出栈一元素后栈顶为：

"+s.getTop（））;

}catch（Exceptione1）{

//TODOAuto-generatedcatchblock

e1.printStackTrace（）;

}

intb=s.length（）;

System.out.println（"元素个数为：

"+b）;

}

}

packagezhan;

importjava.util.Scanner;

publicclassTest2{

publicstaticvoidmain（Stringargs[]）{

intnum;

Stackstack=newStack（50）;

Scannerscanner=newScanner（System.in）;

System.out.println（"请输入十进制的数字：

"）;

intnumber1=scanner.nextInt（）;

while（number1>0）{

num=number1%2;//取模

number1=number1/2;

stack.push（num）;//取模入栈

}

System.out.println（"二进制是：

"）;

while（stack.noEmpty（））{

try{

System.out.println（stack.getTop（））;

stack.pop（）;

}catch（Exceptione）{

//TODOAuto-generatedcatchblock

e.printStackTrace（）;

}

}

}

}

实验六队列

实验目的掌握队列的特点，理解在什么问题中应利用何种结构，熟练掌握在两种存储结构上实现队列的基本运算，特别注意队满的条件及它们的描述

实验内容入队和出队

实验要求1.利用队列实现，存储结构采用顺序结构，大小是5

2.A,B,C入队

3.出队两次

4.D,E,F入队

5.全部出队

实验实现

实验总结

分析得失，在设计中出现什么问题以及如何解决

packagecom.abc;

publicclassduilie{

inttail=0;

inthead=0;

String[]list=newString[5];

publicstaticvoidmain（String[]args）{

duilied=newduilie（）;

d.add（"A"）;

d.add（"B"）;

d.add（"C"）;

d.remove（）;

d.remove（）;

d.add（"D"）;

d.add（"E"）;

d.add（"F"）;

for（Strings:

d.list）{

System.out.println（s）;

}

}

publicvoidadd（Strings）{

if（tail>4）{

tail=0;

}

if（list[tail]==null）{

list[tail]=s;

tail++;

}else{

if（tail==head）{

for（Stringss:

list）{

System.out.println（ss）;

}

System.out.println（"队列已满"）;

System.exit（0）;

}

tail++;

add（s）;

}

}

publicvoidremove（）{

if（head>4）{

head=0;

}

list[head]=null;

head++;

}

}

实验七二叉树的存储与遍历

实验目的　掌握二叉树的非线性和递归性特点,掌握二叉树的存储结构,　　掌握二叉树的遍历（递归和非递归方式）操作的实现方法

实验内容

　　1）给出某二叉树的先序遍历序列，利用此序列建立链式存储二叉树

2）用栈实现二叉树中序遍历的非递归程序

实验要求

1）按要求编写实验程序

2）将实验程序上机调试运行,给出输出的结果

实验实现

实验总结

分析得失，在设计中出现什么问题以及如何解决