南航计算机软件数据结构上机实践报告_数据结构上机实习报告
南航计算机软件数据结构上机实践报告由刀豆文库小编整理，希望给你工作、学习、生活带来方便，猜你可能喜欢“数据结构上机实习报告”。
数据结构实践报告整理 031040102 刘玉 简述每一部分的对象、目的和要求；
画出程序流程图；另附A4纸手绘； 附源程序清单； 实验的收获：遇到的问题以及解决的办法、方法的优缺点。
实验一 单链表的基本操作与运算
题目一：单链表的定义、创建、插入和删除操作，将数据元素显示出来。
本题目针对单链表。联表示通过一组任意的存储单元来存储线性表格中的数据元素。为了建立起数据元素之间的存储关系，设置每一个结点，结点既存放数据data，又存放其后继地址的部分next。而每个结点中只有一个指向后继的指针，所以称其为单链表。本题目的要求是创建一个新的链表，并且完成链表的创建定义。链表是一种动态管理的存储结构，链表中的每一个结点所占用的空间是根据运行是的实际需要的空间生成的。因此建立单链表是从空链表开始的，每次读入一个数据元素就申请一个结点链表的一段。在单链表中插入一个结点不需要移动元素指针的指向。而删除则需要找到木比啊偶元素的前驱结点，并且修改指针的指向。题目一需要的操作就是，对于一个新建的空链表，以其为对象进行具体的数据的插入填写。待链表中存有数据后，再进行数据的整理查找，然后删除目标数据。
//031040102单链表 #include #define SLNODE struct node SLNODE
//定义一个链表 { int data;SLNODE *next;};void CREATE_SL(SLNODE *h)//创建一个单链表 { SLNODE *p,*s;int x;h->next=NULL;
cout
cin>>x;
//开始输入数据
while(x!=-1)
{
s=new SLNODE[sizeof(SLNODE)];
//申请一个动态新空间
s->data=x;
if(h->next==NULL)
h->next=s;
else
p->next=s;
p=s;
cin>>x;
}
p->next=NULL;
//链表最后指向空 };int Insert_LinkList(SLNODE *h,int i,int x)
//在单链表第i个位置插入x {
SLNODE *p,*s;int j=0;
p=h;while(p->next!=NULL&&j
{
p=p->next;
j++;
}
if(j!=i-1){
cout
return 0;}
else {
s=new SLNODE[sizeof(SLNODE)];
s->data=x;
s->next=p->next;
p->next=s;
return 1;
} };int Del_LinkList(SLNODE *h,int i)
//删除单链表上第i个结点 {
SLNODE *p,*s;int j=0;p=h;while(p->next!=NULL&&j
p=p->next;j++;
} if(j!=i-1){
cout
return 0;4 6 8 9 7 2 6 9 7 5-1 } 链表数据如下
else 4 6 8 9 7 2 6 9 7 5 { 输入需插入的数据8
if(p->next==NULL)输入需插入的结点3
{ 插入成功
cout
return 0;输入需删除的结点 4
} 删除成功
else 链表数据如下
{s=p->next;p->next=s->next;
7 2 6 9 7 */
//删除结点
Deletes;
//释放结点空间
return 1;
} } };void Print_LinkList(SLNODE *h)//输出链表中所有元素
{ SLNODE *p;p=h->next;coutnext!=NULL;p=p->next){
coutdatadatanext=NULL;CREATE_SL(h);Print_LinkList(h);cout>x;cout>i;if(Insert_LinkList(h,i,x))
cout
cout>i;if(Del_LinkList(h,i))
cout
cout
实验一的收获
实验一让我对于链表的创建于定义有了更多的接触与认识。之前的学习经验里主要是 扎实，VC++，涉及链表的内容，我学的不够所以这次在软件基础时间里重新再次
学习。题目一比较简单，设仅是创建和插入以及删除的基本操作。实验一的困难较小，我也是比较顺利参照课本，完成体题目一，也让我对于进一步学习链表有了兴趣和动力。由浅入深，我会一点点开展学习。在图书馆借阅一本《数据结构教程上机实验指
导》，里面对于实验的指导比较全面而且有很多实例可以参考。
上机实践二 题目二：栈、队列的顺序存储结构、链式存储结构的定义、创建、插入和删除操作，将数据元素显示出来。本题目要求掌握栈和列队。栈和列队是
两种常见的数据结构。它们的逻辑结构和线性表相同。其特点是，插入和删除等运算的位置有所限制：栈是按照先进后出的规则进行操作，而是按照先进先出的规则进行操作。堆栈技术现在的应用非常广泛，不管是编译软件还是程序设计，在操作系统和事务管理中则是广泛应用了队列技术。栈是限制在一段进行插入和删除的线性表，允许插入删除的这一端称为栈顶，固定端称为栈底。栈是运算受到限制的一种线
性表，采用顺序存储的是顺序栈，采用链式存储的是链栈。题目要求对于两种存储结构
的栈进行定义创建。对于顺序栈，首先需要申请共享的一位数组空间。即为先置空栈，然后入栈插入元素（特别要注意栈满不能插入），删除出栈（特别要注意栈空不能出栈）。对于链栈，采用带头指针的单链表来实现.队列操作的顺序队列，插入在表的队尾一端，删除在表的另外的队头一端。队的队头和队尾都是活动的，特别地需要设置队头和队尾两个指针。需要实现置空队、入队、出对、以及判别队列是否为空的运算。对于链式队列，通常是用带头结点的单链表实现的，并且设置一个队头指针（始终指向头结点）和一个队尾指针（指向当前的最后一个元素），特别地，当队列为空时队头和队尾指针均指向头结点。显示创建一个带头结点的空队，申请头尾结点，然后进行如对操作不断申请新的结点，还需要进行队列是否为空的判断操作，队空则出队失败。
//031040102 顺序栈 #include #define MaxSize 1024 #define ElemType int Typedef struct stack //定义一个栈 { ElemType data[MaxSize];int top;}SqStack;SqStack *Init_SeqStack()//栈的初始化 { SqStack *s;s=new SqStack[sizeof(SqStack)];s->top=-1;return s;};int IsEmpty_SeqStack(SqStack *s)//判空栈 { if(s->top==-1)
return 1;else
return 0;};int Push_SeqStack(SqStack *s,ElemType x)//入栈 { if(s->top==MaxSize-1)
return 0;else {
s->top++;
s->data[s->top]=x;
return 1;
}
};int Pop_SeqStack(SqStack *s,ElemType x)
//出栈
{ if(IsEmpty_SeqStack(s))
return 0;else
{
x=s->data[s->top];
s->top--;
return 1;
}
};
ElemType Top_SeqStack(SqStack *s)
//取出栈顶元素 {
if(IsEmpty_SeqStack(s))
return 0;
else
return(s->data[s->top]);
};void Print(SqStack *s)
//输出栈内所有元素 {
if(IsEmpty_SeqStack(s))
cout
此栈为空
“
cout
for(int i=s->top;i>-1;i--)
coutdata[i]
} };void main(){ SqStack *s;int x;
s=Init_SeqStack();cout
输入一组以-1结尾的数”>x;while(x!=-1){
s->top++;
s->data[s->top]=x;
cin>>x;} Print(s);cout>x;if(Push_SeqStack(s,x))
cout
cout
Print(s);
delete p;if(Pop_SeqStack(s,x))
return top;
cout
cout
Print(s);} 输入一组以-1结尾的数 5 8 9 7 3 6 2 1 8-1 栈内元素为 8 1 2 6 3 7 9 8 5 输入需插入的数4 插入成功 栈内元素为 4 8 1 2 6 3 7 9 8 5 删除成功 栈内元素为 8 1 2 6 3 7 9 8 5 //031040102 链栈 #include #define LinkStack struct linkstack #define elemtype int LinkStack
//定义一个链栈 { elemtype data;LinkStack *next;};LinkStack *Init_LinkStack()//链栈的初始化 { LinkStack *top;top=new LinkStack[sizeof(LinkStack)];top=NULL;return top;};LinkStack *Push_LinkStack(LinkStack *top,elemtype x)
//数据入栈 { LinkStack *s;s=new LinkStack[sizeof(LinkStack)];s->data=x;s->next=top;top=s;return top;};LinkStack *Pop_LinkStack(LinkStack *top,elemtype x)
//数据出栈 { LinkStack *p;if(top==NULL)
return NULL;else {
x=top->data;
p=top;
top=top->next;//输出栈内所有元素 { LinkStack *p;p=top;if(p==NULL)
cout
cout
for(;p->next!=NULL;p=p->next)
coutdata
coutdata>x;while(x!=-1){
s=new LinkStack[sizeof(LinkStack)];
s->data=x;
s->next=top;
top=s;
cin>>x;} Print(top);cout>x;top=Push_LinkStack(top,x);Print(top);top=Pop_LinkStack(top,x);Print(top);} 输入一组以-1结尾的数 7 9 8 4 3 6 1 23 65-1 栈内元素为 65 23 1 6 3 4 8 9 7
输入需插入的数15 栈内元素为 15 65 23 1 6 3 4 8 9 7 栈内元素为 65 23 1 6 3 4 8 9 7
//031040102 顺序队列 #include #define MaxSize 1024 #define ElemType int
typedef struct queue //定义一个顺序队列 { ElemType data[MaxSize];int rear,front;}SeQueue;SeQueue*Init_Queue()//队列的初始化 { SeQueue *sq;sq=new SeQueue[sizeof(SeQueue)];sq->front=sq->rear=-1;return sq;};int IsEmpty_Queue(SeQueue *sq)//判空队列 { if(sq->rear==-1)
return 1;else
return 0;};int In_Queue(SeQueue *sq,ElemType x)
//入队 { if(sq->rear==MaxSize-1)
return 0;else {
sq->rear++;
sq->data[sq->rear]=x;
return 1;} };int Out_Queue(SeQueue*sq)
//出队 { if(IsEmpty_Queue(sq))
return 0;else {
sq->front++;
return(sq->data[sq->front]);} };int Front_Queue(SeQueue *sq)//读队头元素 { if(IsEmpty_Queue(sq))
return 0;else {
return(sq->data[sq->front+1]);} };void Print(SeQueue *sq)//输出队列所有元素 { if(IsEmpty_Queue(sq))
cout
cout
for(int i=sq->front+1;irear;i++)
coutdata[i]
cout
cin>>x;while(x!=-1){
sq->rear++;
sq->data[sq->rear]=x;
cin>>x;} Print(sq);cout>x;if(In_Queue(sq,x))
cout
cout
cout
cout #define QNODE struct QNODE #define ElemType int QNODE
//定义链队的结点类型 {
ElemType data;QNODE *next;};
typedef struct linkqueue
p=q->front->next;
//封装头尾指针
if(IsEmpty_LQueue(q)){
cout
cout
队列内元素为
“
{
for(;p->next!=q->rear->next;p=p->next)LinkQueue *q;
coutdata
coutdata
} //申请头尾节点
p=new QNODE[sizeof(QNODE)];//申请链队头结点
p->next=NULL;q->front=q->rear=p;return q;};void In_LQueue(LinkQueue *q,ElemType x)//入队操作 {
QNODE *p;p=new QNODE[sizeof(QNODE)];//申请新结点
p->data=x;p->next=NULL;q->rear->next=p;q->rear=p;};int IsEmpty_LQueue(LinkQueue *q)//判队空 { if(q->front==q->rear)
return 1;else
return 0;};int Out_LQueue(LinkQueue *q,ElemType x)//出队操作 { QNODE *p;if(IsEmpty_LQueue(q))
return 0;else {
p=q->front->next;
q->front->next=p->next;
x=p->data;
delete p;
if(q->front->next==NULL)
//一个元素时，出队后队空还要改队尾指针
q->rear=q->front;
return 1;} };void Print(LinkQueue *q){ QNODE *p;};
void main(){ LinkQueue *q;QNODE *s;int x;
q=Init_LQueue();cout>x;while(x!=-1)
{
s=new QNODE[sizeof(QNODE)];
s->data=x;
s->next=NULL;
q->rear->next=s;
q->rear=s;
cin>>x;
}
Print(q);cout>x;In_LQueue(q,x);Print(q);if(Out_LQueue(q,x))
cout
else
cout
队列内元素为 8 9 4 5 3 2 1
实验二的收获
实验二是全新的知识需要理解。在之前的学习经历中没有接触到栈和队列。所以这
次是从概念开始学习的。在具体程序的学习应用时候，我对于书上提到的，首先需要的是为栈申请共享空间，有了理解和认识。特别地，在栈空的时候有s->top[0]==-1;s->top[1]==Maxsize。再有就是栈满的时候不可以入栈操作，未满的入栈操作则是先移动再赋入值。例如语句(两句的顺序不可以颠倒)s->top++;s->data[s->top]=x;由于栈的主要运算是在栈顶插入、删除。因此我在链表的头部作为栈顶，这样方便了程序，而且不需要像单链表一样为了运算方便附加一个头结点。在联系队列的相关程序时候，我理解了，列队单向空间无法利用，即为前面的已经被指针制动过的空间不能释放也无法利用。除此，队列的操作里面。有可能出现“队满”“队空”的条件相同，front==rear;需要具体区分。
上机实践三
题目三：二叉树的链式存储结构的数据结构定义、创建、先序和后序遍历，并将结果序列输出。
二叉树是有限个元素的集合，该集合或者为空、或者由一个称为根的元素以及两个不相交的、被称为左子树右子树的二叉树组成。二叉树的脸是存储结构是指，用链表来表示一颗二叉树，即用链表来表示元素的逻辑关系。二叉树的链表存储的结点有三个域组成，除了数据域外，还有两个指针域，分别用来指向该节点的左子结点和右子结点的存储地址。当左子结点或者右子结点不存在的时候，相应的指针值域为空。二叉树的遍历是指按照某种顺序结构访问二叉树的每个结点，使每个结点仅被访问一次。限定先左后右，只有三种方式即为先序遍历、中序遍历、后序遍历。遍历其实是一个递归的过程，若二叉树为空，则遍历结束，不然就按照顺序依次访问根结点、左结点、右结点。
//031040102 二叉树 #include #define elemtype char typedef struct BiTNode
//定义二叉树结点 { elemtype data;
BiTNode *lchild,*rchild;//两结点指针
}BiTree;
BiTree *Create()//二叉树的创建,递归算法 { BiTree *bt;elemtype ch;cin>>ch;if(ch=='0'){
bt=NULL;} else {
bt=new BiTNode[sizeof(BiTNode)];
bt->data=ch;
bt->lchild=Create();
bt->rchild=Create();} return bt;};
void PreOrder(BiTree *bt)
//先序遍历二叉树，递归算法 { if(bt==NULL)
return;coutdatalchild);PreOrder(bt->rchild);};
void PostOrder(BiTree *bt)
//先序遍历二叉树，递归算法 { if(bt==NULL)
return;PostOrder(bt->lchild);PostOrder(bt->rchild);coutdata
void main(){ BiTree *bt;cout
输入所需字符（空结点以零代替）frt0e000qj00m00
先序遍历可得二叉树元素为 f r t e q j m 后序遍历可得二叉树元素为 e t r j m q f
实验三的收获
二叉树可以用计算机语言来读取，通过遍历可以恢复二叉树。通过这次试验更加深刻理解二叉树。本体操作不断调用函数，递归实现遍历。实际需要的时候对于已知的二叉树的每个结点逐一访问。一次完整的便利科室的一个二叉树的结点信息由非线性排列转变为意义上的线性排列。在二叉树的链表中无法根据结点找到其父结点。不过，二叉树的链表结构灵巧简便、操作方便。特别地还节省空间。对于一个庞大的工程型程序的话，空间与简便十分重要。同样的目的，同样的结果，需要比较选择，肯定是精巧简单操作性强等等优势作为判断取舍。
上机实践四
题目四：查找：顺序查找、二分查找
查找是许多程序中最为耗费时间的部分。因此需要方法提高运行的速度和效率。顺序查找又称为线性查找，也是最为基本的查找方法之一。具体实现为：从表的一端开始，依次将关键码与给定的值比较，若找到查找成功，并且给出数据元素在表中的位置，若整个表查找完成仍未找到相同的关键码，则查找失败给出失败信息。
二分法查找只适用于顺序存储的有序表。有序表即是表中数据元素按照关键码的升序或者降序排列。去中间元素作为比较对象，若给定值与中间元素的关键码相等，则为查找成功；若给定值小于中间元素的关键码，则在中间元素的左半区继续查找，若给定值大于中间元素的关键码，则在中间元素的右半区继续查找。不断重复上述的查找过程直到查找成功，或者所查找的区域，没有该元素查找失败。
//031040102顺序查找 #include #define KeyType int #define ElemType int
#define MaxSize 1024 typedef struct { KeyType key;
//定义关键码字段
ElemType elem;//定义其他字段 }elemtype;
typedef struct
//顺序存储结构定义 { elemtype elem[MaxSize];//定义数组
int length;
//表长度 }S_TBL;
S_TBL *Init_S_TBL()
//顺序表的初始化 { S_TBL *s;s=new S_TBL[sizeof(S_TBL)];s->length=-1;return s;};
int s_search(S_TBL *tbl,KeyType kx)//在表tbl中查找关键码为kx的数据元素 { tbl->elem[0].key=kx;
//存放检测
for(int
i=tbl->length;tbl->elem[i].key!=kx;i--);
//从表尾向前查找
return i;};
void main(){ S_TBL *tbl;tbl=Init_S_TBL();int i,k;cout>k;while(k!=-1){
tbl->length++;
i=tbl->length+1;
tbl->elem[i].key=k;
cin>>k;} i=1;cout>k;while(k!=-1){
tbl->elem[i].elem=k;
i++;
cin>>k;} cout>k;i=s_search(tbl,k);if(i)
{
flag=mid;
cout
break;
coutelem[i].elem
} } } else return flag;
cout #define KeyType int #define ElemType int #define MaxSize 1024 typedef struct { KeyType key;
//定义关键码字段
ElemType elem;
//定义其他字段 }elemtype;typedef struct
//顺序存储结构定义 { elemtype elem[MaxSize];//定义数组
int length;
//表长度 }S_TBL;S_TBL *Init_S_TBL()
//顺序表的初始化 { S_TBL *s;s=new S_TBL[sizeof(S_TBL)];s->length=-1;return s;};int Binary_search(S_TBL *tbl,KeyType kx)//在表tbl中查找关键码为kx的数据元素 { int mid,flag=0,low=1,high=tbl->length;//1.设置初始区间
while(low
//2.表空测试
{
//非空，进行比较测试
mid=(low+high)/2;
//3.得到中间点
if(kxelem[mid].key)
high=mid-1;
//调整到左半区
else if(kx>tbl->elem[mid].key)
low=mid+1;
//调整到右半区
else
{ //返回该元素在表中的位置，或返回0 };void main(){ S_TBL *tbl;tbl=Init_S_TBL();int i,k;cout>k;while(k!=-1){
tbl->length++;
i=tbl->length+1;
tbl->elem[i].key=k;
cin>>k;} i=1;cout>k;while(k!=-1){
tbl->elem[i].elem=k;
i++;
cin>>k;} cout>k;i=Binary_search(tbl,k);if(i){
cout
coutelem[i].elem
}
else
cout
-1结尾的数(数据元素)33 22 11 55 99 77 88 66 44-1 输入所需查找数的关键码字段3 查找成功
所查找的数为33 实验四的收获
查找的程序对我来说不陌生。两种基本方法的比较和应用里，我留意了最大查找次
数的不同。顺序查找的进行，如果查找不成功那么会议共比较N+1次。当数据量很大的时候，平均查找长度过大，当然顺序查找对于数据的存贮方式没有任何的要求。折半查找会有一个平均查找长度以及查找的最大长度。
我比较倾向于这本查找，其查找的效率明显会高于顺序查找。特别地，我还留意到对于单链表结构，无法进行二分法的查找，因为全部的元素的定位只能从指针开始。对于线性列表只能采取顺序查找的方式。
上机实践五
题目五：排序(插入排序选择排序冒泡排序)排序是数据处理中经常使用的一种重要的运算，其目的就是将一组数据按照规定的顺序进行排列。排序的目的是便于查询和处理。插入排序的基本思想是每一步将一个待排序的元素，按照其关键字吗的大小，插入到前面已经排序号的一组元素的适当的位置上，知道所有的元素都插入为止。一般地认为插入排序是一个稳定的排序方法。选择排序，每次从当前待排序的记录中，通过依次地进行关键字妈的比较从中选择一个关键字最小的记录，并且把它与当前待排序的第一个记录进行交换。直接选择排序是一个不稳定的排序方法。冒泡排序是一种简单的交换排序的方法。一次地比较相邻两个记录的关键字，若发现两个记录的次序相反（即位前一个记录的关键字大雨后有一个记录的关键字），进行记录的交换一直到没有反序为止。极端情况下，冒泡排序会有最短与最长时间，整个队列越是接近有序，则冒泡排序的进行次数越少。
//031040102 插入排序 #include #define KeyType int #define ElemType int #define MaxSize 1024 typedef struct { KeyType key;
//定义关键码字段
ElemType elem;
//定义其他字段 }elemtype;
typedef struct
//顺序存储结构定义 { elemtype elem[MaxSize];
//定义数组
int length;
//表长度 }S_TBL;
S_TBL *Init_S_TBL()
//顺序表的初始化 { S_TBL *s;s=new S_TBL[sizeof(S_TBL)];s->length=-1;return s;};
int Binary_search(S_TBL *tbl,KeyType kx)//在表tbl中查找关键码为kx的数据元素 { int mid,flag=0,low=1,high=tbl->length;//1.设置初始区间
while(low
//2.表空测试
{
//非空，进行比较测试
mid=(low+high)/2;
//3.得到中间点
if(kxelem[mid].key)
high=mid-1;
//调整到左半区
else if(kx>tbl->elem[mid].key)
low=mid+1;
//调整到右半区
else
{
flag=mid;
break;
//查找成功，元素位置设置到flag中
} } Return flag;//返回该元素在表中的位置，或返回0 };
void main(){ S_TBL *tbl;tbl=Init_S_TBL();int i,k;cout>k;while(k!=-1){
tbl->length++;
i=tbl->length+1;
tbl->elem[i].key=k;
cin>>k;} i=1;cout>k;
while(k!=-1)};{ void Print(RecType R[],int n)
tbl->elem[i].elem=k;
i++;
cin>>k;} cout>k;i=Binary_search(tbl,k);if(i){
cout
coutelem[i].elem
cout #define keytype int #define itemtype int #define MaxSize 50 typedef struct RecType //定义排序记录的形式 { keytype key;itemtype otherinfo;}RecType;void SelectSort(RecType R[],int n)//选择排序函数 { int i,j,k;for(i=1;i
k=i;
for(j=i+1;j
if(R[j].key
k=j;
if(k!=i)
{
R[0]=R[k];
R[k]=R[i];
R[i]=R[0];
} } //输出数组内所有元素 { cout
cout
cout>x;while(x!=-1){
R[++n].key=x;
cin>>x;} n=0;cout>x;while(x!=-1){
R[++n].otherinfo=x;
cin>>x;}
cout
排序前
”
Print(R,n);SelectSort(R,n);cout
7 4 1 5 6 8 3-1
请输入一组以-1结尾的数(数据元素)： 33 22 11 44 55 66 99 88 77-1 排序前 关键字段为： 6 9 7 4 1 5 6 8 3 所有元素为： 33 22 11 44 55 66 99 88
排序后 关键字段为： 1 3 4 5 6 6 7 8 9 所有元素为： 55 44 66 33 99 11 88 22 //031040102 冒泡排序 #include #define keytype int #define itemtype int
#define MaxSize 50
cin>>x;typedef struct RecType
}
//定义排序记录的形式
cout
请输入一组以
-1结尾的数(关键码字段)： //选择排序函数 { int i,j,flag;for(i=1;i
flag=1;
for(j=1;j
if(R[j+1].key
{
flag=0;
R[0]=R[j];
R[j]=R[j+1];
R[j+1]=R[0];
}
if(flag==1)
return;} };void Print(RecType R[],int n)//输出数组内所有元素 { cout
cout
cout>x;while(x!=-1){
R[++n].key=x;
cin>>x;} n=0;cout>x;while(x!=-1){
R[++n].otherinfo=x;9 8 7 4 1 5 6-1 请输入一组以-1结尾的数(数据元素)： 11 22 33 44 66 55 77 88-1 排序前： 关键字段为： 6 9 8 7 4 1 5 6 所有元素为： 11 22 33 44 66 55 77 88 排序后： 关键字段为： 1 4 5 6 6 7 8 9 所有元素为： 55 66 77 11 88 44 33 22 实验五的收获
三种不同的排序方式，都是之前C++ 学习时候的重点掌握内容。
直接插入排序的算法很简洁，也很容易实现。从空间看，它只需要一个元素的辅助，从实践看该算法的主程序运行次数只比元素的个数少一。当然由于原列表的排序状况未知，其总比较次数和总的移动次数也是未定的，取平均数约为0.25N^2。对于直接选择排序，比较次数与原表元素的排列顺序无关，移动次数有关。根据冒泡排序的思想，待排序的记录有序之
后，则在下一趟的排序时候不会再有记录的交换位置，由此，我增加了一个标记flag，来直观表示每一次的排序是否需要发生交换，无交换则已经完成可以结束冒泡。特别地冒泡排序需要增加一个附加的单元来实现元素的交换。在交换时需要留意免得出错。
·
实验一 线性表一、实验题线性表的应用———多项式计算二、程序设计思路包括每个函数的功能说明，及一些重要函数的算法实现思路一链式存储：1.void InitPoly(LNode *&p) 初始......
实习报告题 目 : 实现一个约瑟夫环程序班级：031021姓名：王帅学号：03102076一、需求分析1． 本演示程序中，利用单向循环链表存储结构存储约瑟夫环数据（即n个人的编号和密码）。2． 演示......
数据结构实验报告课程 数据结构 _ 院 系专业班级 实验地点姓 名 学 号实验时间 指导老师 数据结构上机实验报告1 一﹑实验名称：实验一——链表二﹑实验目的：1.了解线性表的逻辑结......
数据结构上机实验六实验内容:图的基本操作实验要求:1) 图的遍历与基本操作要作为函数被调用.2) 把自己使用的图结构明确的表达出来.3) 基本上实现每个实验题目的要求.分组要......
西华大学数计学院学生上机实践报告 西华数学与计算机学院上机实践报告课程名称：数据结构 指导教师：唐剑梅 上机实践名称：上机实践编号：1 年级： 2011 姓名：蒋俊 学号：3120110806111......
