各类排序算法C++

1.序言

本文章的数组元素都是用下方的结构体存储

const int maxsize=100;
typedef int datatype;
typedef struct{
    datatype key;

}rectype;
typedef rectype list[maxsize+1];

2.插入排序

步骤：

1.从第一个元素开始，该元素可以认为已经被排序
2.取下一个元素num，从已排序的元素序列从后往前扫描
3.如果该元素大于num，则将该元素移到下一位
4.重复步骤3，直到找到已排序元素中小于等于tem的元素
5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
6.重复步骤2~5

思路：
  在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。

以下为插入排序的步骤：

代码实现：

void InsertSort(list r,int n){
    int i,j;
    for(i=2;i<=n;i++){
        if(r[i].key>=r[i-1].key) continue;
        r[0]=r[i];
        j=i-1;
        do{
            r[j+1]=r[j];
            j--;
        }while(r[0].key<r[j].key);
        r[j+1]=r[0];

    }
}

3.希尔排序

步骤：
1.先选定一个小于N的整数g作为第一增量，然后将所有距离为g的元素分在同一组，并对每一组的元素进行直接插入排序。然后再取一个比第一增量小的整数作为第二增量，重复上述操作…
2.当增量的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。

思路：

先将待排序列进行预排序，使待排序列接近有序，然后再对该序列进行一次插入排序。直到整个序列有序为止。

以下为希尔排序的步骤：

 代码实现：

//希尔排序
void ShellSort(list r, int n)
{
	int gap = n;
	while (gap>1)
	{
		//每次对gap折半操作
		gap = gap / 2;
		//单趟排序
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tem = r[end + gap].key;
			while (end >= 0)
			{
				if (tem < r[end].key)
				{
					r[end + gap].key = r[end].key;
					end -= gap;
				}
				else
				{
					break;
				}
			}
			r[end + gap].key = tem;
		}
	}
}

4.冒泡排序

步骤和思路：

从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。

以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。

以下为冒泡排序的步骤：

代码实现：

void BubbloeSort(list r,int n){//上升
    int i,j,flag;
    for(i=1;i<n-1;i++){
        flag=0;
        for(j=n;j>=i+1;j--)
        if(r[j].key<r[j-1].key){
            flag=1;
            r[0]=r[j];
            r[j]=r[j-1];
            r[j-1]=r[0];
        }
        if(!flag) break;
    }
}

5.选择排序

步骤和思路：
每次从待排序列中选出一个最小值，然后放在序列的起始位置，直到全部待排数据排完即可。

以下为选择排序的步骤：

代码实现：

void SelectSort(list r,int n){
    int i,j,k;
    for(i=1;i<=n-1;i++){
        k=i;
        for(j=i+1;j<=n;j++){
            if(r[j].key<r[k].key) k=j;
        }
        if(k!=i){r[0]=r[i];r[i]=r[k];r[k]=r[0];}

    }
}

6.快速排序

步骤和思路：

1、选出一个key，一般是最左边或是最右边的。
2、定义一个l和一个r，l从左向右走，r从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要r先走；若选择最右边的数据作为key，则需要l先走）。
3、在走的过程中，若r遇到小于key的数，则停下，l开始走，直到l遇到一个大于key的数时，将l和r的内容交换，r再次开始走，如此进行下去，直到l和r最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）
4.此时key的左边都是小于key的数，key的右边都是大于key的数
5.将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作，此时此部分已有序

以下为快速排序的步骤：

代码实现：

int Partition(list r,int p,int q){
    int i,j;
    i=p;j=q;
    r[0]=r[i];
    while(i<j){
        while(i<j&&r[j].key>=r[0].key) j--;
        if(i<j) {r[i]=r[j];i++;}
        while(i<j&&r[i].key<=r[0].key) i++;
        if(i<j) {r[j]=r[i];j--;}
    }
    r[i]=r[0];
    return i;
}
void QuickSort(list r,int s,int t){
    int i;
    if(s>=t) return;
    i=Partition(r,s,t);
    QuickSort(r,s,i-1);
    QuickSort(r,i+1,t);
}

 7.归并排序

思路：

1. 将待排序的线性表不断地切分成若干个子表，直到每个子表只包含一个元素，这时，可以认为只包含一个元素的子表是有序表。
2. 将子表两两合并，每合并一次，就会产生一个新的且更长的有序表，重复这一步骤，直到最后只剩下一个子表，这个子表就是排好序的线性表。

以下为归并排序的步骤：

 

代码实现：

void Merge(list r,list r1,int low,int mid,int high){
    int i,j,k;
    i=low;
    j=mid+1;
    k=low;
    while(i<=mid&&j<=high){
        if(r[i].key<=r[j].key) r1[k++]=r[i++];
        else r1[k++]=r[j++];
    }

    while(i<=mid) r1[k++]=r[i++];
    while(j<=high) r1[k++]=r[j++];

}

void MergeSort(list r,int s,int t){
    int m;
    rectype r1[1000];
    if(s==t) return;
    else{
        m=(s+t)/2;
        MergeSort(r,s,m);
        MergeSort(r,m+1,t);
        Merge(r,r1,s,m,t);
        for(int i=s;i<=t;i++){
            r[i]=r1[i];
        }
    }
}

7.堆排序

堆结构分为大根堆和小根堆

大根堆：所有父节点大于等于孩子节点

小根堆：所有父节点小于等于孩子节点

 

代码实现：

void Sift(list r,int p,int q){
    int i,j;
    r[0]=r[p];
    i=p;
    j=2*i;
    while(j<=q){
        if(j<q&&r[j].key<r[j+1].key) j++;
        if(r[0].key>r[j].key) break;
        r[i]=r[j];
        i=j;
        j=2*i;
    }
    r[i]=r[0];
}
void HeapSort(list r,int n){
    int i;
    for(i=n/2;i>=1;i--) Sift(r,i,n);
    for(i=n;i>=2;i--){
        r[0]=r[1]; r[1]=r[i];r[i]=r[0];
        Sift(r,1,i-1);
    }
}