八大排序(C语言)

void BubbleSort();//冒泡

void SelectSort();//选择

void InsertSort();//直接插入

void ShellSort();//希尔

void HeapSort();//堆排

void QuickSort();//快排

void MegerSort();//归并

void RadixSort();//基数(桶排序)

冒泡：
1）比较相邻的元素。如果第一个比第二个大，就交换他们两个；
2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；
3）针对所有的元素重复以上的步骤，除了最后一个；
4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
选择：
1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾；
3）重复第二步，直到所有元素均排序完毕。
直接插入：
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法步骤：
1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列；
2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置(相同则插入相等元素后边)。
希尔(递减增量排序算法)：
核心思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
1）选择一个增量序列d[1]，t[2]，…，d[k]，其中d[i]>d[j]，d[k]=1；
2）按增量序列个数k，对序列进行k 趟排序；
3）每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
堆排：

快排：

归并：

基数排序：
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。

1.算法排序的时间复杂度:
时间复杂度o(n^2)
冒泡排序，选择排序，插入排序
时间复杂度o(n*logn)
归并排序，快速排序，堆排序，希尔排序
时间复杂度o(n)
基数排序

2.算法排序的空间复杂度
o(1)
冒泡排序，选择排序，插入排序，堆排序，希尔排序
o(nlogn)
快速排序
o(N)
归并排序
o(M)
基数排序

3.稳定性：相同值的元素排序前和排序后值保持不变
稳定的排序算法：冒泡排序，插入排序，归并排序，基数排序；
不稳定的排序算法：选择排序，快速排序，堆排序，希尔排序；
4.不稳定原因：
选择排序原因：在选择最小值和位置为0的数交换的时候产生；
快速排序原因：在随机选择相同值中间的数的，两边的相同值的不不是被划分到选择值得左边就是选择值的右边；
堆排序原因：在每次建立大根堆后，堆顶元素会换到最后的位置上去；
希尔排序：步长为2时，第二个1跳两部，造成了不稳定；

详情见代码注释

/***********************************************************

while (i < j) // 保证找的整个过程 i < j { while (i < j) // 从后向前找比tmp小的元素保证 i < j { if (arr[j] < tmp) break; j--; } arr[i] = arr[j]; // 当找到比tmp小的元素后，将j位置的值存储到i位置 while (i < j) // 从前向后找比tmp大的元素保证 i < j { if (arr[i] > tmp) break; i++; } arr[j] = arr[i]; // 当找到比tmp大的元素后，将i位置的值存储到j位置 } arr[i] = tmp; // i之前的数据都比tmp小，之后的数据都比tmp大 return i;

st.data[st.top++] = left; st.data[st.top++] = right; while (st.top != 0) { right = st.data[--st.top]; left = st.data[--st.top]; int mod = OneQuick(arr, left, right); if (mod - left > 1) { st.data[st.top++] = left; st.data[st.top++] = mod - 1; } if (right - mod > 1) { st.data[st.top++] = mod + 1; st.data[st.top++] = right; } } free(st.data);

while (L1 < len && L2 < len) { while (L1 <= H1 && L2 <= H2) { if (arr[L1] < arr[L2]) { brr[num++] = arr[L1++]; } else { brr[num++] = arr[L2++]; } } while (L1 <= H1) { brr[num++] = arr[L1++]; } while (L2 <= H2) { brr[num++] = arr[L2++]; } L1 = H2 + 1; H1 = L1 + width - 1 < len - 1 ? L1 + width - 1 : len - 1; L2 = H1 + 1; H2 = L2 + width - 1 < len - 1 ? L2 + width - 1 : len - 1; } while (L1 <= H1) { brr[num++] = arr[L1++]; } for (int i = 0; i < len; ++i) { arr[i] = brr[i]; }

Que que[10]; for (int i = 0; i < 10; ++i) { que[i].data = (int*)malloc(sizeof(int)* len); assert(que[i].data != NULL); que[i].head = que[i].tail = 0; } int width = GetMaxWidth(arr, len); // O(n) for (int i = 0; i < width; ++i) // O(d * n) { // 将数组中所有的数字取其相应位数的值，并将其存储到相应的队列中 for (int j = 0; j < len; ++j) { int num = GetNumOfWidth(arr[j], i); que[num].data[que[num].tail++] = arr[j]; } int k = 0; for (int m = 0; m < 10; ++m) { while (que[m].head != que[m].tail) { arr[k++] = que[m].data[que[m].head++]; } } for (int n = 0; n < 10; ++n) { que[n].head = que[n].tail = 0; } } for (int i = 0; i < 10; ++i) { free(que[i].data); }

八大排序(C语言)

八大排序(C语言)

你可能感兴趣的:(数据结构与算法,八大排序)