zoukankan      html  css  js  c++  java

  • 常见排序算法题（java版）

    常见排序算法题（java版）
    //插入排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class InsertSort implements SortUtil.Sort{
     
        /** (non-Javadoc)
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            int temp;
            for(int i=1;i<data.length;i++){
                for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                    SortUtil.swap(data,j,j-1);
                }
            }       
        }
     
    }
    //冒泡排序:
     
     
    for(var i=0; i<arr.length; i++) {   
        for(var j=i+1; j<=arr.length-1; j++) {
            if(eval(arr[i]) < eval(arr[j])) {       
                temp = arr[i];                     
                arr[i] = arr[j];                       
                arr[j] = temp;                                             
            }
        }
    }
     
     
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class BubbleSort implements SortUtil.Sort{
     
        /** (non-Javadoc)
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            int temp;
            for(int i=0;i<data.length;i++){
                for(int j=data.length-1;j>i;j--){
                    if(data[j]<data[j-1]){
                        SortUtil.swap(data,j,j-1);
                    }
                }
            }
        }
     
    }
     
    //选择排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class SelectionSort implements SortUtil.Sort {
     
        /**
         * (non-Javadoc)
         *
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            int temp;
            for (int i = 0; i < data.length; i++) {
                int lowIndex = i;
                for (int j = data.length - 1; j > i; j--) {
                    if (data[j] < data[lowIndex]) {
                        lowIndex = j;
                    }
                }
                SortUtil.swap(data,i,lowIndex);
            }
        }
     
    }
     
    //Shell排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class ShellSort implements SortUtil.Sort{
     
        /** (non-Javadoc)
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            for(int i=data.length/2;i>2;i/=2){
                for(int j=0;j<i;j++){
                    insertSort(data,j,i);
                }
            }
            insertSort(data,0,1);
        }
     
        /**
         * @param data
         * @param j
         * @param i
         */
        private void insertSort(int[] data, int start, int inc) {
            int temp;
            for(int i=start+inc;i<data.length;i+=inc){
                for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
                    SortUtil.swap(data,j,j-inc);
                }
            }
        }
     
    }
     
    //快速排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class QuickSort implements SortUtil.Sort{
     
        /** (non-Javadoc)
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            quickSort(data,0,data.length-1);       
        }
        private void quickSort(int[] data,int i,int j){
            int pivotIndex=(i+j)/2;
            //swap
            SortUtil.swap(data,pivotIndex,j);
             
            int k=partition(data,i-1,j,data[j]);
            SortUtil.swap(data,k,j);
            if((k-i)>1) quickSort(data,i,k-1);
            if((j-k)>1) quickSort(data,k+1,j);
             
        }
        /**
         * @param data
         * @param i
         * @param j
         * @return
         */
        private int partition(int[] data, int l, int r,int pivot) {
            do{
               while(data[++l]<pivot);
               while((r!=0)&&data[--r]>pivot);
               SortUtil.swap(data,l,r);
            }
            while(l<r);
            SortUtil.swap(data,l,r);       
            return l;
        }
     
    }
    //改进后的快速排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class ImprovedQuickSort implements SortUtil.Sort {
     
        private static int MAX_STACK_SIZE=4096;
        private static int THRESHOLD=10;
        /** (non-Javadoc)
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            int[] stack=new int[MAX_STACK_SIZE];
             
            int top=-1;
            int pivot;
            int pivotIndex,l,r;
             
            stack[++top]=0;
            stack[++top]=data.length-1;
             
            while(top>0){
                int j=stack[top--];
                int i=stack[top--];
                 
                pivotIndex=(i+j)/2;
                pivot=data[pivotIndex];
                 
                SortUtil.swap(data,pivotIndex,j);
                 
                //partition
                l=i-1;
                r=j;
                do{
                    while(data[++l]<pivot);
                    while((r!=0)&&(data[--r]>pivot));
                    SortUtil.swap(data,l,r);
                }
                while(l<r);
                SortUtil.swap(data,l,r);
                SortUtil.swap(data,l,j);
                 
                if((l-i)>THRESHOLD){
                    stack[++top]=i;
                    stack[++top]=l-1;
                }
                if((j-l)>THRESHOLD){
                    stack[++top]=l+1;
                    stack[++top]=j;
                }
                 
            }
            //new InsertSort().sort(data);
            insertSort(data);
        }
        /**
         * @param data
         */
        private void insertSort(int[] data) {
            int temp;
            for(int i=1;i<data.length;i++){
                for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                    SortUtil.swap(data,j,j-1);
                }
            }      
        }
     
    }
     
    //归并排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class MergeSort implements SortUtil.Sort{
     
        /** (non-Javadoc)
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            int[] temp=new int[data.length];
            mergeSort(data,temp,0,data.length-1);
        }
         
        private void mergeSort(int[] data,int[] temp,int l,int r){
            int mid=(l+r)/2;
            if(l==r) return ;
            mergeSort(data,temp,l,mid);
            mergeSort(data,temp,mid+1,r);
            for(int i=l;i<=r;i++){
                temp[i]=data[i];
            }
            int i1=l;
            int i2=mid+1;
            for(int cur=l;cur<=r;cur++){
                if(i1==mid+1)
                    data[cur]=temp[i2++];
                else if(i2>r)
                    data[cur]=temp[i1++];
                else if(temp[i1]<temp[i2])
                    data[cur]=temp[i1++];
                else
                    data[cur]=temp[i2++];           
            }
        }
     
    }
     
    //改进后的归并排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class ImprovedMergeSort implements SortUtil.Sort {
     
        private static final int THRESHOLD = 10;
     
        /**
         * (non-Javadoc)
         *
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            int[] temp=new int[data.length];
            mergeSort(data,temp,0,data.length-1);
        }
     
        private void mergeSort(int[] data, int[] temp, int l, int r) {
            int i, j, k;
            int mid = (l + r) / 2;
            if (l == r)
                return;
            if ((mid - l) >= THRESHOLD)
                mergeSort(data, temp, l, mid);
            else
                insertSort(data, l, mid - l + 1);
            if ((r - mid) > THRESHOLD)
                mergeSort(data, temp, mid + 1, r);
            else
                insertSort(data, mid + 1, r - mid);
     
            for (i = l; i <= mid; i++) {
                temp[i] = data[i];
            }
            for (j = 1; j <= r - mid; j++) {
                temp[r - j + 1] = data[j + mid];
            }
            int a = temp[l];
            int b = temp[r];
            for (i = l, j = r, k = l; k <= r; k++) {
                if (a < b) {
                    data[k] = temp[i++];
                    a = temp[i];
                } else {
                    data[k] = temp[j--];
                    b = temp[j];
                }
            }
        }
     
        /**
         * @param data
         * @param l
         * @param i
         */
        private void insertSort(int[] data, int start, int len) {
            for(int i=start+1;i<start+len;i++){
                for(int j=i;(j>start) && data[j]<data[j-1];j--){
                    SortUtil.swap(data,j,j-1);
                }
            }
        }
     
    }
    //堆排序:
     
    package org.rut.util.algorithm.support;
     
    import org.rut.util.algorithm.SortUtil;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class HeapSort implements SortUtil.Sort{
     
        /** (non-Javadoc)
         * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
         */
        public void sort(int[] data) {
            MaxHeap h=new MaxHeap();
            h.init(data);
            for(int i=0;i<data.length;i++)
                h.remove();
            System.arraycopy(h.queue,1,data,0,data.length);
        }
     
     
         private static class MaxHeap{
              
             
            void init(int[] data){
                this.queue=new int[data.length+1];
                for(int i=0;i<data.length;i++){
                    queue[++size]=data[i];
                    fixUp(size);
                }
            }
              
            private int size=0;
     
            private int[] queue;
                     
            public int get() {
                return queue[1];
            }
     
            public void remove() {
                SortUtil.swap(queue,1,size--);
                fixDown(1);
            }
            //fixdown
            private void fixDown(int k) {
                int j;
                while ((j = k << 1) <= size) {
                    if (j < size && queue[j]<queue[j+1])
                        j++;
                    if (queue[k]>queue[j]) //不用交换
                        break;
                    SortUtil.swap(queue,j,k);
                    k = j;
                }
            }
            private void fixUp(int k) {
                while (k > 1) {
                    int j = k >> 1;
                    if (queue[j]>queue[k])
                        break;
                    SortUtil.swap(queue,j,k);
                    k = j;
                }
            }
     
        }
     
    }
     
      
     
    //SortUtil:
     
    package org.rut.util.algorithm;
     
    import org.rut.util.algorithm.support.BubbleSort;
    import org.rut.util.algorithm.support.HeapSort;
    import org.rut.util.algorithm.support.ImprovedMergeSort;
    import org.rut.util.algorithm.support.ImprovedQuickSort;
    import org.rut.util.algorithm.support.InsertSort;
    import org.rut.util.algorithm.support.MergeSort;
    import org.rut.util.algorithm.support.QuickSort;
    import org.rut.util.algorithm.support.SelectionSort;
    import org.rut.util.algorithm.support.ShellSort;
     
    /**
     * @author treeroot
     * @since 2006-2-2
     * @version 1.0
     */
    public class SortUtil {
        public final static int INSERT = 1;
     
        public final static int BUBBLE = 2;
     
        public final static int SELECTION = 3;
     
        public final static int SHELL = 4;
     
        public final static int QUICK = 5;
     
        public final static int IMPROVED_QUICK = 6;
     
        public final static int MERGE = 7;
     
        public final static int IMPROVED_MERGE = 8;
     
        public final static int HEAP = 9;
     
        public static void sort(int[] data) {
            sort(data, IMPROVED_QUICK);
        }
        private static String[] name={
                "insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
        };
         
        private static Sort[] impl=new Sort[]{
                new InsertSort(),
                new BubbleSort(),
                new SelectionSort(),
                new ShellSort(),
                new QuickSort(),
                new ImprovedQuickSort(),
                new MergeSort(),
                new ImprovedMergeSort(),
                new HeapSort()
        };
     
        public static String toString(int algorithm){
            return name[algorithm-1];
        }
         
        public static void sort(int[] data, int algorithm) {
            impl[algorithm-1].sort(data);
        }
     
        public static interface Sort {
            public void sort(int[] data);
        }
     
        public static void swap(int[] data, int i, int j) {
            int temp = data[i];
            data[i] = data[j];
            data[j] = temp;
        }
    }
     
     
     
     

    各大排序算法性能比较

     移动开发  来源:iOSDevTip  2016-11-02 05:21  1922℃  0评论

    点击上方蓝色字体关注「iOS开发」

    所谓排序，即将原来无序的一个序列重新排列成有序的序列。

    排序方法中涉及到稳定性，所谓稳定性，是指待排序的序列中有两个或两个以上相同的项，在排序前和排序后看这些相同项的相对位置有没有发生变化，如果没有发生变化，即该排序方法是稳定的，如果发生变化，则说明该排序方法是不稳定的。

    如果记录中关键字不能重复，则排序结果是唯一的，那么选择的排序方法稳定与否就无关紧要了；如果关键字可以重复，则在选择排序方法时，就要根据具体的需求来考虑选择稳定还是不稳定的排序方法。那么，哪些排序算法是不稳定的呢？

    “快些选堆”：其中“快”指快速排序，“些”指希尔排序，“选”指选择排序，“堆”指堆排序，即这四种排序方法是不稳定的，其他自然都是稳定的。

    排序算法分类

    1. 插入类排序

    即在一个已经有序的序列中，插入一个新的记录，就好比军训排队，已经排好一个纵队，这时来了个新家伙，于是新来的“插入”这个队伍中的合适位置。这类排序有：直接插入排序、折半插入排序、希尔排序。

    2.交换类排序

    该类方法的核心是“交换”，即每趟排序，都是通过一系列的“交换”动作完成的，如军训排队时，教官说：你比旁边的高，你俩交换下，还比下一个高就继续交换。这类排序有：冒泡排序、快速排序。

    3. 选择类排序

    该方法的核心是“选择”，即每趟排序都选出一个最小（或最大）的记录，把它和序列中的第一个（或最后一个）记录交换，这样最小（或最大）的记录到位。如军训排队时，教官选出个子最小的同学，让他和第一个位置的同学交换，剩下的继续选择。这类排序有：选择排序、堆排序。

    4. 归并类排序

    所谓归并，就是将两个或两个以上的有序序列合并成一个新的有序序列。如军训排队时，教官说：每个人先和旁边的人组成二人组，组内排好队，二人组和旁边的二人组组成四人组，内部再排好队，以此类推，直到最后全部同学都归并到一个组中并排好序。这类排序有：（二路）归并排序。

    5. 基数类排序

    此类方法较为特别，是基于多关键字排序的思想，把一个逻辑关键字拆分成多个关键字，如一副扑克牌，按照基数排序思想可以先按花色排序，则分成4堆，每堆再按A-K的顺序排序，使得整副扑克牌最终有序。

    排序算法分析

    本文主要分析的排序算法有：冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序。

    交换算法

    由于大部分排序算法中使用到两个记录相互交换的动作，因此将交换动作单独封装出来，便于各排序算法使用。

    //交换函数Array.prototype.swap = function(i, j) {   
            var temp = this[i];   
            this[i] = this[j];   
            this[j] = temp;   
    }     插入排序

    算法思想：每趟将一个待排序的关键字，按照其关键字值的大小插入到已经排好的部分序列的适当位置上，直到插入完成。

    //插入排序Array.prototype.insertionSort = function() {          for (var i = 1; i < this.length; ++i)          {                   var j = i,                          value = this[i];                   while (j > 0 && this[j - 1] > value)                  {                              this[j] = this[j - 1];                              --j;                  }                  this[j] = value;          }  }

    算法性能：在内层循环中this[j]=this[j-1]，这句是作为基本操作。考虑最坏情况，即整个序列是逆序的，则其基本操作总的执行次数为n*(n-1)/2，其时间复杂度为O(n*n)。考虑最好情况，即整个序列已经有序，则循环内的操作均为常量级，其时间复杂度为O(n)。因此本算法平均时间复杂度为O(n*n)。算法所需的额外空间只有一个value，因此空间复杂度为O(1)。

    希尔排序

    算法思想：希尔排序又叫做缩小增量排序，是将待排序的序列按某种规则分成几个子序列，分别对这几个子序列进行插入排序，其中这一规则就是增量。如可以使用增量5、3、1来分格序列，且每一趟希尔排序的增量都是逐渐缩小的，希尔排序的每趟排序都会使得整个序列变得更加有序，等整个序列基本有序了，再使用一趟插入排序，这样会更有效率，这就是希尔排序的思想。

    //希尔排序Array.prototype.shellSort = function() {          for (var step = this.length >> 1; step > 0; step >>= 1)          {                  for (var i = 0; i < step; ++i)                   {                          for (var j = i + step; j < this.length; j += step)                          {                                  var k = j, value = this[j];                                  while (k >= step && this[k - step] > value)                                  {                                          this[k] = this[k - step];                                          k -= step;                                  }                                  this[k] = value;                          }                  }          }  }

    算法性能：希尔排序的时间复杂度平均情况为O(nlogn)，空间复杂度为O(1)。希尔排序的增量取法要注意，首先增量序列的最后一个值一定是1，其次增量序列中的值没有除1之外的公因子，如8，4，2，1这样的序列就不要取（有公因子2）。

    冒泡排序

    算法思想：通过一系列的“交换”动作完成的，首先第一个记录与第二个记录比较，如果第一个大，则二者交换，否则不交换；然后第二个记录和第三个记录比较，如果第二个大，则二者交换，否则不交换，以此类推，最终最大的那个记录被交换到了最后，一趟冒泡排序完成。在这个过程中，大的记录就像一块石头一样沉底，小的记录逐渐向上浮动。冒泡排序算法结束的条件是一趟排序没有发生元素交换。

    //冒泡排序Array.prototype.bubbleSort = function() {   
            for (var i = this.length - 1; i > 0; --i)   
            {   
                   for (var j = 0; j < i; ++j)   
                            if (this[j] > this[j + 1])  
                                    this.swap(j, j + 1);              }   
    }

    算法性能：最内层循环的元素交换操作是算法的基本操作。最坏情况，待排序列逆序，则基本操作的总执行次数为(n-1+1)*(n-1)/2=n(n-1)/2，其时间复杂度为O(n*n)；最好情况，待排序列有序，则时间复杂度为O(n)，因此平均情况下的时间复杂度为O(n*n)。算法的额外辅助空间只有一个用于交换的temp，所以空间复杂度为O(1)。

    快速排序

    算法思想：以军训排队为例，教官说以第一个同学为中心，比他矮的站他左边，比他高的站他右边，这就是一趟快速排序。因此，一趟快速排序是以一个枢轴，将序列分成两部分，枢轴的一边比它小（或小于等于），另一边比它大（或大于等于）。

    //递归快速排序Array.prototype.quickSort = function(s, e) {          if (s == null)                s = 0;          if (e == null)                e = this.length - 1;          if (s >= e)                return;          this.swap((s + e) >> 1, e);          var index = s - 1;          for (var i = s; i <= e; ++i)                  if (this[i] <= this[e]) this.swap(i, ++index);          this.quickSort(s, index - 1);          this.quickSort(index + 1, e);  }

    算法性能：快速排序最好情况下时间复杂度为O(nlogn)，待排序列越接近无序，则该算法效率越高，在最坏情况下时间复杂度为O(n*n)，待排序列越接近有序，则该算法效率越低，算法的平均时间复杂度为O(nlogn)。就平均时间而言，快速排序是所有排序算法中最好的。该算法的空间复杂度为O(logn)，快速排序是递归进行的，需要栈的辅助，因此需要的辅助空间比前面几类排序方法要多。

    快速排序的效率和选取的“枢轴”有关，选取的枢轴越接近中间值，算法效率就越高，因此为了提高算法效率，可以在第一次选取“枢轴”时做文章，如在数据堆中随机选取3个值，取3个值的平均值作为“枢轴”，就如抽样一般。关于具体如何提高快速排序算法的效率，在本文不做详细介绍了，点到为止。（感兴趣的读者可以自行去研究）

    选择排序

    算法思想：该算法的主要动作就是“选择”，采用简单的选择方式，从头至尾顺序扫描序列，找出最小的一个记录，和第一个记录交换，接着从剩下的记录中继续这种选择和交换，最终使序列有序。

    //选择排序Array.prototype.selectionSort = function() {          for (var i = 0; i < this.length; ++i)          {                  var index = i;                  for (var j = i + 1; j < this.length; ++j)                  {                          if (this[j] < this[index])                                index = j;                  }                  this.swap(i, index);          }  }

    算法性能：将最内层循环中的比较视为基本操作，其执行次数为(n-1+1)*(n-1)/2=n(n-1)/2，其时间复杂度为O(n*n)，本算法的额外空间只有一个temp，因此空间复杂度为O(1)。

    堆排序

    算法思想：堆是一种数据结构，最好的理解堆的方式就是把堆看成一棵完全二叉树，这个完全二叉树满足任何一个非叶节点的值，都不大于（或不小于）其左右孩子节点的值。若父亲大孩子小，则这样的堆叫做大顶堆；若父亲小孩子大，这样的堆叫做小顶堆。根据堆的定义，其根节点的值是最大（或最小），因此将一个无序序列调整为一个堆，就可以找出这个序列的最大（或最小）值，然后将找出的这个值交换到序列的最后（或最前），这样有序序列元素增加1个，无序序列中元素减少1个，对新的无序序列重复这样的操作，就实现了序列排序。堆排序中最关键的操作是将序列调整为堆，整个排序的过程就是通过不断调整使得不符合堆定义的完全二叉树变为符合堆定义的完全二叉树的过程。

    堆排序执行过程（大顶堆）：

    （1）从无序序列所确定的完全二叉树的第一个非叶子节点开始，从右至左，从下至上，对每个节点进行调整，最终将得到一个大顶堆。将当前节点（a）的值与其孩子节点进行比较，如果存在大于a值的孩子节点，则从中选出最大的一个与a交换。当a来到下一层的时候重复上述过程，直到a的孩子节点值都小于a的值为止。

    （2）将当前无序序列中第一个元素，在树中是根节点（a）与无序序列中最后一个元素（b）交换。a进入有序序列，到达最终位置，无序序列中元素减少1个，有序序列中元素增加1个，此时只有节点b可能不满足堆的定义，对其进行调整。

    （3）重复过程2，直到无序序列中的元素剩下1个时排序结束。

    //堆排序Array.prototype.heapSort = function() {          for (var i = 1; i < this.length; ++i)                  {                  for (var j = i, k = (j - 1) >> 1; k >= 0; j = k, k = (k - 1) >> 1)                  {                          if (this[k] >= this[j])                                break;                          this.swap(j, k);                  }          }          for (var i = this.length - 1; i > 0; --i)          {                  this.swap(0, i);                  for (var j = 0, k = (j + 1) << 1; k <= i; j = k, k = (k + 1) << 1)                  {                          if (k == i || this[k] < this[k - 1])                                --k;                          if (this[k] <= this[j])                                break;                          this.swap(j, k);                  }          }  }

    算法性能：完全二叉树的高度为[log(n+1)]，即对每个节点调整的时间复杂度为O(logn)，基本操作总次数是两个并列循环中基本操作次数相加，则整个算法时间复杂度为O(logn)*n/2+O(logn)*(n-1)，即O(nlogn)。额外空间只有一个temp，因此空间复杂度为O(1)。

    堆排序的优点是适合记录数很多的场景，如从1000000个记录中选出前10个最小的，这种情况用堆排序最好，如果记录数较少，则不提倡使用堆排序。另外，Hash表+堆排序是处理海量数据的绝佳组合，关于海量数据处理会在之后的博文中介绍到。

    归并排序

    算法思想：其核心就是“两两归并”，首先将原始序列看成每个只含有单独1个元素的子序列，两两归并，形成若干有序二元组，则第一趟归并排序结束，再将这个序列看成若干个二元组子序列，继续两两归并，形成若干有序四元组，则第二趟归并排序结束，以此类推，最后只有两个子序列，再进行一次归并，即完成整个归并排序。

    //归并排序Array.prototype.mergeSort = function(s, e, b) {         if (s == null)                s = 0;          if (e == null)                e = this.length - 1;          if (b == null)                b = new Array(this.length);          if (s >= e)                return;          var m = (s + e) >> 1;          this.mergeSort(s, m, b);          this.mergeSort(m + 1, e, b);          for (var i = s, j = s, k = m + 1; i <= e; ++i)                  b[i] = this[(k > e || j <= m && this[j] < this[k]) ? j++ : k++];          for (var i = s; i <= e; ++i)                this[i] = b[i];  }

    算法性能：可以选取“归并操作”作为基本操作，“归并操作”即为将待归并表中元素复制到一个存储归并结果的表中的过程，其次数为要归并的两个子序列中元素个数之和。算法总共需要进行logn趟排序，每趟排序执行n次基本操作，因此整个归并排序中总的基本操作执行次数为nlogn，即时间复杂度为O(nlogn)，说明归并排序时间复杂度和初始序列无关。由于归并排序需要转存整个待排序列，因此空间复杂度为O(n)。

    一些结论

    （1）快速排序、希尔排序、归并排序、堆排序的平均时间为O(nlogn)，其他的为O(n*n)。

    （2）快速排序、希尔排序、选择排序、堆排序不稳定，其他的稳定。

    （3）经过一趟排序能够保证一个元素到达最终位置的是冒泡排序、快速排序、选择排序、堆排序。

    （4）元素比较次数和原始序列无关的是选择排序、折半插入排序。

    （5）排序趟数和原始序列有关的是交换类排序。

    （6）直接插入排序和折半插入排序的区别是寻找插入位置的方式不同，一个是按顺序查找方式，另一个是按折半查找方式。

     

    八大排序算法

    标签： 算法mergepivot存储exchange
    2012-07-23 16:45 516483人阅读 评论(134) 收藏 举报
     分类：
     

    版权声明：本文为博主原创文章，未经博主允许不得转载。

     

    目录(?)[+]

     

    概述

    排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

    我们这里说说八大排序就是内部排序。

        

        当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

       快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；

    1.插入排序—直接插入排序(Straight Insertion Sort)

    基本思想:

    将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

    要点：设立哨兵，作为临时存储和判断数组边界之用。

    直接插入排序示例：

    如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

    算法的实现：

    [cpp] view plain copy
     
     print?
    1. void print(int a[], int n ,int i){  
    2.     cout<<i <<":";  
    3.     for(int j= 0; j<8; j++){  
    4.         cout<<a[j] <<" ";  
    5.     }  
    6.     cout<<endl;  
    7. }  
    8.   
    9.   
    10. void InsertSort(int a[], int n)  
    11. {  
    12.     for(int i= 1; i<n; i++){  
    13.         if(a[i] < a[i-1]){               //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入  
    14.             int j= i-1;   
    15.             int x = a[i];        //复制为哨兵，即存储待排序元素  
    16.             a[i] = a[i-1];           //先后移一个元素  
    17.             while(x < a[j]){  //查找在有序表的插入位置  
    18.                 a[j+1] = a[j];  
    19.                 j--;         //元素后移  
    20.             }  
    21.             a[j+1] = x;      //插入到正确位置  
    22.         }  
    23.         print(a,n,i);           //打印每趟排序的结果  
    24.     }  
    25.       
    26. }  
    27.   
    28. int main(){  
    29.     int a[8] = {3,1,5,7,2,4,9,6};  
    30.     InsertSort(a,8);  
    31.     print(a,8,8);  
    32. }  

    效率：

    时间复杂度：O（n^2）.

    其他的插入排序有二分插入排序，2-路插入排序。

     2. 插入排序—希尔排序（Shell`s Sort）

    希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

    基本思想：

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

    操作方法：

    1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
    2. 按增量序列个数k，对序列进行k 趟排序；
    3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

    希尔排序的示例：

    算法实现：

    我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

    即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

    [cpp] view plain copy
     
     print?
    1. void print(int a[], int n ,int i){  
    2.     cout<<i <<":";  
    3.     for(int j= 0; j<8; j++){  
    4.         cout<<a[j] <<" ";  
    5.     }  
    6.     cout<<endl;  
    7. }  
    8. /** 
    9.  * 直接插入排序的一般形式 
    10.  * 
    11.  * @param int dk 缩小增量，如果是直接插入排序，dk=1 
    12.  * 
    13.  */  
    14.   
    15. void ShellInsertSort(int a[], int n, int dk)  
    16. {  
    17.     for(int i= dk; i<n; ++i){  
    18.         if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入  
    19.             int j = i-dk;     
    20.             int x = a[i];           //复制为哨兵，即存储待排序元素  
    21.             a[i] = a[i-dk];         //首先后移一个元素  
    22.             while(x < a[j]){     //查找在有序表的插入位置  
    23.                 a[j+dk] = a[j];  
    24.                 j -= dk;             //元素后移  
    25.             }  
    26.             a[j+dk] = x;            //插入到正确位置  
    27.         }  
    28.         print(a, n,i );  
    29.     }  
    30.       
    31. }  
    32.   
    33. /** 
    34.  * 先按增量d（n/2,n为要排序数的个数进行希尔排序 
    35.  * 
    36.  */  
    37. void shellSort(int a[], int n){  
    38.   
    39.     int dk = n/2;  
    40.     while( dk >= 1  ){  
    41.         ShellInsertSort(a, n, dk);  
    42.         dk = dk/2;  
    43.     }  
    44. }  
    45. int main(){  
    46.     int a[8] = {3,1,5,7,2,4,9,6};  
    47.     //ShellInsertSort(a,8,1); //直接插入排序  
    48.     shellSort(a,8);           //希尔插入排序  
    49.     print(a,8,8);  
    50. }  
    希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法，有取奇数的，也有取质数的，但需要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

    3. 选择排序—简单选择排序（Simple Selection Sort）

    基本思想：

    在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

    简单选择排序的示例：

     

    操作方法：

    第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

    第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

    以此类推.....

    第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

    直到整个序列按关键码有序。

    算法实现：

    [cpp] view plain copy
     
     print?
    1. void print(int a[], int n ,int i){  
    2.     cout<<"第"<<i+1 <<"趟 : ";  
    3.     for(int j= 0; j<8; j++){  
    4.         cout<<a[j] <<"  ";  
    5.     }  
    6.     cout<<endl;  
    7. }  
    8. /** 
    9.  * 数组的最小值 
    10.  * 
    11.  * @return int 数组的键值 
    12.  */  
    13. int SelectMinKey(int a[], int n, int i)  
    14. {  
    15.     int k = i;  
    16.     for(int j=i+1 ;j< n; ++j) {  
    17.         if(a[k] > a[j]) k = j;  
    18.     }  
    19.     return k;  
    20. }  
    21.   
    22. /** 
    23.  * 选择排序 
    24.  * 
    25.  */  
    26. void selectSort(int a[], int n){  
    27.     int key, tmp;  
    28.     for(int i = 0; i< n; ++i) {  
    29.         key = SelectMinKey(a, n,i);           //选择最小的元素  
    30.         if(key != i){  
    31.             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换  
    32.         }  
    33.         print(a,  n , i);  
    34.     }  
    35. }  
    36. int main(){  
    37.     int a[8] = {3,1,5,7,2,4,9,6};  
    38.     cout<<"初始值：";  
    39.     for(int j= 0; j<8; j++){  
    40.         cout<<a[j] <<"  ";  
    41.     }  
    42.     cout<<endl<<endl;  
    43.     selectSort(a, 8);  
    44.     print(a,8,8);  
    45. }  

     简单选择排序的改进——二元选择排序

    简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。具体实现如下：

    [cpp] view plain copy
     
     print?
    1. void SelectSort(int r[],int n) {  
    2.     int i ,j , min ,max, tmp;  
    3.     for (i=1 ;i <= n/2;i++) {    
    4.         // 做不超过n/2趟选择排序   
    5.         min = i; max = i ; //分别记录最大和最小关键字记录位置  
    6.         for (j= i+1; j<= n-i; j++) {  
    7.             if (r[j] > r[max]) {   
    8.                 max = j ; continue ;   
    9.             }    
    10.             if (r[j]< r[min]) {   
    11.                 min = j ;   
    12.             }     
    13.       }    
    14.       //该交换操作还可分情况讨论以提高效率  
    15.       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
    16.       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
    17.   
    18.     }   
    19. }  

    4. 选择排序—堆排序（Heap Sort）

    堆排序是一种树形选择排序，是对直接选择排序的有效改进。

    基本思想：

    堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足

    时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。 若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

    （a）大顶堆序列：（96, 83,27,38,11,09)

      (b)  小顶堆序列：（12，36，24，85，47，30，53，91）

     

    初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

    因此，实现堆排序需解决两个问题： 1. 如何将n 个待排序的数建成堆； 2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

    首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。 调整小顶堆的方法：

    1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

    2）将根结点与左、右子树中较小元素的进行交换。

    3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.

    4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.

    5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

    称这个自根结点到叶子结点的调整过程为筛选。如图：

    再讨论对n 个元素初始建堆的过程。 建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

    1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

    2）筛选从第个结点为根的子树开始，该子树成为堆。

    3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

    如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）                               

                                  

     算法的实现：

    从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

    [cpp] view plain copy
     
     print?
    1. void print(int a[], int n){  
    2.     for(int j= 0; j<n; j++){  
    3.         cout<<a[j] <<"  ";  
    4.     }  
    5.     cout<<endl;  
    6. }  
    7.   
    8.   
    9.   
    10. /** 
    11.  * 已知H[s…m]除了H[s] 外均满足堆的定义 
    12.  * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,  
    13.  * 
    14.  * @param H是待调整的堆数组 
    15.  * @param s是待调整的数组元素的位置 
    16.  * @param length是数组的长度 
    17.  * 
    18.  */  
    19. void HeapAdjust(int H[],int s, int length)  
    20. {  
    21.     int tmp  = H[s];  
    22.     int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)  
    23.     while (child < length) {  
    24.         if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
    25.             ++child ;  
    26.         }  
    27.         if(H[s]<H[child]) {  // 如果较大的子结点大于父结点  
    28.             H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点  
    29.             s = child;       // 重新设置s ,即待调整的下一个结点的位置  
    30.             child = 2*s+1;  
    31.         }  else {            // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出  
    32.              break;  
    33.         }  
    34.         H[s] = tmp;         // 当前待调整的结点放到比其大的孩子结点位置上  
    35.     }  
    36.     print(H,length);  
    37. }  
    38.   
    39.   
    40. /** 
    41.  * 初始堆进行调整 
    42.  * 将H[0..length-1]建成堆 
    43.  * 调整完之后第一个元素是序列的最小的元素 
    44.  */  
    45. void BuildingHeap(int H[], int length)  
    46. {   
    47.     //最后一个有孩子的节点的位置 i=  (length -1) / 2  
    48.     for (int i = (length -1) / 2 ; i >= 0; --i)  
    49.         HeapAdjust(H,i,length);  
    50. }  
    51. /** 
    52.  * 堆排序算法 
    53.  */  
    54. void HeapSort(int H[],int length)  
    55. {  
    56.     //初始堆  
    57.     BuildingHeap(H, length);  
    58.     //从最后一个元素开始对序列进行调整  
    59.     for (int i = length - 1; i > 0; --i)  
    60.     {  
    61.         //交换堆顶元素H[0]和堆中最后一个元素  
    62.         int temp = H[i]; H[i] = H[0]; H[0] = temp;  
    63.         //每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整  
    64.         HeapAdjust(H,0,i);  
    65.   }  
    66. }   
    67.   
    68. int main(){  
    69.     int H[10] = {3,1,5,7,2,4,9,6,10,8};  
    70.     cout<<"初始值：";  
    71.     print(H,10);  
    72.     HeapSort(H,10);  
    73.     //selectSort(a, 8);  
    74.     cout<<"结果：";  
    75.     print(H,10);  
    76.   
    77. }  

    分析:

    设树深度为k，。从根到叶的筛选，元素比较次数至多2(k-1)次，交换记录至多k 次。所以，在建好堆后，排序过程中的筛选次数不超过下式： 

                                    

    而建堆时的比较次数不超过4n 次，因此堆排序最坏情况下，时间复杂度也为：O(nlogn )。

    5. 交换排序—冒泡排序（Bubble Sort）

    基本思想：

    在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

    冒泡排序的示例：

     

    算法的实现：

    [cpp] view plain copy
     
     print?
    1. void bubbleSort(int a[], int n){  
    2.     for(int i =0 ; i< n-1; ++i) {  
    3.         for(int j = 0; j < n-i-1; ++j) {  
    4.             if(a[j] > a[j+1])  
    5.             {  
    6.                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
    7.             }  
    8.         }  
    9.     }  
    10. }  

    冒泡排序算法的改进

    对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：

    1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

    改进后算法如下:

    [cpp] view plain copy
     
     print?
    1. void Bubble_1 ( int r[], int n) {  
    2.     int i= n -1;  //初始时,最后位置保持不变  
    3.     while ( i> 0) {   
    4.         int pos= 0; //每趟开始时,无记录交换  
    5.         for (int j= 0; j< i; j++)  
    6.             if (r[j]> r[j+1]) {  
    7.                 pos= j; //记录交换的位置   
    8.                 int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
    9.             }   
    10.         i= pos; //为下一趟排序作准备  
    11.      }   
    12. }    

    2．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

    改进后的算法实现为:

    [cpp] view plain copy
     
     print?
    1. void Bubble_2 ( int r[], int n){  
    2.     int low = 0;   
    3.     int high= n -1; //设置变量的初始值  
    4.     int tmp,j;  
    5.     while (low < high) {  
    6.         for (j= low; j< high; ++j) //正向冒泡,找到最大者  
    7.             if (r[j]> r[j+1]) {  
    8.                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
    9.             }   
    10.         --high;                 //修改high值, 前移一位  
    11.         for ( j=high; j>low; --j) //反向冒泡,找到最小者  
    12.             if (r[j]<r[j-1]) {  
    13.                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
    14.             }  
    15.         ++low;                  //修改low值,后移一位  
    16.     }   
    17. }   

    6. 交换排序—快速排序（Quick Sort）

    基本思想：

    1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

    2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

    3）此时基准元素在其排好序后的正确位置

    4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

    快速排序的示例：

    （a）一趟排序的过程：

    （b）排序的全过程

    算法的实现：

     递归实现：

    [cpp] view plain copy
     
     print?
    1. void print(int a[], int n){  
    2.     for(int j= 0; j<n; j++){  
    3.         cout<<a[j] <<"  ";  
    4.     }  
    5.     cout<<endl;  
    6. }  
    7.   
    8. void swap(int *a, int *b)  
    9. {  
    10.     int tmp = *a;  
    11.     *a = *b;  
    12.     *b = tmp;  
    13. }  
    14.   
    15. int partition(int a[], int low, int high)  
    16. {  
    17.     int privotKey = a[low];                             //基准元素  
    18.     while(low < high){                                   //从表的两端交替地向中间扫描  
    19.         while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端  
    20.         swap(&a[low], &a[high]);  
    21.         while(low < high  && a[low] <= privotKey ) ++low;  
    22.         swap(&a[low], &a[high]);  
    23.     }  
    24.     print(a,10);  
    25.     return low;  
    26. }  
    27.   
    28.   
    29. void quickSort(int a[], int low, int high){  
    30.     if(low < high){  
    31.         int privotLoc = partition(a,  low,  high);  //将表一分为二  
    32.         quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序  
    33.         quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序  
    34.     }  
    35. }  
    36.   
    37. int main(){  
    38.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
    39.     cout<<"初始值：";  
    40.     print(a,10);  
    41.     quickSort(a,0,9);  
    42.     cout<<"结果：";  
    43.     print(a,10);  
    44.   
    45. }  

    分析：

    快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

      快速排序的改进

    在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序。实践证明，改进后的算法时间复杂度有所降低，且当k取值为 8 左右时,改进算法的性能最佳。算法思想如下：

    [cpp] view plain copy
     
     print?
    1. void print(int a[], int n){  
    2.     for(int j= 0; j<n; j++){  
    3.         cout<<a[j] <<"  ";  
    4.     }  
    5.     cout<<endl;  
    6. }  
    7.   
    8. void swap(int *a, int *b)  
    9. {  
    10.     int tmp = *a;  
    11.     *a = *b;  
    12.     *b = tmp;  
    13. }  
    14.   
    15. int partition(int a[], int low, int high)  
    16. {  
    17.     int privotKey = a[low];                 //基准元素  
    18.     while(low < high){                   //从表的两端交替地向中间扫描  
    19.         while(low < high  && a[high] >= privotKey) --high; //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端  
    20.         swap(&a[low], &a[high]);  
    21.         while(low < high  && a[low] <= privotKey ) ++low;  
    22.         swap(&a[low], &a[high]);  
    23.     }  
    24.     print(a,10);  
    25.     return low;  
    26. }  
    27.   
    28.   
    29. void qsort_improve(int r[ ],int low,int high, int k){  
    30.     if( high -low > k ) { //长度大于k时递归, k为指定的数  
    31.         int pivot = partition(r, low, high); // 调用的Partition算法保持不变  
    32.         qsort_improve(r, low, pivot - 1,k);  
    33.         qsort_improve(r, pivot + 1, high,k);  
    34.     }   
    35. }   
    36. void quickSort(int r[], int n, int k){  
    37.     qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序  
    38.   
    39.     //再用插入排序对基本有序序列排序  
    40.     for(int i=1; i<=n;i ++){  
    41.         int tmp = r[i];   
    42.         int j=i-1;  
    43.         while(tmp < r[j]){  
    44.             r[j+1]=r[j]; j=j-1;   
    45.         }  
    46.         r[j+1] = tmp;  
    47.     }   
    48.   
    49. }   
    50.   
    51.   
    52.   
    53. int main(){  
    54.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
    55.     cout<<"初始值：";  
    56.     print(a,10);  
    57.     quickSort(a,9,4);  
    58.     cout<<"结果：";  
    59.     print(a,10);  
    60.   
    61. }  

    7. 归并排序（Merge Sort）

    基本思想：

    归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

    归并排序示例：

     

    合并方法：

    设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。

    1. j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
    2. 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
    3. //选取r[i]和r[j]较小的存入辅助数组rf 如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵ 否则，rf[k]=r[j]； j++； k++； 转⑵
    4. //将尚未处理完的子表中元素存入rf 如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空 如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
    5. 合并结束。
    [cpp] view plain copy
     
     print?
    1. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
    2. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
    3. {  
    4.     int j,k;  
    5.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
    6.         if(r[j] < r[i]) rf[k] = r[j++];  
    7.         else rf[k] = r[i++];  
    8.     }  
    9.     while(i <= m)  rf[k++] = r[i++];  
    10.     while(j <= n)  rf[k++] = r[j++];  
    11. }  
     

    归并的迭代算法

    1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。

    [cpp] view plain copy
     
     print?
    1. void print(int a[], int n){  
    2.     for(int j= 0; j<n; j++){  
    3.         cout<<a[j] <<"  ";  
    4.     }  
    5.     cout<<endl;  
    6. }  
    7.   
    8. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
    9. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
    10. {  
    11.     int j,k;  
    12.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
    13.         if(r[j] < r[i]) rf[k] = r[j++];  
    14.         else rf[k] = r[i++];  
    15.     }  
    16.     while(i <= m)  rf[k++] = r[i++];  
    17.     while(j <= n)  rf[k++] = r[j++];  
    18.     print(rf,n+1);  
    19. }  
    20.   
    21. void MergeSort(ElemType *r, ElemType *rf, int lenght)  
    22. {   
    23.     int len = 1;  
    24.     ElemType *q = r ;  
    25.     ElemType *tmp ;  
    26.     while(len < lenght) {  
    27.         int s = len;  
    28.         len = 2 * s ;  
    29.         int i = 0;  
    30.         while(i+ len <lenght){  
    31.             Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的两个子表合并  
    32.             i = i+ len;  
    33.         }  
    34.         if(i + s < lenght){  
    35.             Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的两个子表合并  
    36.         }  
    37.         tmp = q; q = rf; rf = tmp; //交换q,rf，以保证下一趟归并时，仍从q 归并到rf  
    38.     }  
    39. }  
    40.   
    41.   
    42. int main(){  
    43.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
    44.     int b[10];  
    45.     MergeSort(a, b, 10);  
    46.     print(b,10);  
    47.     cout<<"结果：";  
    48.     print(a,10);  
    49.   
    50. }  

    两路归并的递归算法

    [cpp] view plain copy
     
     print?
    1. void MSort(ElemType *r, ElemType *rf,int s, int t)  
    2. {   
    3.     ElemType *rf2;  
    4.     if(s==t) r[s] = rf[s];  
    5.     else  
    6.     {   
    7.         int m=(s+t)/2;          /*平分*p 表*/  
    8.         MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的p2[s…m]*/  
    9.         MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/  
    10.         Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/  
    11.     }  
    12. }  
    13. void MergeSort_recursive(ElemType *r, ElemType *rf, int n)  
    14. {   /*对顺序表*p 作归并排序*/  
    15.     MSort(r, rf,0, n-1);  
    16. }  

    8. 桶排序/基数排序(Radix Sort)

    说基数排序之前，我们先说桶排序：

    基本思想：是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。          简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。  

     例如要对大小为[1..1000]范围内的n个整数A[1..n]排序  

     首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储   (10..20]的整数，……集合B[i]存储(   (i-1)*10,   i*10]的整数，i   =   1,2,..100。总共有  100个桶。  

      然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。  再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任  何排序法都可以。

      最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这  样就得到所有数字排好序的一个序列了。  

      假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果  

      对每个桶中的数字采用快速排序，那么整个算法的复杂度是  

      O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)  

      从上式看出，当m接近n的时候，桶排序复杂度接近O(n)  

      当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的  ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。  

            前面说的几大排序算法 ，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

            1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。

            2）其次待排序的元素都要在一定的范围内等等。

           桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较，但前提是要知道待排序列的一些具体情况。

    分配排序的基本思想：说白了就是进行多次的桶式排序。

    基数排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶：O(n)。

    实例:

    扑克牌中52 张牌，可按花色和面值分成两个字段，其大小关系为： 花色： 梅花< 方块< 红心< 黑心   面值： 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

    若对扑克牌按花色、面值进行升序排序，得到如下序列：

    即两张牌，若花色不同，不论面值怎样，花色低的那张牌小于花色高的，只有在同花色情况下，大小关系才由面值的大小确定。这就是多关键码排序。

    为得到排序结果，我们讨论两种排序方法。 方法1：先对花色排序，将其分为4 个组，即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序，最后，将4 个组连接起来即可。 方法2：先按13 个面值给出13 个编号组(2 号，3 号，...，A 号)，将牌按面值依次放入对应的编号组，分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心)，将2号组中牌取出分别放入对应花色组，再将3 号组中牌取出分别放入对应花色组，……，这样，4 个花色组中均按面值有序，然后，将4 个花色组依次连接起来即可。

    设n 个元素的待排序列包含d 个关键码{k1，k2，…，kd}，则称序列对关键码{k1，k2，…，kd}有序是指：对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系：

                                                                   

    其中k1 称为最主位关键码，kd 称为最次位关键码     。

    两种多关键码排序方法：

    多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序，分两种方法：

    最高位优先(Most Significant Digit first)法，简称MSD 法：

    1）先按k1 排序分组，将序列分成若干子序列，同一组序列的记录中，关键码k1 相等。

    2）再对各组按k2 排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd 对各子组排序后。

    3）再将各组连接起来，便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。

    最低位优先(Least Significant Digit first)法，简称LSD 法：

    1) 先从kd 开始排序，再对kd-1进行排序，依次重复，直到按k1排序分组分成最小的子序列后。

    2) 最后将各个子序列连接起来，便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。

    基于LSD方法的链式基数排序的基本思想

    　　“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字，可以看作由多个数位或多个字符构成的多关键字，此时可以采用“分配-收集”的方法进行排序，这一过程称作基数排序法，其中每个数字或字符可能的取值个数称为基数。比如，扑克牌的花色基数为4，面值基数为13。在整理扑克牌时，既可以先按花色整理，也可以先按面值整理。按花色整理时，先按红、黑、方、花的顺序分成4摞（分配），再按此顺序再叠放在一起（收集），然后按面值的顺序分成13摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。   

    基数排序:

    是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

    算法实现：

    [cpp] view plain copy
     
     print?
    1. Void RadixSort(Node L[],length,maxradix)  
    2. {  
    3.    int m,n,k,lsp;  
    4.    k=1;m=1;  
    5.    int temp[10][length-1];  
    6.    Empty(temp); //清空临时空间  
    7.    while(k<maxradix) //遍历所有关键字  
    8.    {  
    9.      for(int i=0;i<length;i++) //分配过程  
    10.     {  
    11.        if(L[i]<m)  
    12.           Temp[0][n]=L[i];  
    13.        else  
    14.           Lsp=(L[i]/m)%10; //确定关键字  
    15.        Temp[lsp][n]=L[i];  
    16.        n++;  
    17.    }  
    18.    CollectElement(L,Temp); //收集  
    19.    n=0;  
    20.    m=m*10;  
    21.   k++;  
    22.  }  
    23. }  

    总结

    各种排序的稳定性，时间复杂度和空间复杂度总结：

     我们比较时间复杂度函数的情况：

                                 时间复杂度函数O(n)的增长情况

    所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。

    时间复杂度来说：

    (1)平方阶(O(n2))排序 　　各类简单排序:直接插入、直接选择和冒泡排序；  (2)线性对数阶(O(nlog2n))排序 　　快速排序、堆排序和归并排序；  (3)O(n1+§))排序,§是介于0和1之间的常数。

           希尔排序 (4)线性阶(O(n))排序 　　基数排序，此外还有桶、箱排序。

    说明：

    当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；

    而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；

    原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

     

    稳定性：

    排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。       稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；

    稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

    不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

    选择排序算法准则：

    每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。

    选择排序算法的依据

    影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：

    1．待排序的记录数目n的大小；

    2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；

    3．关键字的结构及其分布情况；

    4．对排序稳定性的要求。

    设待排序元素的个数为n.

    1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

       快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；        堆排序 ：  如果内存空间允许且要求稳定性的，

           归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

    2）  当n较大，内存空间允许，且要求稳定性 =》归并排序

    3）当n较小，可采用直接插入或直接选择排序。

        直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。

        直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

    5）一般不使用或不直接使用传统的冒泡排序。

    6）基数排序 它是一种稳定的排序算法，但有一定的局限性： 　　1、关键字可分解。 　　2、记录的关键字位数较少，如果密集更好 　　3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。
  • 相关阅读:
    javascript 获取event
    IE与火狐下兼容（阻止冒泡事件）
    IE和FireFox中JS兼容之event
    不同浏览器中childNodes获取子节点个数
    文档结构和遍历
    爬取拉钩Java招聘数据
    爬取糗事百科的图片
    爬虫框架scrapy安装
    会爬电影神器，是一种什么样的体验，你懂得！！！！！！！
    利用Python的unittest单元测试框架的discover方法批量执行脚本用例
  • 原文地址：https://www.cnblogs.com/think90/p/6379732.html
Copyright © 2011-2022 走看看