常见的排序算法

  排序就是将一组对象按照某种逻辑顺序重新排列的过程，在数据处理和科学计算中有着重要的作用，下文将会对一些常见的算法进行分析并给出实现（Java）：

常见排序算法特点

算法	是否稳定	原地排序	时间复杂度	空间复杂度
冒泡排序	稳定	是	N^2	1
插入排序	是	是	介于N和N^2之间	1
选择排序	否	是	N^2	1
希尔排序	否	是	大致NlogN	1
归并排序	是	否	NlogN	N
快速排序	否	是	NlogN	lgN

1·冒泡排序：

---

      冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过 来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢“浮”到数列的顶端。

 public int[] sort(int[] nums){
        int length=nums.length;
        for(int i=0;i<length-1;i++){
            for(int j=0;j<length-1;j++){
                int temp=nums[j+1];
                nums[j+1]=nums[j];
                nums[j]=temp;
            }
        }
        return nums;
    }

2·选择排序：

---

      选择排序的思想：首先找到数组中最小的元素，其次，将它和数组的第一个元素交换位置；再次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置，如此循环往复。

//不断寻找最小的元素，排在数组的前端
    public  void sort(int[] a){
        int n=a.length;
        for(int i=0;i<n;i++){
            int min=i;
            for(int j=i+1;j<n;j++){
                if(a[j]<a[min]){
                    min=j;
                }
            }
            int temp=a[i];
            a[i]=a[min];
            a[min]=temp;
        }
    }

3·插入排序：

---

   插入排序的思想与整理扑克牌类似，将一张张扑克牌查到对应的位置；与选择排序一样，当前索引左边的元素顺序是确定的，但它们的最终位置还没有确定，当索引到达数组右端时，排序完成。

//假定数组前端已排序，将未排序的第一个元素插入到已排序数组的对应位置
    public void sort(int[] a){
        int N=a.length;
        for(int i=1;i<N;i++){
            for(int j=i;j>0&&a[j]<a[j-1];j--){
                int temp=a[j-1];
                a[j-1]=a[j];
                a[j]=temp;
            }
        }
    }

4·希尔排序：

---

   希尔排序是在插入排序之上的改进，希尔排序通过交换不相邻的元素以对数组的局部进行排序，并最终用插入排序将局部有序的数组排序；希尔排序的思想是使数组中任意间隔为h的元素都是有序的。

public void sort(int[] a){
        int N=a.length;
        int h=1;
        while(h<N/3){
            h=3*h+1;
        }
        while(h>=1){
            //将数组变为h有序
            for(int i=h;i<N;i++){
                for(int j=i;j>=h && a[i]<a[j-h];j=j-h){
                    int temp=a[j-h];
                    a[j-h]=a[j];
                    a[j]=temp;
                }
            }
            h=h/3;
        }
    }

5·归并排序：

   归并排序基于递归实现，其思想是将一个数组分成两半分别排序，然后将结果归并起来；它的优点在于能够保证将任意长度为N的数组排序所需时间和NlogN成正比，缺点是学要额外的存储空间。

package Rank;

public class MergeSort {
    private static int[] aux;

    public static void sort(int[] a){
        aux=new int[a.length];
        sort(a,0,a.length-1);
    }
    //基于递归的思想归并数组
    public static void sort(int[] a,int lo,int hi){
        if(hi<=lo){
            return;
        }
        int mid=lo+(hi-lo)/2;
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        merge(a,lo,mid,hi);
    }
    //将子数组a[lo,mid]和a[mid+1,hi]归并成一个有序的数组
    public static void merge(int[] a,int lo,int mid,int hi){
        int i=lo,j=mid+1;
        for(int k=lo;k<=hi;k++){
            aux[k]=a[k];
        }
        //四个条件判断（左半边用尽，右半边用尽，右当前元素小于左当前元素，右当前元素大于左当前元素）
        for(int k=lo;k<=hi;k++){
            if(i>mid){
                a[k]=aux[j++];
            }else if(j>hi){
                a[k]=aux[i++];
            }else if(aux[j]<(aux[i])){
                a[k]=aux[j++];
            }else{
                a[k]=aux[i++];
            }
        }
    }
}

6·快速排序：

   快速排序可能是应用最广的算法，它将一个数组分为两个子数组，将两部分独立地排序；快速排序和归并排序是互补的，它的优点是将长度为N的数组排序所需时间和NlgN成正比，并且它是原地排序(只需一个很小的辅助栈）。快速排序在数组较小时比插入排序慢，因此对于小数组，可优先采用插入排序。

package Rank;

public class QuickSort {
    public static void sort(int[] a){
        sort(a,0,a.length-1);
    }
    //将数组切分为两个子数组，分别排序
    public static void sort(int[] a,int lo,int hi){
        if(hi<=lo){
            return;
        }
        int j=partion(a,lo,hi);
        sort(a,lo,j-1);
        sort(a,j+1,hi);
    }
    /*切分函数，将数组切分为两部分，左端都比选择数小，
     右端都比选择数大，这里以数组的第一个元素作为切分点，将数组分为两个部分*/
    private static int partion(int[] a,int lo,int hi){
        int i=lo,j=hi+1;
        int v=a[lo];
        //从左开始扫描大于切分点元素，从右开始扫描小于切分点元素，将找到的元素交换位置
        while (true){
            while(a[++i]<v){
                if(i==hi){
                    break;
                }
            }
            while(v<=a[--j]){
                if(j==lo){
                    break;
                }
            }
            if(i>=j){
                break;
            }
            int temp=a[j];
            a[j]=a[i];
            a[i]=temp;
        }
        //将切分标准元素放入正确的位置
        int temp=a[j];
        a[j]=a[lo];
        a[lo]=temp;
        return j;
    }
}