数据结构实验5查找排序算法
实验五、查找排序算法得实现
一、 实验目得
1.掌握顺序、二分法查找方法及适用场合,并能在解决实际问题时灵活应用。
2.掌握各种排序(直接插入,希尔,冒泡,快速排序,简单选择,堆排序等)方法及
适用场合,并能在解决实际问题时灵活应用。
二、 实验内容
随机输入(或随机产生)30个数
(1)采用冒泡排序完成对这30个数得排序
(2)采用顺序、折半查找在(1)中排好序得数据中完成查找任务
(3)分别采用插入、快速与希尔完成对这30个数得排序任务,并输出每一趟排序后得结果
三、实验代码:
#include
#include
#include
#define MaxSize 100
typedef struct
{
int key;
}RecordType;
//直接插入排序
void InsertSort(RecordType r[], int length)
{
for (int i=2; i<=length;i++)
{
r[0]=r[i];
int j=i-1;
while (r[0]、key
r[j+1]=r[j];
j=j-1;
}
r[j+1]=r[0];
}
}
//冒泡排序
void BubbleSort(RecordType r[], int length)
{
int t;
for (int i=1; i<=length; i++)
{
for (int j=1; j<=length-i; j++)
{
if (r[j]、key>r[j+1]、key)
{
t = r[j+1]、key;
r[j+1]、key=r[j]、key;
r[j]、key=t;
}
}
}
}
//快速排序
int QKPass(RecordType r[], int left, int right)
{
int low=left;
int high=right;
r[0]=r[left];
while (low < high)
{
while (low
{
high--;
}
if (low < high)
{
r[low] = r[high];
low++;
}
while (low < high && r[low]、key < r[0]、key)
{
low++;
}
if (low < high)
{
r[high] = r[low];
high--;
}
}
r[low] = r[0];
return low;
}
void QKSort(RecordType r[], int low, int high)
{
if (low < high)
{
int pos=QKPass(r,low,high);
QKSort(r, low, pos-1);
QKSort(r, pos+1, high);
}
}
//希尔排序
void ShellInsert(RecordType r[], int length, int delta)
{
int i, j;
for (i=1+delta; i<=length; i++)
{
if (r[i]、key < r[i-delta]、key)
{
r[0] = r[i];
for (j=i-delta; j>0 && r[j]、key>r[0]、key; j-= delta)
{
r[j+delta] = r[j];
}
r[j+delta] = r[0];
}
}
}
void ShellSort(RecordType r[], int length, int delta[], int n)
{
for (int i=0; i
ShellInsert(r, length, delta[i]);
}
}
void ShowResult(RecordType* r, int length)
{
for (int i=1; i<=length; i++)
{
printf("%-5d", r[i]);
if (i%10==0)
{
printf("\n");
}
}
}
void RandNum(RecordType r[MaxSize])
{
srand((unsigned)time(NULL));
for (int i=1; i<=30;i++)
{
r[i]、key=rand()%100+1;
printf("%-5d",r[i]);
if (i%10==0)
{
printf("\n");
}
}
}
int SeqSearch(RecordType* r,int length,int n)
{
int i;
for(i=0;i
return i;
return(-1);
}
int BinSearch(RecordType* r,int length,int n)
{
int low,mid,high;
low=0;high=length-1;
while(low<=high)
{
mid=(low+high)/2;
if(r[mid]、key==n) return(mid);
else if(r[mid]、key>n) high=mid-1;
else low=mid+1;
}
return (-1);
}
void Select()
{
printf("------------排序算法-----------\n");
printf("* * * * 1: 冒泡排序 * * * *\n");
printf("* * * * 2: 插入排序 * * * *\n");
printf("* * * * 3: 快速排序 * * * *\n");
printf("* * * * 4: 希尔排序 * * * *\n");
printf("-------------------------------\n");
}
int main(void)
{
int n, m;
int j;
RecordType r[31] ;
int delta[]={15,7,3,1};
Select();
do
{
printf("请选择排序算法:");
scanf("%d", &m);
switch (m)
{
case 1:
printf("您选择了冒泡排序!\n");
printf("\n");
printf("产生得随机待排序列为:\n");
RandNum(r);
BubbleSort(r, 30);
printf("排序结果为:\n");
ShowResult(r, 30);
printf("请输入要查找得数:");
scanf("%d",&j);
printf("顺序查找结果:该数就是第%d位\n",SeqSearch(r,30,j));
printf("折半查找结果:该数就是第%d位\n",BinSearch(r,30,j));
break;
case 2:
printf("您选择了直接插入排序!\n");
printf("\n");
printf("产生得随机待排序列为:\n");
RandNum(r);
InsertSort(r, 30);
printf("排序结果为:\n");
ShowResult(r, 30);
break;
case 3:
printf("您选择了快速排序!\n");
printf("\n");
printf("产生得随机待排序列为:\n");
RandNum(r);
QKSort(r, 1, 30);
printf("排序结果为:\n");
ShowResult(r, 30);
break;
case 4:
printf("您选择了希尔排序!\n");
printf("\n");
printf("产生得随机待排序列为:\n");
RandNum(r);
ShellSort(r, 30, delta, 4);
printf("排序结果为:\n");
ShowResult(r, 30);
break;
default:
printf("输入有误！");
return false;
break;
}
} while (true);
return 0;
}
数据结构实验报告八-快速排序
实验8 快速排序1．需求分析（1）输入的形式和输入值的范围：第一行是一个整数n，代表任务的件数。
接下来一行，有n个正整数，代表每件任务所用的时间。
中间用空格或者回车隔开。
不对非法输入做处理，及假设用户输入都是合法的。
（2）输出的形式：输出有n行，每行一个正整数，从第一行到最后一行依次代表着操作系统要处理的任务所用的时间。
按此顺序进行，则使得所有任务等待时间最小。
（3）程序所能达到的功能：在操作系统中，当有n 件任务同时来临时，每件任务需要用时ni，输出所有任务等待的时间和最小的任务处理顺序。
（4）测试数据：输入请输入任务个数：9请输入任务用时：5 3 4 2 6 1 5 7 3输出任务执行的顺序：1 2 3 3 4 5 5 6 72．概要设计（1）抽象数据类型的定义：为实现上述程序的功能，应以整数存储用户的第一个输入。
并将随后输入的一组数据储存在整数数组中。
（2）算法的基本思想：如果将任务按完成时间从小到大排序，则在完成前一项任务时后面任务等待的时间总和最小，即得到最小的任务处理顺序。
采取对输入的任务时间进行快速排序的方法可以在相对较小的时间复杂度下得到从小到大的顺序序列。
3．详细设计（1）实现概要设计中定义的所有数据类型：第一次输入的正整数要求大于零，为了能够存储，采用int型定义变量。
接下来输入的一组整数，数据范围大于零，为了排序需要，采用线性结构存储，即int类型的数组。
（2）实现程序的具体步骤：一.程序主要采取快速排序的方法处理无序数列：1．在序列中根据随机数确定轴值，根据轴值将序列划分为比轴值小和比轴值大的两个子序列。
2．对每个子序列采取从左右两边向中间搜索的方式，不断将值与轴值比较，如果左边的值大于轴值而右边的小于轴值则将二者交换，直到左右交叉。
3．分别对处理完毕的两个子序列递归地采取1，2步的操作，直到子序列中只有一个元素。
二.程序各模块的伪代码：1、主函数int main(){int n;cout<<"请输入任务个数：";cin>>n;int a[n];cout<<"请输入任务用时：";for(int i=0;i<n;i++) cin>>a[i];qsort(a,0,n-1); //调用“快排函数”cout<<"任务执行的顺序：";for(int i=0;i<n;i++) cout<<a[i]<<" "; //输出排序结果}2、快速排序算法：void qsort(int a[],int i,int j){if(j<=i)return; //只有一个元素int pivotindex=findpivot(a,i,j); //调用“轴值寻找函数”确定轴值swap(a,pivotindex,j); //调用“交换函数”将轴值置末int k=partition(a,i-1,j,a[j]); //调用“分割函数”根据轴值分割序列swap(a,k,j);qsort(a,i,k-1); //递归调用，实现子序列的调序qsort(a,k+1,j);}3、轴值寻找算法：//为了保证轴值的“随机性”，采用时间初始化种子。
《数据结构》实验报告
苏州科技学院数据结构（C语言版）实验报告专业班级测绘1011学号10201151姓名XX实习地点C1 机房指导教师史守正目录封面 (1)目录 (2)实验一线性表 (3)一、程序设计的基本思想，原理和算法描述 (3)二、源程序及注释（打包上传） (3)三、运行输出结果 (4)四、调试和运行程序过程中产生的问题及采取的措施 (6)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (6)实验二栈和队列 (7)一、程序设计的基本思想，原理和算法描述 (8)二、源程序及注释（打包上传） (8)三、运行输出结果 (8)四、调试和运行程序过程中产生的问题及采取的措施 (10)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (10)实验三树和二叉树 (11)一、程序设计的基本思想，原理和算法描述 (11)二、源程序及注释（打包上传） (12)三、运行输出结果 (12)四、调试和运行程序过程中产生的问题及采取的措施 (12)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (12)实验四图 (13)一、程序设计的基本思想，原理和算法描述 (13)二、源程序及注释（打包上传） (14)三、运行输出结果 (14)四、调试和运行程序过程中产生的问题及采取的措施 (15)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (16)实验五查找 (17)一、程序设计的基本思想，原理和算法描述 (17)二、源程序及注释（打包上传） (18)三、运行输出结果 (18)四、调试和运行程序过程中产生的问题及采取的措施 (19)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (19)实验六排序 (20)一、程序设计的基本思想，原理和算法描述 (20)二、源程序及注释（打包上传） (21)三、运行输出结果 (21)四、调试和运行程序过程中产生的问题及采取的措施 (24)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (24)实验一线性表一、程序设计的基本思想，原理和算法描述：程序的主要分为自定义函数、主函数。
数据结构实验报告(C语言)(强力推荐)
数据结构实验实验内容和目的：掌握几种基本的数据结构：集合、线性结构、树形结构等在求解实际问题中的应用，以及培养书写规范文档的技巧。
学习基本的查找和排序技术。
让我们在实际上机中具有编制相当规模的程序的能力。
养成一种良好的程序设计风格。
实验教材：数据结构题集（C语言版）清华大学出版社2007年实验项目：实验一、栈和循环队列㈠、实验内容：①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。
本程序采用的是链栈结构，具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。
②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等，学会循环队列的实现，以便在实际问题背景下灵活运用。
本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。
㈡、实验代码①栈程序代码：#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果：②循环队列程序代码：#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误，请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为：\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为：\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为：\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果：实验二、数组㈠、实验内容：数组一般不做插入或删除操作，也就是说，一旦建立了数组，则结构中的数据元素个数和元素之间的关系就不再发生变动。
汽车牌照的排序与查找问题-数据结构与算法课程设计报告
合肥学院计算机科学与技术系课程设计报告2009 ～20010 学年第二学期课程数据结构与算法课程设计名称汽车牌照的排序与查找问题学生姓名闵晓龙学号**********专业班级08计本（2）班指导教师王昆仑20010年6月题目：汽车牌照的排序与查找问题，实现对汽车牌照按多关键字排序及快速查找。
其中汽车牌照有汉字、字母和数字混合排列，例如：皖A12345。
使用基数排序方法进行排序，并在排序的基础上，利用二分查找思想实现对汽车牌照按多关键字的查找。
一、问题分析和任务定义此程序要完成如下要求：选择一种数据结构来存储每个车辆的信息（如车主姓名,汽车等），在此基础上进行基数排序，而汽车牌照是由汉字、字母以及数字组成，即多关键字，其中字母和数字的比较是比较容易实现的，考虑到汉字的存储等各方面原因，对汉字的排序并不是很容易就能完成的，故不能直接对汉字排序。
经过分析可知，汽车牌照中的汉字是各个省市自治区的简称，共有34个。
这些汉字可以根据其汉语拼音的规则进行排序，然后预先存放到字符串数组中，这样每个汉字就对应着一个数组下标，只要对数组下标进行排序就可以实现对汉字的排序了。
在对车牌号进行查找时，先对车牌号进行排序，然后将车牌号中的汉字及字符均转换成一个长整形数据存储在一个预先定义的一个一维数组中并把需要查找的车牌号码也转换成一个长整型数据，然后在原先的一维数组中使用二分查找来查找该车牌号码对应的车辆信息。
二、数据结构的选择和概要设计1、数据结构的选择：程序要求实现对汽车牌照的排序与查找，而如果仅仅进行牌照的排序与查找，则显得程序没有太大的实用性，所以考虑在程序中加入例如车主的姓名以及车子的品牌等内容来增加程序的实用性。
为了能够更好的完成这些功能，在这里选用链表来存储所有车辆的信息，用链表中的单个节点来存储一辆汽车的信息，而对应的各个节点的域中则存储其对应的车辆信息（如车牌号码、车主姓名、车的品牌等信息）。
在存储汽车牌照中的汉字时，由于汉字在内存中占用两个字节，需要使用字符串数据来存储。
数据结构实验-实验指导书
实验一线性表操作一、实验目的1熟悉并掌握线性表的逻辑结构、物理结构。
2熟悉并掌握顺序表的存储结构、基本操作和具体的函数定义。
3熟悉VC++程序的基本结构，掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用。
4熟悉VC++操作环境的使用以及多文件的输入、编辑、调试和运行的全过程。
二、实验要求1实验之前认真准备，编写好源程序。
2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。
3不断积累程序的调试方法。
三、实验内容基本题:1对元素类型为整型的顺序存储的线性表进行插入、删除和查找操作。
加强、提高题：2、编写一个求解Josephus问题的函数。
用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。
然后使用n = 9, s = 1, m = 5，以及n = 9, s = 1, m = 0，或者n = 9, s = 1, m = 10作为输入数据，检查你的程序的正确性和健壮性。
最后分析所完成算法的时间复杂度。
定义JosephusCircle类，其中含完成初始化、报数出圈成员函数、输出显示等方法。
（可以选做其中之一）加强题：（1）采用数组作为求解过程中使用的数据结构。
提高题：（2）采用循环链表作为求解过程中使用的数据结构。
运行时允许指定任意n、s、m数值，直至输入n = 0退出程序。
实验二栈、队列、递归应用一、实验目的1熟悉栈、队列这种特殊线性结构的特性2熟练掌握栈、队列在顺序存储结构和链表存储结构下的基本操作。
二、实验要求1实验之前认真准备，编写好源程序。
2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。
3不断积累程序的调试方法。
三、实验内容基本题（必做）：1分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。
2、假设以带头结点的循环链表表示队列，并且只设一个指针指向对尾结点，不设头指针，试设计相应的置队空、入队和出队的程序。
加强题：3设线性表A中有n个字符，试设计程序判断字符串是否中心对称，例如xyzyx和xyzzyx都是中心对称的字符串。
《数据结构与算法》教案
《数据结构与算法》教案
数据结构与算法教案
一、教学目标
本课程旨在让学生掌握数据结构和算法设计的基本原理和方法，掌握数据结构和算法的基本概念和基本操作，具备较强的分析和解
决实际问题的能力。
同时，学生应该掌握常见数据结构和算法，如栈、队列、树、图、排序、查找等。
二、教学内容
1. 数据结构基础知识
- 数据结构的定义和分类
- 算法的基础概念
- 算法的复杂度分析
2. 线性结构
- 数组
- 链表
- 栈与队列
3. 树结构
- 二叉树和二叉搜索树
- 堆和优先队列
- 平衡树
4. 图结构
- 基本概念和图的表示方法
- 图的遍历
- 最短路径和最小生成树
5. 排序和查找
- 内部排序和外部排序
- 快速排序、归并排序、选择排序、插入排序和希尔排序- 二分查找、哈希表查找和树形查找
三、教学方法
1. 理论知识讲授配合实例演示
2. 小组讨论和作业设计
3. 实践 or 上机操作
四、评估方法
1. 考试：学生掌握数据结构和算法知识的理论能力
2. 作业：学生较强的实际分析和解决问题的能力
3. 上机实验：实践能力
五、教材
主教材：《数据结构与算法分析》
辅导教材：《算法设计与分析基础》、《数据结构（C++语言版）》。
形考作业四及答案
形考作业四及答案（本部分作业覆盖教材第8-9章的内容）一、单项选择题1、顺序查找方法适合于存储结构为（）的线性表。
A．散列存储B．索引存储C．散列存储或索引存储D．顺序存储或链接存储2、对线性表进行二分查找时，要求线性表必须（）。
A．以顺序存储方式B．以链接存储方式C．以顺序存储方式，且数据元素有序D．以链接存储方式，且数据元素有序3、对于一个线性表，若要求既能进行较快地插入和删除，又要求存储结构能够反映数据元素之间的逻辑关系，则应该（）。
A．以顺序存储方式B．以链接存储方式C．以索引存储方式D．以散列存储方式4、采用顺序查找方法查找长度为n的线性表时，每个元素的平均查找长度为（）。
A．n B．n/2C．(n+1)/2 D．(n-1)/25、哈希函数有一个共同的性质，即函数值应当以（）取其值域的每个值。
A．最大概率B．最小概率C．平均概率D．同等概率6、有一个长度为10的有序表，按折半查找对该表进行查找，在等概率情况下查找成功的平均比较次数为（）。
A．29/10 B．31/10 C．26/10 D．29/97、已知一个有序表为{11,22,33,44,55,66,77,88,99}，则顺序查找元素55需要比较（）次。
A．3 B．4 C．5 D．68、顺序查找法与二分查找法对存储结构的要求是（）。
A．顺序查找与二分查找均只是适用于顺序表B．顺序查找与二分查找均既适用于顺序表，也适用于链表C．顺序查找只是适用于顺序表D．二分查找适用于顺序表9、有数据{53,30,37,12,45,24,96}，从空二叉树开始逐个插入数据来形成二叉排序树，若希望高度最小，应该选择的序列是（）。
A．45,24,53,12,37,96,30 B．37,24,12,30,53,45,96C．12,24,30,37,45,53,96 D．30,24,12,37,45,96,5310、对有18个元素的有序表作二分（折半）查找，则查找A[3]的比较序列的下标可能为（）。
《数据结构排序》PPT课件
讨论：若记录是链表结构，用直接插入排序行否？折半插入 排序呢？
答：直接插入不仅可行，而且还无需移动元素，时间效率更 高！但链表无法“折半”！
折半插入排序的改进——2-路插入排序见教材P267。 （1）基本思想： P267 （2）举 例：P268 图10.2 （3）算法分析：移动记录的次数约为n2/8
13 20 39 39 42 70 85
i=8
0
1
2
3
4
5
6
7
8
Hj
折半插入排序的算法分析 • 折半查找比顺序查找快，所以折半插入排序
就平均性能来说比直接插入排序要快。
• 在插入第 i 个对象时，需要经过 log2i +1
次关键码比较，才能确定它应插入的位置。 • 折半插入排序是一个稳定的排序方法。
for ( j=i-1；j>=high+1；--j) L.r [j+1] = L.r [j]；// 记录
后移
L.r [high+1] = L.r [0]；
// 插入
} // for
} // BInsertSort
初始
30 13 70 85 39 42 6 20
012345678
i=2 13
30
13
数逐渐变多，由于前面工作的基础，大多数对象已基本有 序，所以排序速度仍然很快。
时间效率： O(n1.25）～O（1.6n1.25）——经验公式
空间效率：O（1）——因为仅占用1个缓冲单元 算法的稳定性：不稳定——因为49*排序后却到了49的前面
希尔排序算法（主程序）
参见教材P272
void ShellSort(SqList &L，int dlta[ ]，int t){
排序算法实验报告
数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的C语言程序，要求包含直接插入排序、希尔排序、简单项选择择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。
二、实验步骤各种内部排序算法的比较：1.八种排序算法的复杂度分析〔时间与空间〕。
2.八种排序算法的C语言编程实现。
3.八种排序算法的比较，包括比较次数、移动次数。
三、稳定性，时间复杂度和空间复杂度分析比较时间复杂度函数的情况：时间复杂度函数O(n)的增长情况所以对n较大的排序记录。
一般的选择都是时间复杂度为O(nlog2n)的排序方法。
时间复杂度来说：(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序；(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序；(3)O(n1+§))排序,§是介于0和1之间的常数。
希尔排序(4)线性阶(O(n))排序基数排序，此外还有桶、箱排序。
说明：当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O〔n〕；而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O〔n2〕；原表是否有序，对简单项选择择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性：排序算法的稳定性:假设待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；假设经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。
稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。
另外，如果排序算法稳定，可以防止多余的比较；稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
C语言常见排序算法
6.1.5 选择排序
排序过程：
首先通过n-1次比较，从n个数中找出最小的， 将它与第一个数 交换—第一趟选择排序，结果最小的数被安置在第一个元素位 置上 再通过n-2次比较，从剩余的n-1个数中找出关键字次小的记录， 将它与第二个数交换—第二趟选择排序 重复上述过程，共经过n-1趟排序后，排序结束
6.1.3 直接插入排序
实用例子：
已知待序的一组记录的初始排列为：21, 25, 49, 25*, 16, 08
21 25 49 25* 16 08 012345
6.1.3 直接插入排序
实用例子：
i=1
21 25 49 25* 16 08 25 012345 temp
i=2 i=3
21 25 49 25* 16 08 49 012345 temp
6.1.1Leabharlann 冒泡排序算法实例21
21
21
21
16
08
25
25
25
16
08
16
49
25
16
08
21
21
25
16
08
25
25
25
16
08
25
25
25
25
08
49
49
49
49
49
6.1.1 冒泡排序
算法实现
输入n 个数给a[1] 到 a[n] for j=1 to n-1
for i=1 to n-j
真
if ( temp < r[j-1] ) r[j] = r[j-1];