zoukankan      html  css  js  c++  java
  • 几种排序算法的认识

    所有排序算法总结:冒泡排序,快速排序,插入排序,归并排序,堆排序,shell排序,选择排序

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

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

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

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

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

    1. 冒泡排序

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

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

    代码:

    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;
    }

    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(n2))参考博文
      思路:把一个序列分为两个区,前部分是已排好的序列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;
            }
    }

     
     
     
     
  • 相关阅读:
    2017/08/02 工作日志
    2017/08/01 工作日志
    http随笔
    window open() 方法
    asp.net中gridview控件的一些基本使用方法
    《java.util.concurrent 包源码阅读》04 ConcurrentMap
    《java.util.concurrent 包源码阅读》03 锁
    《java.util.concurrent 包源码阅读》02 关于java.util.concurrent.atomic包
    __stdcall 与 __cdecl
    iebugs产生的原因,zoom:1的作用
  • 原文地址:https://www.cnblogs.com/fightformylife/p/4335390.html
Copyright © 2011-2022 走看看