当前位置：文档之家 › 内部排序比较

内部排序比较

  • 格式：docx
  • 大小：142.73 KB
  • 文档页数：18

哈尔滨理工大学课程设计（数据结构）题目：内部排序算法比较班级：姓名：指导教师：系主任：2013年3月7号目录1．（内部排序算法）问题课程设计————3 1.1题目分析—————————————3 1.2数据结构—————————————3 1.3流程图——————————————4 1.4实现技术—————————————51.5设计结论和心得——————————62. （C++）代码分析——————————7 2.1功能说明—————————————13 2.2局部数据结构———————————13 2.3流程图——————————————141内部排序课程设计1.1题目分析对各种内部排序算法的时间复杂度有一个比较直观的感受，包括关键字比较次数和关键字移动次数。

将排序算法进行合编在一起，可考虑用顺序执行各种排序算法来执行，最后输出所有结果。

1.2数据结构本程序中，考虑的内容就是待排序对象，排序的依据是关键字之间的大小比较，故在每个节点的类型定义中，至少得包含关键字key一项。

不失一般性，这里就使用关键词这一项，其他都省略，具体应用加上其他数据项即可。

被排序对象是由一个个节点够成，一个排序对象包含一系列指向一串节点的指针，排序对象的长度。

本程序功能简单。

typedef struct{int key; /*关键字*/}RecordNode; /*排序节点的类型*/typedef struct{RecordNode *record;int n; /*排序对象的大小*/}SortObject; /*排序节点的类型*/用伪代码表示如下1）冒泡排序算法伪代码bubblesoft（data[ ]）{ for i=1to data.length-2 for j=data.length-1 downto j+1如果顺序错误就交换j和j-1的位置上元素；}2）选择排序算法伪代码selectionsoft（data[ ]）{ for i=1to data.length-2从data[i]，……，data[data.length-1]中选取最小的元素将它和data[i]交换；}3）插入排序算法伪代码insertionsoft（data[ ]）{ for i=1todata.length-1 tmp =data[i];将所有大于tmp的元素data[j]移动一个位置；把tmp放到正确的位置上；}为了实现这些数据结构，用C语言定义变量如下：int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high)void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ]1.3流程图1.4实现技术实现步骤如下：1.待排序长度不小于100，数据可有随机函数产生，用五组不同输入数据做比较，比较的指标为关键字参加比较的次数和关键字移动的次数；2.对结果做简单的分析，包括各组数据得出结果的解释；3.设计程序用顺序存储。

运行结果如下：元素个数为20元素个数为1001.5设计结论和心得（1）实验中的存在问题和提高存在问题：程序有待增强。

提高：界面处理简洁。

（2）收获与体会各种排序的算法排序的算法的比较次数与移动次数的计算随机数的生成2.代码分析为了进一步了解操作系统内核，学习了Linux操作系统的进程同步程序，主要程序源代码如下：#include <cstdlib>#include <iostream>using namespace std;#define LS(a,b) ((a)<(b))#define LL(a,b) ((a)>(b))#define MAXSIZE 10000typedef int KeyType;typedef struct {KeyType key;}RedType;typedef struct {RedType r[MAXSIZE+1];int length;}SqList;int compare=0;int change=0;int Create_Sq(SqList &L){int k;cout<<"20074795元素个数:";cin>>k;L.length=k;srand(time(NULL));for (int x=1; x<=k; x++){L.r[x].key= rand() % k;//随机域为0~k }return 1;}void Bubble_sort(SqList &L)//冒泡排序{int i,j,l,k=L.length,m=0,n=0;for(i=1;i<=L.length-1;++i){for(j=1;j<=k-1;++j){++m;if(LL(L.r[j].key,L.r[j+1].key)){l=L.r[j].key;L.r[j].key=L.r[j+1].key;L.r[j+1].key=l;++n;}}--k;}cout<<endl<<"-----冒泡排序后的序列-----"<<endl; for(i=1;i<=L.length;i++)cout<<""<<L.r[i].key;cout<<endl;cout<<"冒泡排序的比较次数:";cout<<m<<endl;cout<<"冒泡排序的交换次数:";cout<<n<<endl;}void InsertSort(SqList &L)//插入排序{int i,j,m=0,n=0;cout<<endl;for(i=2;i<=L.length;++i)if(LS(L.r[i].key,L.r[i-1].key)){++m;++n;L.r[0]=L.r[i];L.r[i]=L.r[i-1];for(j=i-2;LS(L.r[0].key,L.r[j].key);--j){++m;L.r[j+1]=L.r[j];}L.r[j+1]=L.r[0];}cout<<"-----直接插入排序后的序列-----"<<endl; for(i=1;i<=L.length;i++)cout<<""<<L.r[i].key;cout<<endl;cout<<"直接插入排序的比较次数:";cout<<m<<endl;cout<<"直接插入排序的交换次数:";cout<<n<<endl;}void SelectSort(SqList &L) //简单选择排序{int l,i,j,m=0,n=0;cout<<endl;for(i=1;i<L.length;++i){L.r[0]=L.r[i];j=i+1;l=i;for(j;j<=L.length;++j){++m;if(LL(L.r[0].key,L.r[j].key)){l=j;L.r[0]=L.r[j];}}if(l!=i){++n;L.r[l]=L.r[i];L.r[i]=L.r[0];}}cout<<"-----简单选择排序后的序列-----"<<endl; for(i=1;i<=L.length;i++)cout<<""<<L.r[i].key;cout<<endl;cout<<"简单选择排序的比较次数:";cout<<m<<endl;cout<<"简单选择排序的交换次数:";cout<<n<<endl;}int Partition(SqList &L,int low,int high){int pivotkey;L.r[0]=L.r[low];pivotkey=L.r[low].key;while(low<high){while(low<high&&L.r[high].key>=pivotkey){++compare;--high;}++change;L.r[low]=L.r[high];while(low<high&&L.r[low].key<=pivotkey){++compare;++low;}++change;L.r[high]=L.r[low];}L.r[low]=L.r[0];return low;}void QSort(SqList &L,int low,int high)//递归形式的快速排序算法{int pivotloc;if(low<high){pivotloc=Partition(L,low,high);QSort(L,low,pivotloc-1);QSort(L,pivotloc+1,high);}}void QuickSort(SqList &L){int i;QSort(L,1,L.length);cout<<"-----快速排序后的序列为-----"<<endl;for(i=1;i<=L.length;i++)cout<<""<<L.r[i].key;cout<<endl;cout<<"快速排序的比较次数:";cout<<compare<<endl;cout<<"快速排序的交换次数:";cout<<change<<endl;compare=0;change=0;}void ShellInsert(SqList &L,int dk)//希尔排序{int i;int j;for(i=dk+1;i<=L.length;++i)if(LS(L.r[i].key,L.r[i-dk].key)){++compare;L.r[0]=L.r[i];for(j=i-dk;j>0&&LS(L.r[0].key,L.r[j].key);j-=dk){ ++compare;++change;L.r[j+dk]=L.r[j];}L.r[j+dk]=L.r[0];}}void ShellSort(SqList &L,int dlta[])//希尔排序{int k,j=L.length/2,t=0;while(j>=0){++t;j-=2;}j=L.length/2;for(k=0;k<t;++k)//计算每次的增量值{if(j==0)j=1;//定义最后一趟排序的增量dlta[k]=j;j-=2;}for(k=0;k<t;++k)ShellInsert(L,dlta[k]);cout<<"-----希尔排序后的序列为-----"<<endl; for(k=1;k<=L.length;k++)cout<<""<<L.r[k].key;cout<<endl;cout<<"希尔排序的比较次数:";cout<<compare<<endl;cout<<"希尔排序的交换次数:";cout<<change<<endl;compare=0;change=0;}/*这里是改造后的main，他的原始形式是dev自动生成的*/int main(int argc, char *argv[]){int i;int dlta[MAXSIZE];SqList L,a,b,c,d;Create_Sq(L);a=b=c=d=L;for(i=1;i<=L.length;i++)cout<<""<<L.r[i].key;Bubble_sort(L);InsertSort(a);SelectSort(b);QuickSort(c);ShellSort(d,dlta);/*这两行是系统自动生成的main中的内容，不要删了*/system("PAUSE");return EXIT_SUCCESS;}2.1功能说明这一段程序的主要功能为：时间复杂度与空间复杂度：理论分析可以得出各种排序算法的时间复杂度和空间复杂度，如下表所示（图6）：影响排序的因素：◆待排序的记录数目n 的大小。

合集下载

数据结构-第十章-内部排序

数据结构-第十章-内部排序


0
1
2
3
4
5
6
7
8
i=5
MAXINT 49 2 3
MAXINT 49 6 3 MAXINT 49 6 3 MAXINT 49 6 8
38 1
38 1 38 1 38 1
65 97 5 0
65 5 65 5 65 5 97 0 97 0 97 0
76 4
76 4 76 4 76 4
13
27
49
i=6



最坏情况下,待排记录按关键字非递增有序 排列（逆序）时，第 i 趟时第 i＋1 个对象 必须与前面 i 个对象都做排序码比较, 并且 每做1次比较就要做1次数据移动。总比较 次 数 为 (n+2)(n-1)/2 次 ， 总 移 动 次 数 为 (n+4)(n-1)/2。 在平均情况下的排序码比较次数和对象移 动次数约为 n2/4。因此，直接插入排序的 时间复杂度为 O(n2)。 直接插入排序是一种稳定的排序方法。
折半插入排序 (Binary Insertsort)
基本思想 既然每个要插入记录之前的纪录 已经按关键字有序排列，在查找插入位 臵时就没有必要逐个关键字比较，可以 使用折半查找来实现。由此进行的插入 排序称之为折半插入排序。
折半插入排序的算法
void BInsertSort (SqList &L){ for (i=2;i<=L.length;++i){ L.r[0]=L.r[i]; low=1;high=i-1; //查找范围由1到i-1 while(low<=high){ m=(low+high)/2; if LT(L.r[0].key,L.r[m].key) high=m-1; else low=m+1; }//while 折半查找 for (j=i-1;j>=high+1;--j) L.r[j+1]=L.r[j]; //折半查找结束后high+1位臵即为插入位臵 L.r[high+1]=L.r[0]; }//for }//BInsertSort
关于排序的小知识积攒

关于排序的小知识积攒

关于排序的小知识积攒1. 排序的稳定性：如果在排序过程中，对于相同的元素，它们的相对顺序在排序前后保持不变，则称该排序算法是稳定的。

例如，在整数排序中，对于两个相等的整数 5 和 5，如果排序后它们的相对顺序没有改变，那么这个排序算法就是稳定的。

稳定性在某些应用中很重要，例如在排序一组人员名单时，希望按照姓氏字母顺序排序，并且相同姓氏的人应该保持相对顺序。

2. 内部排序和外部排序：根据排序操作是否在内存中完成，排序可以分为内部排序和外部排序。

内部排序是指在内存中进行排序，适用于数据量较小的情况。

常见的内部排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等。

外部排序是指在内存无法容纳全部数据时，需要使用外部存储（如磁盘）来辅助排序。

外部排序通常涉及数据的分割、排序和合并过程。

3. 时间复杂度和空间复杂度：评估排序算法的性能通常考虑时间复杂度和空间复杂度。

时间复杂度是指算法执行所需的时间与问题规模的增长关系，通常用大 O 表示法表示。

常见的时间复杂度包括 O(n^2)、O(nlogn)、O(n)等。

空间复杂度是指算法在执行过程中所需的额外存储空间与问题规模的增长关系。

一些排序算法可能需要额外的存储来保存中间结果或进行递归操作。

4. 排序算法的选择：不同的排序算法在不同的情况下具有不同的性能。

选择合适的排序算法取决于问题的规模、数据的特征、对时间和空间复杂度的要求等因素。

例如，对于小规模数据，简单的排序算法如冒泡排序可能就足够了；而对于大规模数据，更高效的算法如快速排序或归并排序可能更适合。

5. 排序的应用：排序在许多领域都有广泛的应用。

除了数据处理和算法设计，排序还用于数据库查询优化、图像处理、机器学习等领域。

例如，在搜索引擎中，对网页进行排序以提供相关度更高的结果；在图像处理中，对像素进行排序以进行图像过滤或增强。

这些是关于排序的一些小知识，排序是一个基础而重要的概念，深入理解排序算法和其应用可以帮助我们更好地处理和分析数据。

河北工业大学-数据结构实验报告-内部排序算法效率比较平台的设计与实现

河北工业大学-数据结构实验报告-内部排序算法效率比较平台的设计与实现

实验五内部排序算法效率比较平台的设计与实现1.试验内容1、问题描述各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。

设计和实现内部排序算法效率比较平台，通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观的感受。

2、基本要求（1）对以下6种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

（2）待排序的表长不小于100；其中的数据要用伪随机数产生程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。

（3）最后要对结果作出简单分析，包括对各组数据得出结果波动大小的解释。

3、测试数据由随机数产生器生成。

4、实现提示主要工作是设法在已知算法中的适当位置插入对关键字的比较次数和移动次数的计数操作。

程序还可以考虑几组数据的典型性，如，正序、逆序和不同程度的乱序。

注意采用分块调试的方法。

2.试验目的掌握多种排序方法的基本思想，如直接插入、冒泡、简单选择、快速、堆、希尔排序等排序方法，并能够用高级语言实现。

3.流程图4.源程序代码#include<iostream.h>#include<string.h>#include<stdlib.h>#define le 100struct point{char key[11];};//冒泡法void maopao(point c[]){point a,b[le];int i,j,jh=0,bj=0,q;for(i=0;i<le;i++){b[i]=c[i];};for(i=0;i<le;i++){for(j=le-1;j>i;j--){bj=bj+1;q=strcmp(b[i].key,b[j].key);if(q==1){a=b[i];b[i]=b[j];b[j]=a;jh=jh+3;};};};cout<<"冒泡法:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};//直接插入排序void zhijiecharu(point c[]){point b[le+1];int i,j,jh=0,bj=0,q;for(i=0;i<le;i++){b[i+1]=c[i];};for(i=2;i<=le+1;i++){q=strcmp(b[i].key,b[i-1].key);bj=bj+1;if(q==-1){b[0]=b[i];b[i]=b[i-1];jh=jh+2;q=strcmp(b[0].key,b[i-2].key);bj=bj+1;for(j=i-2;q==-1;j--){b[j+1]=b[j];jh=jh+1;q=strcmp(b[0].key,b[j-1].key);bj=bj+1;};b[j+1]=b[0];jh=jh+1;};};cout<<"直接插入排序:"<<endl<<"完成的序列如下:"<<endl;for(i=1;i<le+1;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};//void shellinsert(point c[],int dk,int d[]){int j,i,q;point a;for(i=dk+1;i<le+1;i++){q=strcmp(c[i].key,c[i-dk].key);d[0]=d[0]+1;if(q==-1){a=c[i];q=strcmp(a.key,c[i-dk].key);d[0]=d[0]+1;d[1]=d[1]+1;for(j=i-dk;j>0&&q==-1;j=j-dk){c[j+dk]=c[j];d[1]=d[1]+1;q=strcmp(a.key,c[j-dk].key);};c[j+dk]=a;d[1]=d[1]+1;};};};void shellsort(point c[],int dlta[],int t){int k,d[2],i;d[0]=0;d[1]=0;point b[le+1];for(k=0;k<le;k++){b[k+1]=c[k];};for(k=0;k<t;k++)shellinsert(b,dlta[k],d);cout<<"希尔排序:"<<endl<<"完成的序列如下:"<<endl;for(i=1;i<le+1;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<d[0]<<"次,进行交换"<<d[1]<<"次"<<endl<<"***************************"<<endl;};//希尔排序void xier(point c[]){int dlta[20],t,i;t=le/2;for(i=0;i<20;i++){dlta[i]=t+1;if(t==0)break;t=t/2;};t=i+1;shellsort(c,dlta,t);};//简单选择排序void jiandanxuanze(point c[]){point a,b[le];int i,j,jh=0,bj=0,q,w;for(i=0;i<le;i++){b[i]=c[i];};for(i=0;i<le-1;i++){q=i;for(j=i+1;j<le;j++){bj=bj+1;w=strcmp(b[q].key,b[j].key);if(w==1)q=j;};if(q==i)continue;else {a=b[i];b[i]=b[q];b[q]=a;jh=jh+3;};};cout<<"简单选择排序排序:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};int partition(point c[],int low,int high,int d[]){point a,b;int jh=0,bj=0,q;a=c[low];while(low<high){q=strcmp(c[high].key,a.key);d[0]=d[0]+1;while(low<high&&q!=-1){high--;q=strcmp(c[high].key,a.key);d[0]=d[0]+1;};b=c[low];c[low]=c[high];c[high]=b;d[1]=d[1]+3;q=strcmp(c[low].key,a.key);d[0]=d[0]+1;while(low<high&&q!=1){low++;q=strcmp(c[low].key,a.key);d[0]=d[0]+1;};b=c[low];c[low]=c[high];c[high]=b;d[1]=d[1]+3;};return(low);};void qsort(point c[],int low,int high,int d[]){int pivotloc;if(low<high){pivotloc=partition(c,low,high,d);qsort(c,low,pivotloc-1,d);qsort(c,pivotloc+1,high,d);};};//快速排序void kuaisu(point c[]){point b[le];int i,d[2];d[0]=0;d[1]=0;for(i=0;i<le;i++){b[i]=c[i];};qsort(b,0,le-1,d);cout<<"快速排序:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<d[1]<<"次,进行交换"<<d[0]<<"次"<<endl<<"***************************"<<endl;};void diu(point b[],int we,int *jh,int *bj){point a;int i,q;for(i=we/2-1;i>=0;i--){q=strcmp(b[i].key,b[2*i].key);*bj=*bj+1;if(q==-1){a=b[i];b[i]=b[2*i];b[2*i]=a;*jh=*jh+3;};if(2*i+1<we){q=strcmp(b[i].key,b[2*i+1].key);*bj=*bj+1;if(q==-1){a=b[i];b[i]=b[2*i+1];b[2*i+1]=a;*jh=*jh+3;};};};a=b[we-1];b[we-1]=b[0];b[0]=a;*jh=*jh+3;};//堆排序void diup(point c[]){point b[le];int i,jh=0,bj=0,*j,*bl;j=&jh;bl=&bj;for(i=0;i<le;i++){b[i]=c[i];};for(i=le;i>1;i--){diu(b,i,j,bl);};cout<<"堆排序:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};void main(){int i,j,n=10,ans,an;char b[]="abcdefghijklmnopqrstuvwxyz";point a[le];for(i=0;i<le;i++){n=10;an=rand()*(n-1)/RAND_MAX+1;n=26;for(j=0;j<an;j++){ans=rand()*(n-0)/RAND_MAX+0;a[i].key[j]=b[ans];};a[i].key[j]='\0';};for(i=0;i<le;i++){cout<<a[i].key<<endl;};zhijiecharu(a);maopao(a);xier(a);jiandanxuanze(a);kuaisu(a);diup(a);}参考自百度文库5.实验结果运行结果如下：直接插入排序:完成的序列如下:***************************冒泡法:完成的序列如下:***************************希尔排序:完成的序列如下:*************************** 简单选择排序排序:完成的序列如下:*************************** 快速排序:完成的序列如下:*************************** 堆排序:完成的序列如下:。

第三章内部排序算法比较

第三章内部排序算法比较

第三章内部排序算法比较3.1. 问题描述3.1.1 题目内容设计程序实现六种方法的内部排序：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

并对各个内部排序算法进行实测比较。

3.1.2 基本要求程序分别对六种常用的内部排序算法进行实测比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

待排序表的表长不小于100，其中数据要用随机数产生程序产生，要求用多组不同的输入数据进行比较，比较的指标为：有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次的移动）。

3.1.3 待测试数据因为所产生的数据是随机数，所以只需要用户输入要产生的随机数的个数。

所以可根据需要设置以下一组数：5，10，50，300，1000，7000，20000，50000。

3.2. 需求分析3.2.1 程序的基本功能首先用户输入要测试的随机数的个数，然后可以进行各个选项对数据进行不同的测试，程序能分别输出用起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序所用的移动关键字的步数，以便比较各个排序算法的效率。

3.2.2 输入值的形式和范围程序设定输入的整型数据在100000之内。

3.2.3 输出形式程序将产生的随机数以数组的形式储存，并在屏幕上依次输出，排序后得到的有序数组也同样依次输出，同时输出跟踪的来的总移动步数。

3.2.4 测试数据要求在调试时，为了能方便判断得出的结果是否正确可使用数量小的随机数，如3、4、5。

在调试确定算法能得出正确结果后测试数据要求每组随机数的个数应大于100，最好更长，这样才能更加容易得出各个排序算法在时间上的不同。

3.3. 概要设计3.3.1 主程序流程及模块调用关系（1）主程序流程图：一. 产生随机数。

二. 各个排序算法图 3-1 程序流程图（2）模块调用关系图见下页：图 3-23.3.2 核心的粗线条伪码算法设置一个类class Algorithm{……..将各个排序算法的函数作为类中的构造函数……..}A;Algorithm Sorting( )1. 输入随机数的个数N；2. 调用随机数产生函数产生个N随机数并储存到Array[1]~~Array[N]中.3. 输入选择功能4．switch(c){case '1':调用起泡法对所产生的随机数进行排序;case '2':调用直接插入法对所产生的随机数进行排序;case '3':调用简单选择法对所产生的随机数进行排序;case '4':调用快速排序法对所产生的随机数进行排序;case '5':调用Shell排序对所产生的随机数进行排序;case '6':调用堆排序对所产生的随机数进行排序;case '7':产生下一组随机数据case '8':结束并退出程序3.4. 详细设计3.4.1 实现概要设计的数据类型.定义一个类，将每个算法都现在该类中：Class Algorithm{Public:Bubblesort(){……….}StraightInsertsort(){……….}Selectsort(){……….}Quiksort(){……….}Shellsort(){……….}Heapesort(){……….}}A;3.4.2 每个操作的伪码算法.（1）.起泡法排序伪码算法：Algorithm BubbleSort( ){while(k>1){//i>1表明上一趟曾进行过记录交换设定一个记录最后一次交换位置的整型int lastExchangeIndex=1;for(int j=1;j<k;j++){作循环当后一个元素小于前一个时L.elem[j+1].key<L.elem[j].key{相互交换元素的值.记录交换的元素的位置}将一趟排序中无序序列中最后一个记录的位置传递给k,做下一次循环（2）.直接插入排序的伪算法：Algorithm InsertSort()for(int i=2;i<=L.length;++i)判断如果第i个元素的值小于第i-1元素的值时{ 需将第i个元素插入有序子表将i元素复制为哨兵for(int j=i-1;L.elem[0].key<L.elem[j].key;--j)将元素记录后移然后将哨兵插入到正确位置}（3）.Shell排序伪算法Algorithm ShellSort(){设置一个整型变量福初始值为5（dlta=5; ）{ 做运算dlta = dlta/3+1;调用ShellInsert函数}当设置的整型变量大于1;ShellInsert( ) //ShellInsert函数{for(int i=dk+1;i<=L.length;++i)if(L.elem[i].key<L.elem[i-dk].key){ //需将L.elem.[i]插入有序增量子表L.elem[0]=L.elem[i];//暂存在L.elem.[0]int j=i-dk;do{ L.elem[j+dk] = L.elem[j];j = j - dk;}while(j > 0&&L.elem[0].key < L.elem[j].key); //记录后移，查找插入位置插入操作L.elem[j+dk]=L.elem[0];}（4）. 快速排序伪算法：Algorithm QuikSort(){判断需要排序的数组长度，如果大于1{调用Partition函数，将Low 到Hight一分为二分别调用QSort函数，分别对高低子表进行递归排序} }Partition(sqlist &R,int low,int high) //划分函数{//对记录子序列R[low....high]进行一趟快速排序，并返回枢轴记录所在位置，//使得在它之前的记录的关键字均不大于它的关键字，在它之后的记录的关键//字均不小于它的关键字将枢轴记录移至数组的闲置地方；枢轴记录关键字；从表的两端交替地向中间扫描；将比枢轴记录小的记录移到底端将比枢轴记录大的记录移到高端枢轴记录移到正确位置（R.elem[low] = R.elem[0]）返回枢轴的位置return low}void QSort(sqlist &R,int low,int high) 函数对记录序列R[s....t]进行快速排序{ 如果子表长度大于1{ 调用Partition对R[s...t]进行一次划分，并返回枢轴位置对底端子序列递归排序(QSort(R,low,pivotloc-1) ).对高断子序列递归排序(QSort(R,pivotloc+1,high) ).}3.4.3 主程序和其它模块的伪码算法.Algorithm main( )1. 函数运行，并先后调用菜单函数和随机数产生函数2. 进入while循环，再次调用菜单函数3．进入如下一个Switch语句，对各个功能进行调用switch(c){ case '1':调用起泡法对所产生的随机数进行排序;case '2':调用直接插入法对所产生的随机数进行排序;……….case '6':调用堆排序对所产生的随机数进行排序;case '7':产生下一组随机数据case '8':结束并退出程序3.5. 调试分析3.5.1 设计与调试过程中遇到的问题及分析、体会在程序的最初调试中因为没有把握好各个函数之间的调用关系，因而出现了许多错误，比如得不到排序结果等，然后将所有排序的函数都写在了一个类中，这样，只要声明一次，以后就可以非常方便，准确的调用各个函数了。