数据结构.docx

数据结构.docx

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

数据结构

数据结构实验题

本文档包含4个数据结构的实验题，每个实验题有三个部分：

题目、源代码以及运行结果。

主要内容：

实验1：

删除重复的数

实验2：

创建单链表并插入和删除第i个节点

实验3：

构造一棵二叉排序树，用中序的方法进行遍历（递归与非递归），并计算该二叉树的深度和该树中叶子结点的个数。

实验4：

:

直接插入排序（多种方法）、简单选择排序和冒泡排序、折半插入排序法。

本文档上的程序均可正确运行，但并不一定是解题的最佳办法，若是有更好解题办法的人，请指教。

（用文档上传的名字联系）

实验一

一、上机实验题目

1、编写一个程序，在一个递增有序顺序表中删除相邻重复的元素。

例如：

将表1122334455变为12345

2、编写一个程序，在一个顺序表中删除重复的元素。

例如：

将表1234512345变为12345

二、源程序及实验结果（截图）

（1）

#include

#defineN11

voidmain（）

{

inta[N],i,j,t=0;

printf（"请输入一个递增有序顺序表:

\n"）;

for（i=1;i

scanf（"%d",&a[i]）;

a[0]=a[1]-1;

for（i=1;i

{

for（j=i+1;j

{

if（a[j]==a[i]）a[j]=a[0];

else

{

t=j;

break;

}

}

i=t;

}

printf（"删除相邻重复的元素后:

\n"）;

for（i=1;i

if（a[i]!

=a[0]）

printf（"%d",a[i]）;

printf（"\n"）;

}

（2）

#include

#defineN10

voidmain（）

{

inta[N],i,j,t=0;

printf（"请输入一个顺序表:

\n"）;

for（i=0;i

scanf（"%d",&a[i]）;

for（i=0;i

{

for（j=i+1;j

{

if（a[j]==a[i]）a[j]=a[0];

}

}

printf（"删除重复的元素后:

\n"）;

for（i=0;i

if（i==0||a[i]!

=a[0]）

printf（"%d",a[i]）;

printf（"\n"）;

}

三、注意事项

1、输入一个递增有序顺序表a[N],将a[0]空出来存放找出的相同的数。

如果i=1..N,j=（i+1）..N,a[i]!

=a[j]，记下j的位置，将j赋给i，重复

2、用双for循环找出相同的数，用a[0]记下，输出时跳过该记录

实验二

一、上机实验题目

1、输入一系列整数，以0作为结束标志，建立一个单链表

2、将新元素x插入到链表中第i个位置。

3、从链表中删除第i个元素。

二、源程序及实验结果（截图）

#include

#include

typedefintDataType;

typedefstructnode

{

DataTypedata;

structnode*next;

}ListNode,*LinkList;

LinkListhcreat（LinkListhead）//利用头插法创建单链表

{

ListNode*p;

intx;

printf（"输0时结束单链表的创建\n"）;

printf（"输入元素\n"）;

scanf（"%d",&x）;

while（x!

=0）

{

p=（ListNode*）malloc（sizeof（ListNode））;//建立新结点

p->data=x;//给新结点赋值

p->next=head->next;//p结点的指针指向第一个结点

head->next=p;//头结点的指针指向p结点

scanf（"%d",&x）;

}

returnhead;

}

LinkListrcreat（LinkListhead）//利用尾插法创建单链表

{

ListNode*p,*q;

q=head;

intx;

printf（"输0时结束单链表的创建\n"）;

printf（"输入元素\n"）;

scanf（"%d",&x）;

while（x!

=0）

{

p=（ListNode*）malloc（sizeof（ListNode））;//建立新结点

p->data=x;//给新结点赋值

p->next=NULL;//p结点的指针为空

q->next=p;//q结点的指针指向p结点

q=p;

scanf（"%d",&x）;

}

returnhead;

}

intlength（LinkListhead）

{

inti=0;

ListNode*p;

p=head->next;//p指向第一个结点

while（p）//遍历链表结点p，同时计数器i加1

{

i++;

p=p->next;

}

returni;

}

voidprint（LinkListhead）//输出数据

{

ListNode*p;

p=head->next;

printf（"输出数据\n"）;

while（p）//当指针p指向空时，输出结束

{

printf（"%4d",p->data）;

p=p->next;

}

printf（"\n"）;

}

LinkListinsert（LinkListhead,DataTypex,inti）//在第i个位置插入元素

{

ListNode*p,*q,*s;

intj=1;

s=（LinkList）malloc（sizeof（ListNode））;//新建结点

s->data=x;//将要插入的值赋给结点s

s->next=NULL;

q=head->next;

if（i<0||i>length（head））{printf（"位置错误!

\n"）;return0;}//判断位置

while（j

{

p=q;

q=q->next;

j++;

}

s->next=p->next;

p->next=s;

returnhead;

}

DataTypedelet（LinkListhead,inti）//删除单链表上的第i个元素

{

ListNode*p,*q;

intj=1;

DataTypex;

q=head->next;

if（i<0||i>length（head））{printf（"位置错误!

\n"）;return0;}//判断位置

while（j

{

p=q;

q=q->next;

j++;

}

if（!

q||j>i）

{

printf（"第%d个元素不存在\n",i）;

return0;

}

else

{

p->next=q->next;

x=q->data;

free（q）;

printf（"\n删除的元素是%d\n",x）;

return1;

}

}

voidmain（）

{

intt;

LinkListhead,p;

head=（LinkList）malloc（sizeof（ListNode））;//生成头结点，并赋值给头指针

head->next=NULL;

printf（"请选择创建单链表的方法1-头插法2-尾插法:

\n"）;

scanf（"%d",&t）;

switch（t）

{

case1:

p=hcreat（head）;break;

case2:

p=rcreat（head）;break;

default:

printf（"选择错误!

"）;break;

}

print（p）;

printf（"插入第i个元素后"）;

insert（p,6,7）;

print（p）;

printf（"删除第i个元素后"）;

delet（p,3）;

print（p）;

}

三、注意事项

在本实验中，有两处容易出现错误：

1、头结点。

在创建、插入和删除，容易把有头结点和无头结点的情况弄混而出现上下不一致的错误。

2、查找第i个结点时。

指针指的位置不准确。

确定第i个位置时还需要与自己所写的算法相互对照，防止查过和少查。

实验3递归算法设计

一、实验题目

构造一棵二叉排序树，用中序的方法进行遍历（递归与非递归），并计算该二叉树的深度和该树中叶子结点的个数。

实验使用的一棵二叉排序树

要求：

1输入序列‘HQWERTYUIOPSDFG#’，#作为结束标志。

已知结点个数

时，也可不使用#结束标志。

2输入输出格式的美观。

二、源代码

#include

#include

#defineMAX100

typedefcharElemType;

typedefstructnode

{

ElemTypedata;//数据元素

structnode*lchild,*rchild;//左右孩子

}BTNode;

voidCreateBTNode（BTNode*&b,char*str）//由str串创建二叉链

{

BTNode*St[MAX],*p=NULL;

inttop=-1,k,j=0;

charch;

b=NULL;//建立的二叉树初始时为空

ch=str[j];

while（ch!

='\0'）

{

switch（ch）

{

case'（':

top++;St[top]=p;k=1;break;

case'）':

top--;break;

case',':

k=2;break;

default:

p=（BTNode*）malloc（sizeof（BTNode））;

p->data=ch;

p->lchild=p->rchild=NULL;

if（b==NULL）//p指向二叉树的根结点

b=p;

else//已建立二叉树的根结点

{

switch（k）

{

case1:

St[top]->lchild=p;break;

case2:

St[top]->rchild=p;break;

}

}

}

j++;

ch=str[j];

}

}

voidDispBTNode（BTNode*b）

{

if（b!

=NULL）

{

printf（"%c",b->data）;

if（b->lchild!

=NULL||b->rchild!

=NULL）

{

printf（"（"）;

DispBTNode（b->lchild）;

if（b->rchild!

=NULL）printf（","）;

DispBTNode（b->rchild）;

printf（"）"）;

}

}

}

voidInOrder（BTNode*b）//中序遍历的递归算法

{

if（b!

=NULL）

{

InOrder（b->lchild）;//递归访问左子树

printf（"%c",b->data）;//访问根结点

InOrder（b->rchild）;//递归访问右子树

}

}

voidInOrder1（BTNode*b）//中序遍历的非递归算法

{

BTNode*St[MAX],*p;

inttop=-1;

if（b!

=NULL）

{

p=b;

while（top>-1||p!

=NULL）

{

while（p!

=NULL）

{

top++;

St[top]=p;

p=p->lchild;

}

if（top>-1）

{

p=St[top];

top--;

printf（"%c",p->data）;

p=p->rchild;

}

}

}

}

voidInOrder2（BTNode*b）

{

BTNode*p;

struct

{

BTNode*pt;

inttag;

}St[MAX];

inttop=-1;

top++;

St[top].pt=b;

St[top].tag=1;

while（top>-1）

{

if（St[top].tag==1）

{

p=St[top].pt;

top--;

if（p!

=NULL）

{

top++;//右孩子进栈

St[top].pt=p->rchild;

St[top].tag=1;

top++;//根结点进栈

St[top].pt=p;

St[top].tag=0;

top++;//左孩子进栈

St[top].pt=p->lchild;

St[top].tag=1;

}

}

if（St[top].tag==0）

{

printf（"%c",St[top].pt->data）;

top--;

}

}

}

intBTNodeDepth（BTNode*b）//求二叉树的深度

{

intlchilddep,rchilddep;

if（b==NULL）

return0;

else

{

lchilddep=BTNodeDepth（b->lchild）;//求左子树的高度

rchilddep=BTNodeDepth（b->rchild）;//求右子树的高度

return（lchilddep>rchilddep）?

（lchilddep+1）:

（rchilddep+1）;

}

}

intLeafNodes（BTNode*b）

{

intnum1,num2;

if（b==NULL）

return0;

elseif（b->lchild==NULL&&b->rchild==NULL）//为叶子结点的情况

return1;

else

{

num1=LeafNodes（b->lchild）;

num2=LeafNodes（b->rchild）;

return（num1+num2）;//返回左右子树的叶子结点树

}

}

voidmain（）

{

BTNode*b,*p,*lp,*rp;

CreateBTNode（b,"H（E（D,F（,G））,Q（I（,O（,P））,W（R（,T（S,U））,Y）））"）;

printf（"

（1）输出二叉树:

"）;

DispBTNode（b）;

printf（"\n"）;

printf（"

（2）中序遍历二叉树:

\n"）;

printf（"递归算法:

"）;InOrder（b）;printf（"\n"）;

printf（"非递归算法1:

"）;InOrder1（b）;printf（"\n"）;

printf（"非递归算法2:

"）;InOrder2（b）;printf（"\n"）;

printf（"\n"）;

printf（"（3）二叉树的深度:

%d",BTNodeDepth（b））;

printf（"\n"）;

printf（"（4）二叉树的叶子结点个数:

%d",LeafNodes（b））;

printf（"\n"）;

}

实验四

一、上机实验题目

完成直接插入排序、简单选择排序和冒泡排序。

二、算法介绍

1、直接插入排序：

将当前无序区的第i个记录R[i]插入到有序区R[1..i-1]中适当的位置上，使R[1..i]变成新的有序区

2、让j取n至2，将R[j].key与R[j-1].key比较，如果R[j].key

3、从待排序的所有记录中选取关键字最小的记录，把它与第一个记录交换，然后在其余的记录中在选出最小的记录与第二个记录交换……

三、源程序及实验结果（截图）

#include

#include

#defineMax20

#defineN20

typedefstruct

{

intkey;

}RecType;

voidInsertSort（RecTypeR[],intn）//直接插入排序法

{

inti,j,k;

RecTypetemp;

for（i=1;i

{

temp=R[i];

j=i-1;//从右向左在有序区R[0..i-1]中找R[i]的插入位置

while（j>=0&&temp.key

{

R[j+1]=R[j];//将关键字大于R[i].key的记录后移

j--;

}

R[j+1]=temp;

printf（"i=%d",i）;

for（k=0;k

printf（"%3d",R[k].key）;

printf（"\n"）;

}

}

voidInsertSort1（RecTyper[],intn）//直接插入排序法

{

inti,j;

for（i=2;i<=n;i++）

{

if（r[i].key

{

r[0]=r[i];

j=i-1;

do

{

r[j+1]=r[j];

j--;

}while（r[0].key

r[j+1]=r[0];

}

}

}

voidInsertSort2（RecTyper[],intn）//直接插入排序法

{

inti,j;

for（i=2;i<=n;i++）

{

if（r[i].key

{

r[0]=r[i];

j=i-1;

while（r[0].key

{

r[j+1]=r[j];

j--;

}

r[j+1]=r[0];

}

}

}

voidInsertSort3（RecTyper[],intn）//直接插入排序法

{

inti,j;

for（i=2;i<=n;i++）

if（r[i].key

{

r[0]=r[i];

r[i]=r[i-1];

for（j=i-2;r[0].key

r[j+1]=r[j];

r[j+1]=r[0];

}

}

voidBubbleSort（RecTypeR[],intn）//冒泡排序

{

inti,j,k;

RecTypetemp;

for（i=0;i

{

for（j=n-1;j>i;j--）

if（R[j].key

{

temp=R[i];

R[i]=R[i-1];

R[i-1]=temp;

}

printf（"i=%d",i）;

for（k=0;k

printf（"%3d",R[k].key）;

printf（"\n"）;

}

}

voidmenu（）

{

printf（"请选择排序方法:

\n"）;

printf（"1---直接插入排序法\n"）;

printf（"2---冒泡排序法\n"）;

printf（"3---简单选择排序法\n"）;

}

voidSelectSort（RecTypeR[],intn）//简单选择排序

{

inti,j,k,l;

RecTypetemp;

for（i=0;i

{

k=i;

for（j=i+1;j

if（R[j].key

k=j;

if（k!

=i）

{

temp=R[i];

R[i]=R[k];

R[k]=temp;

}

printf（"i=%d",i）;

for（l=0;l

printf（"%3d",R[l].key）;

printf（"\n"）;

}

}

voidBinsertSort（RecTyper[],intn）//折半插入排序法

{

inti,j,low,high,m;

for（i=2;i<=n;++i）

{

r[0]=r[i];

low=1;

high=i-1;

while（low<=high）

{

m=（low+high）/2;

if（r[0].key

elselow=m+1;

}

for（j=i-1;j>=low;--j）//for（j=i-1;j>=high+1;--j）

r[j+1]=r[j];

r[low]=r[0];//r[high+1]=r[0];

}

}

voidmain（）

{

inti,k,n;

charch;

printf（"输入待排序的个数：

"）;

scanf（"%d",&n）;

printf（"输入要排序的数:

"）;

inta[N];

for（i=0;i

scanf（"%d",&a[i]）;

RecTypeR[Max];

for（i=0;i

R[i].key=a[i];

printf（"\n"）;

printf（"初始关键字"）;

for（k=0;k

printf（"%3d",R[k].key）;

printf（"\n"）;

menu（）;

scanf（"%d",&k）;

switch（k）

{

case