级本科数据结构实验指导书新版.docx
《级本科数据结构实验指导书新版.docx》由会员分享,可在线阅读,更多相关《级本科数据结构实验指导书新版.docx(45页珍藏版)》请在冰豆网上搜索。
级本科数据结构实验指导书新版
实验一线性表的实验
一、实验目的
1、掌握用VisualC++6.0上机调试顺序表的基本方法
2、掌握顺序表的基本操作,插入、删除、查找、以及有序顺序表的合并等算法的实现
3、掌握用VisualC++6.0上机调试单链表的基本方法
4、掌握单链表的插入、删除、查找、求表长以及有序单链表的合并算法的实现
5、进一步掌握循环单链表和双链表的插入、删除、查找算法的实现
二、实验内容
下面是顺序表的部分基本操作实现的算法,请同学们自己设计主函数和部分算法,调用这些算法,完成下面的实验任务。
/*常用的符号常量定义*/
#defineOK1
#defineERROR0
#defineMAXSIZE10
#defineLIST_INIT_SIZE10
#defineLISTINCREMENT10
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineSUCCESS1
#defineUNSUCCESS0
#defineDUPLICATE-1
#defineNULLKEY0//0为无记录标志
#defineN10//数据元素个数
#defineEQ(a,b)((a)==(b))
#defineLT(a,b)((a)<(b))
#defineLQ(a,b)((a)<=(b))
/*定义ElemType为int或别的自定义类型*/
typedefintElemType;
/*顺序存储类型*/
typedefstruct
{int*elem;
intlength;
intlistsize;
}SqList;
/*构造一个空线性表算法*/
intInitList_Sq(SqList&L)//InitList_Sq()function
{//InititialaSq_List
L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));
if(!
L.elem)return(0);
L.length=0;
L.listsize=LIST_INIT_SIZE;
return
(1);
}//endofInitList_Sq()function
/*从顺序表中查找与给定元素值相同的元素在顺序表中的位置*/
intLocateElem_Sq(SqListL,ElemTypee)//LocateElem_Sq()sub-function
{inti=1;
int*p=L.elem;
while(i<=L.length&&*p++!
=e)
++i;
if(i<=L.length)
return(i);
else
return(ERROR);
}//LocateElem_Sq()end
/*向顺序表中插入元素*/
intListInsert_sq(SqList&L,inti,inte)//ListInsert_sq()
{if(i<1||i>L.length+1)//i(location)isillegal
{cout<<"Initialfailure!
"<getch();
return(ERROR);
}
if(L.length>=L.listsize)//insertintotheendoftheSqlist
{int*Newbase;
Newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));
if(!
Newbase)
{cout<<"Overflow!
"<getch();
return(ERROR);
}
L.elem=Newbase;
L.listsize+=LISTINCREMENT;
}
int*p,*q;
q=&(L.elem[i-1]);//qpointattheelementbeforetheinsertedone
for(p=&(L.elem[L.length-1]);p>=q;--p)//movetheelement
*(p+1)=*p;
*q=e;
++L.length;
return(OK);
}//ListInser_sq()end
/*从顺序表中删除元素*/
voidListDelete_Sq(SqList&L,inti,int&e)//ListDelete_Sq()function
{
int*p,*q;
if((i<1)||(i>L.length))
{cout<
"<exit(0);
}
p=&(L.elem[i-1]);
e=*p;
q=L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1)=*p;
--L.length;
cout<<"SuccesstoDeleteSq_list!
"<}//endofListDelete_Sq()function
/*有序顺序表的合并*/
intMerge_Sq(SqList&A,SqList&B,SqList&C)//Merge_Sq()function
{//MergetheSqListAandBtoC
C.listsize=C.length=A.length+B.length;
C.elem=(ElemType*)malloc(C.listsize*sizeof(ElemType));
if(!
C.elem)
{cout<<"OverFlow!
"<return(0);
};
inti=0,j=0;//iandjistheSubscriptofA.elem[]andB.elem[]
intk=0;//kistheSubscriptofC.elem[]
while((i=B.length
if(A.elem[i]<=B.elem[j])
{C.elem[k]=A.elem[i];
i++;k++;
}//endofif
else
{C.elem[k]=B.elem[j];
j++;k++;
}//endofelse
while(i{C.elem[k]=A.elem[i];
i++;k++;
}//endofwhile
while(j{C.elem[k]=B.elem[j];
j++;k++;
}
cout<<"SuccesstoMergeAandB!
"<return
(1);
}//endofMerge_Sq()function
下面是链表的部分基本操作实现的算法,请同学们自己设计主函数和部分算法,调用这些算法,完成下面的实验任务。
/*定义ElemType为int或别的自定义类型*/
typedefintElemType;
/*链式存储类型*/
typedefstructLNode
{ElemTypedata;
structLNode*next;
}LNode,*LinkList;
/* 单链表的取元素*/
intGetElem_L(LinkListL,inti,int&e)//GetElem_L()function
{//ListheHeadPointerofLinkListwithHeadNode,whentheNo.iexist,assignthe
//valuetovariableeandreturn"OK!
"otherwisereturn"Error!
"
LNode*p;
intj=1;
p=L->next;
while(p&&j
{p=p->next;++j;}
if(!
p||j>i)
{cout<<"TheNO."<
"<getch();
exit(0);
}//endofif
e=p->data;
return(e);
}//endofGetElem_L()function
/*单链表的插入元素*/
intListInsert_L(Linklist&L,inti,inte)//ListInsert_L()sub-function
{LNode*p=L;
intj=0;
while(p&&j{p=p->next;
++j;
}
if(!
p||j>i-1)//outoflocation
{cout<<"Errer!
Thelocationisillegal!
"<return(ERROR);
}
LNode*s;
s=(Linklist)malloc(sizeof(LNode));//createnewLNode
s->data=e;
s->next=p->next;
p->next=s;
return(OK);
}//ListInsert_L()end
/*单链表的删除元素*/
intListDelete_L(LinkList&L,inti,int&e)//ListDelete_L()function
{//DeletetheNO.ielementofLinkListandreturnbyvariablee
LNode*p,*q;
intj=0;
p=L;
while(p->next&&j{p=p->next;++j;
}
if(!
p||j>i-1)
{cout<<"TheNO."<
"<getch();
return(0);
}
q=p->next;
p->next=q->next;//deletetheNO.iNode
e=q->data;
free(q);
return(e);
}//endofListDelete()function
/* 单链表的建立(头插法)*/
voidCreateList_L(LinkList&L,intn)//CreateList_L()function
{//ToCreatreaLinkListLwithHeadNode
inti;
LNode*p;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
cout<<"PleaseinputthedataforLinkListNodes:
"<for(i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode));
cin>>p->data;//ReverseorderinputingforCreatingaLinkList
p->next=L->next;
L->next=p;
}//endoffor
if(n)cout<<"SuccesstoCreateaLinkList!
"<elsecout<<"ANULLLinkListhavebeencreated!
"<}//endofCreateList()function
1、顺序表基本操作的实现。
要求生成顺序表时,可以键盘上读取元素,用顺序存储结构实现存储。
2、已知顺序表la和lb中的数据元素按非递减有序排列,将la和lb表中的数据元素,合并成为一个新的顺序表lc,lc中的数据元素仍按非递减有序排列,并且不破坏la和lb表。
3.从有序顺序表A中删除那些在顺序表B和顺序表C中都出现的元素.
4、将一顺序存储的线性表(设元素均为整型量)中所有零元素向表尾集中,其他元素则顺序向表头方向集中。
若输入:
1230050478
则输出:
1235478000
5、单链表基本操作的实现。
要求生成单链表时,可以键盘上读取元素,用链式存储结构实现存储。
6、已知单链表la和lb中的数据元素按非递减有序排列,将la和lb中的数据元素,合并为一个新的单链表lc,lc中的数据元素仍按非递减有序排列。
要求①不破坏la表和lb表的结构。
②破坏la表和lb表的结构。
7、编程实现两个循环单链表的合并。
8、线性表的逆置:
设有一个线性表(e0,e1,…,en-2,en-1),请编写一个函数将这个线性表原地逆置,即将线性表内容置换为(en-1,en-2,…,e1,e0)。
线性表中的数据可以为整数、字符或字符串,试分别采用顺序存储结构和链式结构来实现。
9、约瑟夫环的实现:
设有n个人围坐一圈,用整数序列1,2,3,……,n表示顺序围坐在圆桌周围的人,现从某个位置s上的人开始报数,数到m的人出列,接着从出列的下一个人又从1开始重新报数,数到m的人出列,如此下去,直到所有人都出列为此。
试设计确定他们的出列次序序列的程序。
如n=8,m=4,s=1时,设每个人的编号依次为1,2,3,…开始报数,则得到的出列次序为4,8,5,2,1,3,7,6。
检查程序的正确性和健壮性。
(1)采用数组表示作为求解过程中使用的数据结构。
(2)采用单向循环链表作为存储结构模拟整个过程,循环链表可不设头节点,必须注意空表和非空表的界限。
实验二栈、队列的实现及应用
一、实验目的
1、掌握栈和队列的顺序存储结构和链式存储结构,以便在实际背景下灵活运用。
2、掌握栈和队列的特点,即先进后出与先进先出的原则。
3、掌握栈和队列的基本操作实现方法。
二、实验内容
下面是栈和队列的部分基本操作实现的算法,请同学们自己设计主函数和部分算法,调用这些算法,完成下面的实验任务。
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
#defineMAXQSIZE100
#defineOK1
#defineERROR0
/*定义SElemType为int或别的自定义类型*/
typedefintSElemType;
/*顺序栈的存储类型*/
typedefstruct//definestructureSqStack()
{SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
/*构造空顺序栈*/
intInitStack(SqStack&S)//InitStack()sub-function
{S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!
S.base)
{cout<";
return(ERROR);
}
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return(OK);
}//InitStack()end
/*取顺序栈顶元素*/
intGetTop(SqStackS,SElemType&e)//GetTop()sub-function
{if(S.top==S.base)
{cout<";//ifemptySqStack
return(ERROR);
}
e=*(S.top-1);
return(OK);
}//GetTop()end
/*将元素压入顺序栈*/
intPush(SqStack&S,SElemTypee)//Push()sub-function
{if(S.top-S.base>S.stacksize)
{S.base=(SElemType*)realloc(S.base,(S.stacksize+
STACKINCREMENT*sizeof(SElemType)));
if(!
S.base)
{cout<";
return(ERROR);
}
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return(OK);
}//Push()end
/* 将元素弹出顺序栈*/
intPop(SqStack&S,SElemType&e)//Pop()sub-function
{if(S.top==S.base)
{cout<";
return(ERROR);
}
e=*--S.top;
return(OK);
}//Pop()end
/*利用顺序栈实现对于输入的任意一个非负十进制整数,输出与其等值的八进制数。
*/
voidConversion()//Conversion()function
{
SqStackS;//SisaSqStack
SElemTypeN,e;
InitStack(S);//constructeaemptystackS
printf("PleaseinputtheDeca.numberN=?
:
");
scanf("%d",&N);
while(N)
{Push(S,N%8);
N=N/8;
}
printf("ConversedtoOct.number=:
");
while(!
StackEmpty(S))//noemptythenoutput
{Pop(S,e);
printf("%d",e);
}
}//endofconversion()function
/*链式栈的存储类型*/
typedefstructSNode//definestructureLinkStack
{SElemTypedata;
structSNode*next;
}SNode,*LinkStack;
/*取链式栈顶元素*/
intGetTop_L(LinkStacktop,SElemType&e)//GetTop_L()sub-function
{if(!
top->next)
{cout<It'sanemptyLinkStack!
";
return(ERROR);
}
else
{e=top->next->data;
return(OK);
}
}//GetTop_L()end
/* 将元素压入链式栈*/
intPush_L(LinkStack&top,SElemTypee)//Push_L()sub-function
{SNode*q;
q=(LinkStack)malloc(sizeof(SNode));
if(!
q)
{cout<Allocatespacefailure!
";
return(ERROR);
}
q->data=e;
q->next=top->next;
top->next=q;
return(OK);
}//Push_L()end
/*将元素弹出链式栈*/
intPop_L(LinkStack&top,SElemType&e)//Pop_L()sub-function
{SNode*q;
if(!
top->next)
{cout<It'sanemptyLinkStack!
";
return(ERROR);
}
e=top->next->data;
q=top->next;
top->next=q->next;
free(q);
return(OK);
}//Pop_L()end
/*定义QElemType为int或别的自定义类型*/
typedefintQElemType;
/*顺序队列的存储类型*/
typedefstructSqQueue//definestructureSqQueue
{QElemType*base;
intfront;
intrear;
}SqQueue;
/* 构造空顺序队列*/
intInitQueue(SqQueue&Q)//InitQueue()sub-function
{Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
if(!
Q.base)
{cout<";
return(ERROR);
}
Q.front=Q.rear=0;
return(OK);
}//InitQueue()end
/* 求顺序队列长度*/
intQueueLength(SqQueueQ)//QueueLength()sub-function
{return((Q.rear-Q.front+MAXQSIZE)%MAXQSIZE);
}
/*在顺序队列尾插入新元素*/
intEnQueue(SqQueue&Q,QElemTypee)//EnQueue()sub-func