序列划分c语言,一篇“get”C语言八大排序算法

如果说各种编程语言是程序员的招式，那么数据结构和算法就相当于程序员的内功。

想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。

二、八大排序算法

排序算法作为数据结构的重要部分，系统地学习一下是很有必要的。

1、排序的概念

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。

排序分为内部排序和外部排序。

若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。

反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。

2、排序分类

八大排序算法均属于内部排序。如果按照策略来分类，大致可分为：交换排序、插入排序、选择排序、归并排序和基数排序。如下图所示：

3、算法分析

1.插入排序：

● 直接插入排序

● 希尔排序

2.选择排序

● 简单选择排序

● 堆排序

3.交换排序

● 冒泡排序

● 快速排序

4.归并排序

5.基数排序

不稳定排序：简单选择排序，快速排序，希尔排序，堆排序稳定排序：冒泡排序，直接插入排序，归并排序，奇数排序

三、具体排序讲解

下面针对不同排序进行一一讲解。

一、直接插入排序(Insertion Sort)

算法思想：

直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过 因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成：

?第一层循环：遍历待比较的所有数组元素

?第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。如果：selected > ordered，那么将二者交换。

算法代码：

void print(int a[], int n ,int i){

cout<

for(int j= 0; j<8; j++){

cout<

cout<

void InsertSort(int a[], int n)

for(int i= 1; i

if(a[i] < a[i-1]){ //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入

int j= i-1;

int x = a[i]; //复制为哨兵，即存储待排序元素

a[i] = a[i-1]; //先后移一个元素

while(x < a[j]){ //查找在有序表的插入位置

a[j+1] = a[j];

j--; //元素后移

a[j+1] = x; //插入到正确位置

print(a,n,i); //打印每趟排序的结果

int main(){

int a[8] = {3,1,5,7,2,4,9,6};

InsertSort(a,8);

print(a,8,8);

二、希尔排序(Shell' s Sort)

算法思想:

希尔排序也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

算法步骤：

1.选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

2.按增量序列个数k，对序列进行k 趟排序；

3.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

算法代码:

void print(int a[], int n ,int i){

cout<

for(int j= 0; j<8; j++){

cout<

cout<

* 直接插入排序的一般形式

* @param int dk 缩小增量，如果是直接插入排序，dk=1

void ShellInsertSort(int a[], int n, int dk)

for(int i= dk; i

if(a[i] < a[i-dk]){ //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入

int j = i-dk;

int x = a[i]; //复制为哨兵，即存储待排序元素

a[i] = a[i-dk]; //首先后移一个元素

while(x < a[j]){ //查找在有序表的插入位置

a[j+dk] = a[j];

j -= dk; //元素后移

a[j+dk] = x; //插入到正确位置

print(a, n,i );

// 先按增量d(n/2,n为要排序数的个数进行希尔排序

void shellSort(int a[], int n){

int dk = n/2;

while( dk >= 1 ){

ShellInsertSort(a, n, dk);

dk = dk/2;

int main(){

int a[8] = {3,1,5,7,2,4,9,6};

//ShellInsertSort(a,8,1); //直接插入排序

shellSort(a,8); //希尔插入排序

print(a,8,8);

三、简单选择排序(Selection Sort)

算法思想：

简单选择排序的实现思想：比较+交换

? 从待排序序列中，找到关键字最小的元素；

? 如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；

? 从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。因此我们可以发现，简单选择排序也是通过两层循环实现。

第一层循环：依次遍历序列当中的每一个元素

第二层循环：将遍历得到的当前元素依次与余下的元素进行比较，符合最小元素的条件，则交换。

算法代码：

void print(int a[], int n ,int i){

cout<

for(int j= 0; j<8; j++){

cout<

cout<

* 数组的最小值

* @return int 数组的键值

int SelectMinKey(int a[], int n, int i)

int k = i;

for(int j=i+1 ;j< n; ++j) {

if(a[k] > a[j]) k = j;

return k;

* 选择排序

void selectSort(int a[], int n){

int key, tmp;

for(int i = 0; i< n; ++i) {

key = SelectMinKey(a, n,i); //选择最小的元素

if(key != i){

tmp = a[i]; a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换

print(a, n , i);

int main(){

int a[8] = {3,1,5,7,2,4,9,6};

cout<

for(int j= 0; j<8; j++){

cout<

cout<

selectSort(a, 8);

print(a,8,8);

四、堆排序(Heap Sort)

算法思想：

堆：本质是一种数组对象。特别重要的一点性质：任意的叶子节点小于(或大于)它所有的父节点。对此，又分为大顶堆和小顶堆：

? 大顶堆要求节点的元素都要大于其孩子。

? 小顶堆要求节点元素都小于其左右孩子。

? 两者对左右孩子的大小关系不做任何要求。

利用堆排序，就是基于大顶堆或者小顶堆的一种排序方法。下面，我们通过大顶堆来实现。

基本思想：堆排序可以按照以下步骤来完成：

1.首先将序列构建称为大顶堆；(这样满足了大顶堆那条性质：位于根节点的元素一定是当前序列的最大值)

2.取出当前大顶堆的根节点，将其与序列末尾元素进行交换；(此时：序列末尾的元素为已排序的最大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质)

3.对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；

4.重复2.3步骤，直至堆中只有1个元素为止

下面是基于大顶堆的堆排序算法代码：

void print(int a[], int n){

for(int j= 0; j

cout<

cout<

* 已知H[s…m]除了H[s] 外均满足堆的定义

* 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,

* @param H是待调整的堆数组

* @param s是待调整的数组元素的位置

* @param length是数组的长度

void HeapAdjust(int H[],int s, int length)

int tmp = H[s];

int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)

while (child < length) {

if(child+1

++child ;

if(H[s]

H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点

s = child; // 重新设置s ,即待调整的下一个结点的位置

child = 2*s+1;

} else { // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出

break;

H[s] = tmp; // 当前待调整的结点放到比其大的孩子结点位置上

print(H,length);

* 初始堆进行调整

* 将H[0..length-1]建成堆

* 调整完之后第一个元素是序列的最小的元素

void BuildingHeap(int H[], int length)

//最后一个有孩子的节点的位置 i= (length -1) / 2

for (int i = (length -1) / 2 ; i >= 0; --i)

HeapAdjust(H,i,length);

* 堆排序算法

void HeapSort(int H[],int length)

//初始堆

BuildingHeap(H, length);

//从最后一个元素开始对序列进行调整

for (int i = length - 1; i > 0; --i)

//交换堆顶元素H[0]和堆中最后一个元素

int temp = H[i]; H[i] = H[0]; H[0] = temp;

//每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整

HeapAdjust(H,0,i);

int main(){

int H[10] = {3,1,5,7,2,4,9,6,10,8};

cout<

print(H,10);

HeapSort(H,10);

//selectSort(a, 8);

cout<

print(H,10);

五、冒泡排序(Bubble Sort)

算法思想：

冒泡遍历所有的数据，每次对相邻元素进行两两比较，如果顺序和预先规定的顺序不一致，则进行位置交换；

这样一次遍历会将最大或最小的数据上浮到顶端，之后再重复同样的操作，直到所有的数据有序。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

算法代码：

void bubbleSort(int a[], int n){

for(int i =0 ; i< n-1; ++i) {

for(int j = 0; j < n-i-1; ++j) {

if(a[j] > a[j+1])

int tmp = a[j] ; a[j] = a[j+1] ; a[j+1] = tmp;

六、快速排序(Quick Sort)

算法思想：

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο(nlogn)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(nlogn) 算法更快，因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来

快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)。

算法步骤：

? 从数列中挑出一个元素，称为 “基准”(pivot)。

? 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区(partition)操作。

? 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代(iteration)中，它至少会把一个元素摆到它最后的位置去。

算法代码：

void print(int a[], int n){

for(int j= 0; j

cout<

cout<

void swap(int *a, int *b)

int tmp = *a;

*a = *b;

*b = tmp;

int partition(int a[], int low, int high)

int privotKey = a[low]; //基准元素

while(low < high){ //从表的两端交替地向中间扫描

while(low < high && a[high] >= privotKey) --high; //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端

swap(&a[low], &a[high]);

while(low < high && a[low] <= privotKey ) ++low;

swap(&a[low], &a[high]);

print(a,10);

return low;

void quickSort(int a[], int low, int high){

if(low < high){

int privotLoc = partition(a, low, high); //将表一分为二

quickSort(a, low, privotLoc -1); //递归对低子表递归排序

quickSort(a, privotLoc + 1, high); //递归对高子表递归排序

int main(){

int a[10] = {3,1,5,7,2,4,9,6,10,8};

cout<

print(a,10);

quickSort(a,0,9);

cout<

print(a,10);

七、归并排序(Merge Sort)

算法思想：

归并排序(Merge sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

算法步骤：

? 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

? 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

? 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

? 重复步骤3直到某一指针达到序列尾；

? 将另一序列剩下的所有元素直接复制到合并序列尾。

算法代码：

void print(int a[], int n){

for(int j= 0; j

cout<

cout<

//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]

void Merge(ElemType *r,ElemType *rf, int i, int m, int n)

int j,k;

for(j=m+1,k=i; i<=m && j <=n ; ++k){

if(r[j] < r[i]) rf[k] = r[j++];

else rf[k] = r[i++];

while(i <= m) rf[k++] = r[i++];

while(j <= n) rf[k++] = r[j++];

print(rf,n+1);

void MergeSort(ElemType *r, ElemType *rf, int lenght)

int len = 1;

ElemType *q = r ;

ElemType *tmp ;

while(len < lenght) {

int s = len;

len = 2 * s ;

int i = 0;

while(i+ len

Merge(q, rf, i, i+ s-1, i+ len-1 ); //对等长的两个子表合并

i = i+ len;

if(i + s < lenght){

Merge(q, rf, i, i+ s -1, lenght -1); //对不等长的两个子表合并

tmp = q; q = rf; rf = tmp; //交换q,rf，以保证下一趟归并时，仍从q 归并到rf

int main(){

int a[10] = {3,1,5,7,2,4,9,6,10,8};

int b[10];

MergeSort(a, b, 10);

print(b,10);

cout<

print(a,10);

八、基数排序(Radix Sort)

算法思想：

基数排序：通过序列中各个元素的值，对排序的N个元素进行若干趟的“分配”与“收集”来实现排序。

分配：我们将L[i]中的元素取出，首先确定其个位上的数字，根据该数字分配到与之序号相同的桶中 。

收集：当序列中所有的元素都分配到对应的桶中，再按照顺序依次将桶中的元素收集形成新的一个待排序列L[ ] 。

对新形成的序列L[]重复执行分配和收集元素中的十位、百位...直到分配完该序列中的最高位，则排序结束。

算法代码：

Void RadixSort(Node L[],length,maxradix)

int m,n,k,lsp;

k=1;m=1;

int temp[10][length-1];

Empty(temp); //清空临时空间

while(k

for(int i=0;i

if(L[i]

Temp[0][n]=L[i];

else

Lsp=(L[i]/m)%10; //确定关键字

Temp[lsp][n]=L[i];

n++;

CollectElement(L,Temp); //收集

n=0;

m=m*10;

k++;

看到这里，你对“C语言八大排序算法”了解了多少？