C语言希尔排序算法
C程序经典算法50例
C程序经典算法50例1.二分查找算法：在有序数组中查找指定元素。
2.冒泡排序算法：通过不断比较相邻元素并交换位置，将较大的元素向后冒泡。
3.快速排序算法：通过选择一个基准元素，将数组分割为左右两部分，并递归地对两部分进行快速排序。
4.插入排序算法：将数组划分为已排序和未排序两部分，每次从未排序中选择一个元素插入到已排序的合适位置。
5.选择排序算法：遍历数组，每次选择最小元素并放置在已排序部分的末尾。
6.希尔排序算法：将数组按照一定间隔进行分组并分别进行插入排序，然后逐步减小间隔并重复这个过程。
7.归并排序算法：将数组递归地划分为两部分，然后将两个有序的部分进行合并。
8.桶排序算法：将元素根据特定的映射函数映射到不同的桶中，然后对每个桶分别进行排序。
9.计数排序算法：统计每个元素的出现次数，然后根据计数进行排序。
10.基数排序算法：从低位到高位依次对元素进行排序。
11.斐波那契数列算法：计算斐波那契数列的第n项。
12.阶乘算法：计算给定数字的阶乘。
13.排列问题算法：生成给定数组的全排列。
14.组合问题算法：生成给定数组的所有组合。
15.最大连续子序列和算法：找出给定数组中和最大的连续子序列。
16.最长递增子序列算法：找出给定数组中的最长递增子序列。
17.最长公共子序列算法：找出两个给定字符串的最长公共子序列。
18.最短路径算法：计算给定有向图的最短路径。
19.最小生成树算法：构建给定连通图的最小生成树。
20.汉诺塔算法：将n个圆盘从一个柱子移动到另一个柱子的问题。
21.BFS算法：广度优先算法，用于图的遍历和查找最短路径。
22.DFS算法：深度优先算法，用于图的遍历和查找连通分量。
23.KMP算法：字符串匹配算法，用于查找一个字符串是否在另一个字符串中出现。
24.贪心算法：每次都选择当前情况下最优的方案，适用于求解一些最优化问题。
25.动态规划算法：将一个大问题划分为多个子问题，并通过子问题的解求解整个问题，适用于求解一些最优化问题。
C语言--常见排序算法
49
2 j 49
08
0
25* 3 49 25
16 4
21
5
08
25
25*
16
21
i k 49
j 25* 25
08
25
25*
16
21
算法实例：
1.1.5 选择排序
49 2
08 0
25 1 i
25* 3
16 4 k
21 5 j 21 16
k 指示当前序列中最小者
算法实现：
08 5 temp
16 21 25 25* 49 08 0 1 2 3 4 5
算法实现：
1.1.3 直接插入排序
void InsertSort (int r[ ], int n ) { // 假设关键字为整型，放在向量r[]中 int i, j, temp; for (i = 1;i< n;i++ ) { temp = r[i]; for(j = i;j>0;j- -) {//从后向前顺序比较，并依次后移 if ( temp < r[j-1] ) r[j] = r[j-1]; else break; } r[j] = temp; } }
输入n 个数给a[1] 到 a[n]
for j=1 to n-1
for i=1 to n-j
真 a[i]>a[i+1]
a[i]a[i+1]
输出a[1] 到 a[n]
main() { int a[11],i,j,t; printf("Input 10 numbers:\n"); for(i=1;i<11;i++) scanf("%d",&a[i]); printf("\n"); 假 for(j=1;j<=9;j++) for(i=1;i<=10-j;i++) if(a[i]>a[i+1]) {t=a[i]; a[i]=a[i+1]; a[i+1]=t;} printf("The sorted numbers:\n"); for(i=1;i<11;i++) printf("%d ",a[i]); }
比较冒泡算法,选择算法,希尔排序算法
一、算法简介冒泡排序算法、选择排序算法和希尔排序算法是三种常用的排序算法。
这三种算法的共同点是都属于比较排序算法，即通过比较元素之间的大小，进行排序。
下面将分别对这三种算法进行介绍。
二、冒泡排序算法冒泡排序算法的基本思想是对相邻的元素进行比较，如果逆序则交换它们的位置，直到整个序列有序为止。
具体实现过程如下：1. 设置循环次数为 n-1，n 为待排序序列长度。
2. 对于每一次循环，从第一个元素开始，依次比较相邻的两个元素，如果逆序则交换它们的位置。
3. 每一次循环结束后，待排序序列中最大的元素就会被排到末尾。
4. 重复执行上述步骤，直到整个序列有序。
冒泡排序算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)，稳定性较好，适用于数据量较小的情况。
三、选择排序算法选择排序算法的基本思想是从待排序序列中选择最小的元素，放到已排序序列的末尾，直到整个序列有序为止。
具体实现过程如下：1. 设置循环次数为 n-1，n 为待排序序列长度。
2. 对于每一次循环，从第一个元素开始，找到待排序序列中最小的元素，并将其放到已排序序列的末尾。
3. 重复执行上述步骤，直到整个序列有序。
选择排序算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)，稳定性较差，适用于数据量较小的情况。
四、希尔排序算法希尔排序算法也称为缩小增量排序算法，是插入排序算法的一种改进。
希尔排序算法的基本思想是将待排序序列分成若干个子序列，对每个子序列进行插入排序，然后再对整个序列进行一次插入排序，直到整个序列有序为止。
具体实现过程如下：1. 设置一个增量值 gap，将待排序序列分成若干个子序列，每个子序列包含的元素个数为 gap。
2. 对于每个子序列，进行插入排序。
3. 减小增量值 gap，重复执行上述步骤，直到 gap=1。
4. 对整个序列进行一次插入排序，使得序列有序。
希尔排序算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)，稳定性较差，适用于数据量较大的情况。
希尔排序算法c语言代码
希尔排序算法c语言代码1. 什么是希尔排序？希尔排序是一种高效的排序算法，是插入排序的一种优化版。
由于它的出现，使得插入排序的效率也得到了很大的提升。
希尔排序的特点是先将整个序列分成多个子序列进行插入排序，然后再将整个序列进行插入排序，以此逐渐逼近有序序列。
2. 希尔排序的基本思想希尔排序的基本思想是先将整个序列分成若干个子序列，对每个子序列进行插入排序，使得整个序列变得部分有序。
然后再对整个序列进行插入排序，使其变得有序。
3. 希尔排序的具体实现希尔排序的具体实现步骤如下：1.选择一个增量序列t1，t2，……，tk，其中ti>tj，tk=1；2.按增量序列个数k，对序列进行k趟排序；3.每趟排序，根据对应的增量ti，将待排序的序列分割成若干长度为m的子序列，分别对各个子序列进行插入排序。
这里的m即为增量ti。
4.将各个子序列中的元素依次拼接成新的有序序列。
以下是希尔排序的代码实现：include<stdio.h>void shellsort(int array[], int len){int i, j, increment;int temp;for(increment = len / 2; increment > 0; increment /= 2) //设置增量，初始为数组长度的一半，每次迭代除以2{for(i = increment; i < len; i++){temp = array[i];for(j = i - increment; j >= 0 && array[j] > temp; j -= increment) //在子序列中进行插入排序{array[j + increment] = array[j];}array[j + increment] = temp;}}}int main(){int a[10] = {3, 1, 5, 7, 2, 4, 9, 6, 8, 0}, i;shellsort(a, 10);for(i = 0; i < 10; i++)printf("%d ", a[i]);printf("\n");return 0;}4. 希尔排序的优点和缺点希尔排序的优点在于相对于插入排序而言，有了很大的优化，能够在大多数情况下，达到更好的效率和性能。
C语言八大排序算法
C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法，附动图和详细代码解释！来源：C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式，那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分，系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作，其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。
反之，若参加排序的记录数量很⼤，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类，⼤致可分为：交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰：3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序：简单选择排序，快速排序，希尔排序，堆排序稳定排序：冒泡排序，直接插⼊排序，归并排序，奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序，然后将第3个元素插⼊到已经排好序的元素中，依次类推（插⼊排序最好的情况就是数组已经有序了）因为插⼊排序每次只能操作⼀个元素，效率低。
元素个数N，取奇数k=N/2，将下标差值为k的数分为⼀组（⼀组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为⼀组，构成有序序列，直到k=1，然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换，再在剩余的数中⼜选择最⼩的和第⼆个数交换，依次类推4、堆排序以升序排序为例，利⽤⼩根堆的性质（堆顶元素最⼩）不断输出最⼩元素，直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶，再重新构造成⼩根堆，再输出堆顶元素，以此类推5、冒泡排序改进1：如果某次冒泡不存在数据交换，则说明已经排序好了，可以直接退出排序改进2：头尾进⾏冒泡，每次把最⼤的沉底，最⼩的浮上去，两边往中间靠16、快速排序选择⼀个基准元素，⽐基准元素⼩的放基准元素的前⾯，⽐基准元素⼤的放基准元素的后⾯，这种动作叫分区，每次分区都把⼀个数列分成了两部分，每次分区都使得⼀个数字有序，然后将基准元素前⾯部分和后⾯部分继续分区，⼀直分区直到分区的区间中只有⼀个元素的时候，⼀个元素的序列肯定是有序的嘛，所以最后⼀个升序的序列就完成啦。
C语言版数据结构-希尔排序
2. 希尔排序详细设计#include <stdio.h>#include <stdlib.h>#include <time.h>typedef int KeyType;typedef int OtherType;#define Max_Size 5000typedef struct{KeyType key;OtherType other_data;}RecordType;void ShellInsert(RecordType r[], int length, int delta)/*对记录数组r做一趟希尔插入排序，length为数组的长度,delta 为增量*/{int i,j;for(i=1+delta;i<=length;i=i+delta)//1+delta为第一个子序列的第二个元素的下标if(r[i].key<r[i-delta].key){RecordType t;t=r[i]; //备份r[i]for(j=i;j>0 && t.key<r[j-delta].key;j-=delta)r[j]=r[j-delta];r[j]=t;}}/*ShellInsert*/void ShellSort(RecordType r[], int length, int delta[], int n)/*对记录数组r做希尔排序，length为数组r的长度，delta 为增量数组，n为delta[]的长度 */{for(int i=0;i<n;++i)ShellInsert(r,length,delta[i]);}void main(){int i;RecordType r[Max_Size];int len;int delta[4]={6,4,2,1};printf("请输入待排序记录的长度:");scanf("%d",&len);srand((unsigned)time(NULL));for(i=1;i<=len;i++)r[i].key =rand();printf("\n待排序记录:\n");for(i=1;i<=len;i++)printf("%6d ",r[i].key);printf("\n");ShellSort(r,len,delta,4);printf("\n排序后的记录:\n");for(i=1;i<=len;i++)printf("%6d ",r[i].key);printf("\n\n");}测试结果。
c语言实现简单排序(8种方法)
#include<stdio.h>#include<stdlib.h>//冒泡排序voidbubleSort(int data[], int n);//快速排序voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high);//插入排序voidbInsertSort(int data[], int n);//希尔排序voidshellSort(int data[], int n);//选择排序voidselectSort(int data[], int n);//堆排序voidheapSort(int data[], int n);void swap(int data[], inti, int j);voidheapAdjust(int data[], inti, int n);//归并排序voidmergeSort(int data[], int first, int last);void merge(int data[], int low, int mid, int high); //基数排序voidradixSort(int data[], int n);intgetNumPos(intnum, intpos);int main() {int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");/*printf("冒泡排序:");bubleSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("快速排序:");quickSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("插入排序:");bInsertSort(data,10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("希尔排序:");shellSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("选择排序:");selectSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf(" 堆排序:");heapSort(data, 10);for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf("归并排序:");mergeSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");*/printf("基数排序:");radixSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");return 0;}/*--------------------冒泡排序---------------------*/ voidbubleSort(int data[], int n) {inti,j,temp;//两个for循环，每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。
希尔排序
希尔(shell)排序描述用函数实现希尔(shell)排序，并输出每趟排序的结果,初始增量d=n/2,其后d=d/2 Input第一行：键盘输入待排序关键的个数n第二行：输入n个待排序关键字，用空格分隔数据Output每行输出一趟排序结果，数据之间用一个空格分隔#include"stdio.h"#define MAXSIZE 20//一个用作示例的小顺序表的最大长度typedef int KeyType;//定义关键字类型为整数类型typedef struct{ int key;float info;}JD;void shellsort(JD r[],int n,int d[]){//作一趟希尔(shell)排序，本算法是和一趟直接插入排序相比，做了一下修改：//1。
前后记录位置的增量是dk，而不是1；//2。
r[0]只是暂存单元，不是哨兵。
当j<=0时候，插入位置已经找到int i,j,length,k=0;length=n;for(k=0;d[k]>0;k++){for(i=d[k]+1;i<=length;i++){if(r[i].key <r[i-d[k]].key )//需将r[i]插入有序增量字表{r[0]=r[i];//暂存在r[0]for(j=i-d[k]; (j>0)&&(r[0].key<r[j].key); j-=d[k])//记录后移，查找插入位置{r[j+d[k]]=r[j];}r[j+d[k]]=r[0]; //插入}}for(j=1;j<=n;j++) //输出每趟排序的结果{printf("%d ",r[j].key);}//forprintf("\n");}}//straisortvoid main(){int n,i,t; //待排序的关键字个数nint d[MAXSIZE]={0};JD r[MAXSIZE];scanf("%d",&n);for(i=1;i<=n;i++)//输入待排序的关键字scanf("%d",&r[i].key);t=n/2;i=0;do{d[i]=t;t=t/2;// printf("%d\n",t);i++;}while(t>=1);// for(i=0;d[i]!=0;i++)// printf("%d ",d[i]);shellsort(r,n,d);}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言希尔排序算法
用希尔排序法对一组数据由小到大进行排序，数据分别为69、56、12、136、3、55、46、
99、88、25。
实现过程：
(1)自定义函数shsort()，实现希尔排序。
(2) main() 函数作为程序的入口函数。
程序代码如下：
1.#include<stdio.h>
2.int shsort(int s[],int n)/* 自定义函数 shsort()*/
3.{
4.int i,j,d;
5. d=n/2;/*确定固定增虽值*/
6.while(d>=1)
7.{
8.for(i=d+1;i<=n;i++)/*数组下标从d+1开始进行直接插入排序*/
9.{
10. s[0]=s[i];/*设置监视哨*/
11. j=i-d;/*确定要进行比较的元素的最右边位置*/
12.while((j>0)&&(s[0]<s[j]))
13.{
14. s[j+d]=s[j];/*数据右移*/
15. j=j-d;/*向左移d个位置V*/
16.}
17. s[j + d]=s[0];/*在确定的位罝插入s[i]*/
18.}
19. d = d/2;/*增里变为原来的一半*/
20.}
21.return0;
22.}
23.
24.int main()
25.{
26.int a[11],i;/*定义数组及变量为基本整型*/
27.printf("请输入 10 个数据：\n");
28.for(i=1;i<=10;i++)
29.scanf("%d",&a[i]);/*从键盘中输入10个数据*/
30.shsort(a,10);/* 调用 shsort()函数*/
31.printf("排序后的顺序是：\n");
32.for(i=1;i<=10;i++)
33.printf("%5d",a[i]);/*输出排序后的数组*/
34.printf("\n");
35.return0;
36.}
运行结果：
请输入10 个数据：。