常用排序总结

交换排序

冒泡排序

算法原理：
冒泡排序要对一个列表多次重复遍历。它要比较相邻的两项，并且交换顺序排错的项。每对 列表实行一次遍历，就有一个最大项排在了正确的位置。大体上讲，列表的每一个数据项都会在 其相应的位置 “冒泡”。如果列表有 n 项，第一次遍历就要比较 n-1 对数据。一旦列表中最大(按照规定的原则定义大小)的数据是所比较的数据对中的一个，它就会沿着列表一直后移，直到这次遍历结束。时间复杂度为O(n²)，空间复杂度为O(n)

java实现
public void bubbleSort(int[] a){
        int temp;
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a.length-i-1;j++){
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }

快速排序

算法原理
快速排序由 C. A. R. Hoare 在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

java实现
    public void quickSort(int[] number){
        number = quickSort(number,0,number.length-1);
        System.out.println(Arrays.toString(number));
    }
    public int[] quickSort(int[] numbers, int start, int end) {
        if (start < end) {
            int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）
            int temp; // 记录临时中间值
            int i = start, j = end;
            while (i < j) {
                while ((numbers[i] < base) && (i < end))
                    i++;
                while ((numbers[j] > base) && (j > start))
                    j--;
                if (i <= j) {
                    temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                    if (numbers[i] == base) {
                        j--;
                    }else if(numbers[j] == base){
                        i++;
                    }
                }
            }
            if (start < j)
                quickSort(numbers, start, j-1);
            if (end > i)
                quickSort(numbers, i+1, end);
        }
        return numbers;
    }

插入排序

直接插入排序

算法原理
插入排序 总是保持一个位置靠前的已排好的子表，然后每一个新的数据项被 “插入” 到前边的子表里，排好的子表增加一项。我们认为只含有一个数据项的列表是已经排好的。每排后面一个数据（从 1 开始到 n-1），这 个的数据会和已排好子表中的数据比较。比较时，我们把之前已经排好的列表中比这个数据大的移到它的右边。当子表数据小于当前数据，或者当前数据已经和子表的所有数据比较了时，就可以在此处插入当前数据项。

java实现
	public void insertSort(int[] a){
        int length=a.length;//数组长度，将这个提取出来是为了提高速度。
        int insertNum;//要插入的数
        for(int i=1;i<length;i++){//插入的次数
            insertNum=a[i];//要插入的数
            int j=i-1;//已经排序好的序列元素个数
            while(j>=0 && a[j]>insertNum){//序列从后到前循环，将大于insertNum的数向后移动一格
                a[j+1]=a[j];//元素移动一格
                j--;
            }
            a[j+1]=insertNum;//将需要插入的数放在要插入的位置。
        }

        for (int i=0; i<length; i++){
            System.out.println(a[i]);
        }
    }

希尔排序

算法原理
希尔排序有时又叫做 “缩小间隔排序”，它以插入排序为基础，将原来要排序的列表划分为一些子列表，再对每一个子列表执行插入排序，从而实现对插入排序性能的改进。划分子列的特定方法是希尔排序的关键。我们并不是将原始列表分成含有连续元素的子列，而是确定一个划分列表的增量 “i”，这个i更准确地说，是划分的间隔。然后把每间隔为i的所有元素选出来组成子列表，然后对每个子序列进行插入排序，最后当 i=1 时，对整体进行一次直接插入排序。

java实现
	public void sheelSort(int[] a){
        int d  = a.length;
        while (d!=0) {
            d=d/2; //3
            for (int x = 0; x < d; x++) {//分的组数
                for (int i = x + d; i < a.length; i += d) {//组中的元素，从第二个数开始
                    int j = i - d;//j为有序序列最后一位的位数    1
                    int temp = a[i];//要插入的元素      4
                    for (; j >= 0 && temp < a[j]; j -= d) {//从后往前遍历。
                        a[j + d] = a[j];//向后移动d位
                    }
                    a[j + d] = temp;
                }
            }
        }
        for (int i=0; i<a.length; i++){
            System.out.println(a[i]);
        }
    }

选择排序

简单选择排序

算法原理：
选择排序提高了冒泡排序的性能，它每遍历一次列表只交换一次数据，即进行一次遍历时找到最大的项，完成遍历后，再把它换到正确的位置。和冒泡排序一样，第一次遍历后，最小的数据项就已归位，第二次遍历使次小项归位。这个过程持续进行，一共需要 n-1 次遍历来排好 n 个数据，因为最后一个数据必须在第 n-1 次遍历之后才能归位。

Java实现
	public void selectSort(int[] a) {
        int length = a.length;
        for (int i = 0; i < length; i++) {//循环次数
            int key = a[i];
            int position=i;
            for (int j = i + 1; j < length; j++) {//选出最小的值和位置
                if (a[j] < key) {
                    key = a[j];
                    position = j;
                }
            }
            a[position]=a[i];//交换位置
            a[i]=key;
        }
    }

堆排序

算法原理
堆排序是一种树形选择排序，是对直接选择排序的有效改进。　　
堆的定义如下：具有n个元素的序列 （h1,h2,…,hn),当且仅当满足（hi>=h2i,hi>=2i+1）（hi<=h2i,hi<=2i+1） (i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。　　
思想：初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

java实现
	public  void heapSort(int[] a){
        int arrayLength=a.length;
        //循环建堆
        for(int i=0;i<arrayLength-1;i++){
            //建堆
            buildMaxHeap(a,arrayLength-1-i);
            //交换堆顶和最后一个元素
            swap(a,0,arrayLength-1-i);
            System.out.println(Arrays.toString(a));
        }
    }
    private  void swap(int[] data, int i, int j) {
        // TODO Auto-generated method stub
        int tmp=data[i];
        data[i]=data[j];
        data[j]=tmp;
    }
    //对data数组从0到lastIndex建大顶堆
    private void buildMaxHeap(int[] data, int lastIndex) {
        //从lastIndex处节点（最后一个节点）的父节点开始
        for(int i=(lastIndex-1)/2;i>=0;i--){
            //k保存正在判断的节点
            int k=i;
            //如果当前k节点的子节点存在
            while(k*2+1<=lastIndex){
                //k节点的左子节点的索引
                int biggerIndex=2*k+1;
                //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
                if(biggerIndex<lastIndex){
                    //若果右子节点的值较大
                    if(data[biggerIndex]<data[biggerIndex+1]){
                        //biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                //如果k节点的值小于其较大的子节点的值
                if(data[k]<data[biggerIndex]){
                    //交换他们
                    swap(data,k,biggerIndex);
                    //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
                    k=biggerIndex;
                }else{
                    break;
                }
            }
        }
    }

归并排序

速度仅次于快排，内存少的时候使用，可以进行并行计算的时候使用。

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

java实现
	public void mergeSort(int[] nums){
        nums = sort(nums, 0, nums.length - 1);
        System.out.println(Arrays.toString(nums));
    }
    public int[] sort(int[] nums, int low, int high){
        int mid = (low+high)/2;
        if (low<high){
            sort(nums, low, mid);
            sort(nums, mid+1, high);
            merge(nums, low, mid, high);
        }
        return nums;
    }
    public void merge(int[] nums, int low, int mid, int high){
        int[] temp = new int[high-low+1];
        int i = low;
        int j = mid+1;
        int k = 0;

        //先将较小的数放入temp
        while (i<=mid && j<=high){
            if (nums[i] < nums[j]) {
                temp[k++] = nums[i++];
            }else {
                temp[k++] = nums[j++];
            }
        }

        //放入左边剩余的数
        while (i <= mid){
            temp[k++] = nums[i++];
        }

        //放入右边剩余的数
        while (j <= high){
            temp[k++] = nums[j++];
        }

        //将排序好的序列覆盖原数列中对应位置的值
        for (int m = 0; m<temp.length; m++){
            nums[m + low] = temp[m];
        }
    }

基数排序

用于大量数，很长的数进行排序时。

算法原理
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

java实现
	public void baseSort(int[] arrays){
		//找到最大值，确定要排序几趟
        int max = 0;
        for (int i = 0; i<arrays.length; i++){
            if (arrays[i]>max)
                max = arrays[i];
        }
        //判断最大值有多少位
        int times = 0;
        while (max>0){
            max = max/10;
            times++;
        }
		//建立十个队列
        List<ArrayList> queue1 = new ArrayList<>();
        for (int j=0; j<10; j++){
            ArrayList<Integer> queue2 = new ArrayList<>();
            queue1.add(queue2);
        }
		//进行times次排序
        for (int m=0; m<times; m++){
            //分配
            for (int n=0; n<arrays.length; n++){
                //取相应位数（个、十、百位）的值，pow(a,b) return a的b次幂；
                int x = arrays[n] % (int) Math.pow(10,m+1) / (int) Math.pow(10,m);
                ArrayList queue = queue1.get(x);
                queue.add(arrays[n]);
                queue1.set(x, queue);
            }
            //收集
            int count = 0;
            for (int i = 0; i<queue1.size(); i++){
                while(queue1.get(i).size() > 0){
                    ArrayList<Integer> queue3 = queue1.get(i);
                    arrays[count] = queue3.get(0);
                    queue3.remove(0);
                    count++;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));
    }

各种排序复杂度