几种排序算法的认识

时间 2019-12-11

标签几种排序算法认识繁體版

原文原文链接

全部排序算法总结：冒泡排序，快速排序，插入排序，归并排序，堆排序，shell排序，选择排序html

算法排序的稳定性是指：关键码相同的记录排序先后相对位置不发生改变。举个例子：ios

待排序数组:int a[] ={1, 2, 2, 3, 4, 5, 6};
算法

在快速排序的随机选择比较子(即pivot)阶段：shell

若选择a[2]（即数组中的第二个2）为比较子，，而把大于等于比较子的数均放置在大数数组中，则a[1]（即数组中的第一个2）会到pivot的右边，那么数组中的两个2非原序（这就是“不稳定”）。windows

若选择a[1]为比较子，而把小于等于比较子的数均放置在小数数组中，则数组中的两个2顺序也非原序。数组

1. 冒泡排序函数

　　很简单的排序，外层循环是n-1趟，内层循环是n-1次两两比较。主要思路：从底部往上冒泡，经过无序区中相邻记录关键字间的比较和位置的交换,使关键字最小的记录如气泡通常逐渐往上“漂浮”直至“水面”。测试

就是在每一趟内层循环完毕以后，最小的那个值会像气泡同样上浮到第一个位置（从小到大排序），这样循环执行n-1趟，每一趟都是从最后一个值开始进行两两比较，把每趟中的最小的值往上浮。（注意内层循环的终止条件是j>i，由于i以前是已经放置好的有序的最小值）ui

代码：spa

static void bubblesort(int* A,int n){
    if(A==NULL) return;
    for (int i=0;i<n-1;++i)
    {
        for (int j=n-1;j>i;--j)
        {
            if(A[j]<A[j-1]){int temp=A[j];A[j]=A[j-1];A[j-1]=temp;}
        }
        cout<<"第"<<i+1<<"趟冒泡排序："<<endl;
        for (int i=0;i<n;++i)
        {
            cout<<A[i]<<" ";
        }
        cout<<endl;
    }
}

2. 归并排序（稳定，效率高，采用递归）

　　思路：基本思路就是将数组分红二组A，B，若是这二组组内的数据都是有序的，那么就能够很方便的将这二组数据进行排序。问题是如何让这二组组内数据有序呢？

　　能够将A，B组各自再分红二组。依次类推，当分出来的小组只有一个数据时，能够认为这个小组组内已经达到了有序，而后再合并相邻的二个小组就能够了。这样经过先递归的分解数列，再合并数列就完成了归并排序。具体过程参考下图：

代码（先用递归分解数组，而后用mergearray合并）：

//将有二个有序数列a[first...mid]和a[mid...last]合并。
void mergearray(int a[], int first, int mid, int last, int temp[])
{
    int i = first, j = mid + 1;//i为分出的第一个数组的第一个位置，j为分出来的第二个数组的第一个位置
    int m = mid,n = last;//m为分出的第一个数组的末尾，n为分出来的第二个数组的末尾
    int k = 0;

    while (i <= m && j <= n)
    {
        if (a[i] <= a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
    }

    while (i <= m)
        temp[k++] = a[i++];

    while (j <= n)
        temp[k++] = a[j++];

    for (i = 0; i < k; i++)
        a[first + i] = temp[i];
}
void mergesort(int a[], int first, int last, int temp[])
{
    if (first < last)
    {
        int mid = (first + last) / 2;
        mergesort(a, first, mid, temp);    //左边有序
        mergesort(a, mid + 1, last, temp); //右边有序
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并
    }
}

bool MergeSort(int a[], int n)
{
    int *p = new int[n];
    if (p == NULL)
        return false;
    mergesort(a, 0, n - 1, p);
    delete[] p;
    return true;
}

3. 堆排序（转http://www.cnblogs.com/dolphin0520/archive/2011/10/06/2199741.html）

1.堆

堆其实是一棵彻底二叉树，其任何一非叶节点知足性质：

Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]

即任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。

堆分为大顶堆和小顶堆，知足Key[i]>=Key[2i+1]&&key>=key[2i+2]称为大顶堆，知足 Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]称为小顶堆。由上述性质可知大顶堆的堆顶的关键字确定是全部关键字中最大的，小顶堆的堆顶的关键字是全部关键字中最小的。

2.堆排序的思想

利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。

其基本思想为(大顶堆)：

1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；

2)将堆顶元素R[1]与最后一个元素R[n]交换，此时获得新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且知足R[1,2...n-1]<=R[n];

3)因为交换后新的堆顶R[1]可能违反堆的性质，所以须要对当前无序区(R1,R2,......Rn-1)调整为新堆，而后再次将R[1]与无序区最后一个元素交换，获得新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

操做过程以下：

1)初始化堆：将R[1..n]构造为堆；

2)将当前无序区的堆顶元素R[1]同该区间的最后一个记录交换，而后将新的无序区调整为新的堆。

所以对于堆排序，最重要的两个操做就是构造初始堆和调整堆，其实构造初始堆事实上也是调整堆的过程，只不过构造初始堆是对全部的非叶节点都进行调整。

下面举例说明：

给定一个整形数组a[]={16,7,3,20,17,8}，对其进行堆排序。

首先根据该数组元素构建一个彻底二叉树，获得

而后须要构造初始堆，则从最后一个非叶节点开始调整，调整过程以下：

20和16交换后致使16不知足堆的性质，所以需从新调整

这样就获得了初始堆。

即每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换以后可能形成被交换的孩子节点不知足堆的性质，所以每次交换以后要从新对被交换的孩子节点进行调整)。有了初始堆以后就能够进行排序了。

此时3位于堆顶不满堆的性质，则需调整继续调整

这样整个区间便已经有序了。

从上述过程可知，堆排序其实也是一种选择排序，是一种树形选择排序。只不过直接选择排序中，为了从R[1...n]中选择最大记录，需比较n-1次，而后从R[1...n-2]中选择最大记录需比较n-2次。事实上这n-2次比较中有不少已经在前面的n-1次比较中已经作过，而树形选择排序刚好利用树形的特色保存了部分前面的比较结果，所以能够减小比较次数。对于n个关键字序列，最坏状况下每一个节点需比较log2(n)次，所以其最坏状况下时间复杂度为 nlogn。堆排序为不稳定排序，不适合记录较少的排序。

测试程序

/*堆排序(大顶堆) 2011.9.14*/ 

#include <iostream>
#include<algorithm>
using namespace std;

void HeapAdjust(int *a,int i,int size) //调整堆 
{
 int lchild=2*i; //i的左孩子节点序号 
 int rchild=2*i+1; //i的右孩子节点序号 
 int max=i; //临时变量 
 if(i<=size/2) //若是i是叶节点就不用进行调整 
 {
 if(lchild<=size&&a[lchild]>a[max])
 {
 max=lchild;
 } 
 if(rchild<=size&&a[rchild]>a[max])
 {
 max=rchild;
 }
 if(max!=i)
 {
 swap(a[i],a[max]);
 HeapAdjust(a,max,size); //避免调整以后以max为父节点的子树不是堆 
 }
 } 
}

void BuildHeap(int *a,int size) //创建堆 
{
 int i;
 for(i=size/2;i>=1;i--) //非叶节点最大序号值为size/2 
 {
 HeapAdjust(a,i,size); 
 } 
} 

void HeapSort(int *a,int size) //堆排序 
{
 int i;
 BuildHeap(a,size);
 for(i=size;i>=1;i--)
 {
 //cout<<a[1]<<" ";
 swap(a[1],a[i]); //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 
 //BuildHeap(a,i-1); //将余下元素从新创建为大顶堆 
 HeapAdjust(a,1,i-1); //从新调整堆顶节点成为大顶堆
 }
} 

int main(int argc, char *argv[])
{
 //int a[]={0,16,20,3,11,17,8};
 int a[100];
 int size;
 while(scanf("%d",&size)==1&&size>0)
 {
 int i;
 for(i=1;i<=size;i++)
 cin>>a[i];
 HeapSort(a,size);
 for(i=1;i<=size;i++)
 cout<<a[i]<<"";
 cout<<endl;
 }
 return 0;
}

4.快速排序

　　思路：主要patition函数的编写，即先选一个值做为哨兵，而后把小于该哨兵的数字放在其左边（后称左边序列），而后把大于哨兵的数字放在右边（后称右边序列）。该函数有几种实现方法，请参见http://www.cnblogs.com/mfryf/archive/2012/08/06/2625300.html

　　该函数用small指针来表示左边序列的最后一个位置，当发现某个值A[i]小于哨兵时，只需先对该small指针后移一位（移到右边序列的第一位），而后将A[small]和A[i]互换便可，换完以后，small指针仍然指向左边序列最后一个位置。

　　因此说，数组A，在进行一轮快速排序的时候，实际上有一个哨兵和三个序列，左边序列，右边序列，待排序列。

具体如图所示：

5.直接插入排序（最好O(n),最坏O(n²)）参考博文

　　思路：把一个序列分为两个区，前部分是已排好的序列sorted，然后部分则是待排序列wait_sort，插入排序就是选择wait_sort中的第一个元素，直接插入到sorted序列中。

　　假设要插入元素a[i],则插入的步骤分为3步：1>在sorted序列中找到要插入元素的位置j。2>将位置j以后的序列日后移动一位，给带插入的a[i]空出一个位置。3>把元素a[i]插入到sorted序列中。

设数组为a[0…n-1]。

1. 初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1

2. 将a[i]并入当前的有序区a[0…i-1]中造成a[0…i]的有序区间。

3. i++并重复第二步直到i==n-1。排序完成。

下面给出严格按照定义书写的代码（由小到大排序）：

void Insertsort1(int a[], int n)
{
    int i, j, k;
    for (i = 1; i < n; i++)
    {
        //为a[i]在前面的a[0...i-1]有序区间中找一个合适的位置
        for (j = i - 1; j >= 0; j--)
            if (a[j] < a[i])
                break;

        //如找到了一个合适的位置
        if (j != i - 1)
        {
            //将比a[i]大的数据向后移
            int temp = a[i];
            for (k = i - 1; k > j; k--)
                a[k + 1] = a[k];
            //将a[i]放到正确位置上
            a[j+1] = temp;
        }
    }
}

　　这样的代码太长了，不够清晰。如今进行一下改写，将搜索和数据后移这二个步骤合并。即每次a[i]先和前面一个数据a[i-1]比较，若是a[i] > a[i-1]说明a[0…i]也是有序的，无须调整。不然就令j=i-1,temp=a[i]。而后一边将数据a[j]向后移动一边向前搜索，当有数据a[j]<a[i]时中止并将temp放到a[j + 1]处。

void Insertsort2(int a[], int n)
{
    int i, j;
    for (i = 1; i < n; i++)
        if (a[i] < a[i - 1])
        {
            int temp = a[i];
            for (j = i - 1; j >= 0 && a[j] > temp; j--)
                a[j + 1] = a[j];
            a[j + 1] = temp;
        }
}