数组排序算法

1.冒泡排序法

冒泡排序是一种简单的排序算法。它重复循环要排序的数列，从0索引出开始，一次比较两个相邻的元素，数值大的放前面，数值小的放后面，在进行一轮的比较后，最大值放在最大索引处，以此类推，直到排序完毕。依次经过多次的循环后，使数组成为有序的数组。

例如：

[78, 32，97, 67, 54]             原数组数据

[32, 78, 67, 54, 97]
[32, 67, 54, 78, 97]
[32, 54, 67, 78, 97]
[32, 54, 67, 78, 97]

排序图示：

代码如下： 

public class Bubblesorting {
    public static void main(String[] args) {
        int[] arr = new int[]{78,32,97,67,54};
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    method(arr,j);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    private static void method(int[] arr,  int j) {
        int t=arr[j];
        arr[j]=arr[j+1];
        arr[j+1]=t;
    }
}


[32, 54, 67, 78, 97] 

 

2.选择排序

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法。

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：从0索引出开始，第一个元素依次和后面的元素进行比较，数值大的放前面，数值小的放后面，经过一轮的循环后，最小值出现在最小索引处。以此类推，直到所有元素均排序完毕。 

例如：

[78, 32，97, 67, 54]             原数组数据

[32, 78, 97, 67, 54]
[32, 54, 97, 78, 67]
[32, 54, 67, 97, 78]
[32, 54, 67, 78, 97]
[32, 54, 67, 78, 97]

图示如下：

代码如下：

public class Selectsorting {
    public static void main(String[] args) {
        int[] arr = new int[]{78,32,97,67,54};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 1+i; j < arr.length; j++) {
                if (arr[i]>arr[j]){
                    method(arr,  i,  j);
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    private static void method(int[] arr, int i, int j) {
        int t=arr[j];
        arr[j]=arr[i];
        arr[i]=t;
    }
}


[32, 54, 67, 78, 97]

3.直接插入排序

算法思路:直接插入排序,是一种最简单的排序方法.他的基本操作是将一个记录插入到一个长度为m 的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表.假设有一组元素{k1,k2...,kn},排序开始就认为k1是一个有序序列,让k2插入上述表长为1的有序序列,使之成为一个表长为2的有序序列,然后让k3插入上述表长为2的有序序列,使之成为一个表长为3的有序序列,以此类推,最后让kn插入表长为n-1的有序序列,得到一个表长为n的有序序列.

例如：

[78, 32，97, 67, 54]             原数组数据

[32, 78] 97, 67, 54]
[32, 78, 97] 67, 54]
[32, 67, 78, 97] 54]
[32, 54, 67, 78, 97]

public class Insertsorting {
        public static void main (String[]arges){
            int[] arr = new int[]{78,32,97,67,54};
            //外层循环定义比较的轮次,也就是得几轮才能排序完
            for (int i=0;i<arr.length-1;i++){
                for(int index = i; index >= 0 && arr[index] > arr[index + 1]; --index) {
                    method(arr, index);
                }
//                    while (index>=0&&arr[index]>arr[index+1]){
//                        method(arr, index);
//                        index --;
//                }


                System.out.println(Arrays.toString(arr));
            }
            System.out.println(Arrays.toString(arr));
        }

    private static void method(int[] arr, int index) {
        int t=arr[index];
        arr[index]=arr[index+1];
        arr[index+1]=t;
    }}

[32, 54, 67, 78, 97]

4.希尔排序 

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

4.1 算法描述

我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

图示如下：

 

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

package com.zhang.demo.sorting;

import java.util.Arrays;

public class Shellsorting {
    public static void main(String[] args) {
        int[] arr = new int[]{78,32,97,67,54};
        shellsorting(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void shellsorting(int[] arr) {
        int jianGe = 1;
        while (jianGe <= arr.length / 3) {
            jianGe = 3 * jianGe + 1;
        }
        for (int h = jianGe; h > 0; h = (h - 1) / 3) {
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h - 1; j -= h) {
                    if (arr[j] < arr[j - h]) {

                        method(arr, j, j - h);
                    }
                }
//                System.out.println(Arrays.toString(arr));
            }
            

        }
    }


    private static void method(int[] arr, int j, int i ) {
        int t=arr[i];
        arr[i]=arr[j ];
        arr[j  ]=t;
    }

}


//[32, 54, 67, 78, 97]

5.快速排序法

快速排序是对冒泡排序的一种改进。基本思想是：首先定义一个基数，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此实现整个数据变成有序序列。

package com.zhang.demo.sorting;

import java.util.Arrays;

public class Quicksorting {
    public static void main(String[] arges) {
        //定义基数
        //判断左边比基数小放在基数左边，比基数大的放在基数的右边
        //当左边和右边相等时，把基数放进去
        int[] arr = new int[]{78,32,97,67,54,99,23};
//        method(arr);

        Quicksorting(arr,0,arr.length-1);
        for (int i = 0; i < arr.length; i++) {
        }
        System.out.println(Arrays.toString(arr));
    }

    private static void Quicksorting(int[] arr,int left,int right) {
        //左右索引进行判断
        if(left>right){
            return;
        }
        //定义基数
        int base=arr[left];
        //定义变量i；指向左边的索引
        int i=left;
        //定义变量j；指向右边的索引
        int j=right;
        //左边的检索与基数大小判断
        while (i!=j){
        while (arr[j]>=base&&i<j){
            j--;
        }
            while  (arr[i]<=base&&i<j){
                i++;
            }
            int t=arr[i];
        arr[i]=arr[j];
        arr[j]=t;
    }
    arr[left]=arr[j];
        arr[i]=base;

        Quicksorting( arr, left,i-1);
        Quicksorting( arr,j+1,right);
    }
}
//    private static void method(int[] arr) {
//        int t=arr[index];
//        arr[index]=arr[index+1];
//        arr[index]=t;
//    }


//[23, 32, 54, 67, 78, 97, 99]

6.归并排序

归并排序是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 
归并过程为： 
  比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。 
归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。 
归并操作的工作原理如下： 
  S1: 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 
  S2: 设定两个指针，最初位置分别为两个已经排序序列的起始位置 
  S3: 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 
  S4: 重复S3，直到某一指针超出序列尾 
  S5: 将另一序列剩下的所有元素直接复制到合并序列尾
 

import java.util.Arrays;

public class ArrayDemo3 {
    public static void main(String[] args) {

        int[] arr = {2, 10, 1, 0, 100, 3, 5, -1, 200, 109, 30, 1009, 109, 109, -100};

        //分
        chaiFen(arr, 0, arr.length - 1);

        //归
        // mergerSort(arr,0,(arr.length/2)-1,arr.length-1);

        System.out.println(Arrays.toString(arr));

    }

    private static void chaiFen(int[] arr, int startIndex, int endIndex) {
        //计算中间索引
        int centerIndex = (startIndex + endIndex) / 2;
        //递归来拆
        if (startIndex < endIndex) {
            //拆分左边
            chaiFen(arr, startIndex, centerIndex);
            //拆分右边
            chaiFen(arr, centerIndex + 1, endIndex);
            //归并
            mergerSort(arr, startIndex, centerIndex, endIndex);
        }
    }


    /**
     * @param arr         要归并的数组
     * @param startIndex  起始索引
     * @param centerIndex 中间索引
     * @param endIndex    结束索引
     */
    private static void mergerSort(int[] arr, int startIndex, int centerIndex, int endIndex) {
        //定义一个临时数组
        int[] tempArray = new int[endIndex - startIndex + 1];
        //定义临时数组的起始索引
        int index = 0;
        //定义左边数组的起始索引
        int i = startIndex;
        //定义右边数组的起始索引
        int j = centerIndex + 1;
        //循环比较左右两边数组的元素，往临时数组里面方法
        while (i <= centerIndex && j <= endIndex) {
            //进来比较
            if (arr[i] <= arr[j]) {
                tempArray[index] = arr[i];
                i++; //记得递增索引
            } else {
                tempArray[index] = arr[j];
                j++;//记得递增索引
            }

            index++; //临时数组的索引

        }

        //处理左边剩余元素

        while (i <= centerIndex) {
            tempArray[index] = arr[i];
            i++; //记得递增索引
            index++;
        }

        //处理右边剩余元素


        while (j <= endIndex) {
            tempArray[index] = arr[j];
            j++; //记得递增索引
            index++;
        }

        //这个时候我们的临时数组里面的元素已经排序好了

        //  System.out.println(Arrays.toString(tempArray));
        //遍历临时数组，将临时数组中的元素，放到原数组里面去
        for (int k = 0; k < tempArray.length; k++) {
            arr[k + startIndex] = tempArray[k];
        }


    }
}

//[-1, 0, 1, 2, 3, 5, 10, 100]

7.基数排序

基本思想：通过序列中各个元素的值，对排序的N个元素进行若干趟的“分配”与“收集”来实现排序。 
分配：我们将L[i]中的元素取出，首先确定其个位上的数字，根据该数字分配到与之序号相同的桶中 
收集：当序列中所有的元素都分配到对应的桶中，再按照顺序依次将桶中的元素收集形成新的一个待排序列L[ ] 
对新形成的序列L[]重复执行分配和收集元素中的十位、百位…直到分配完该序列中的最高位，则排序结束。

package com.zhang.demo.sorting;

import java.util.Arrays;

public class jishusorting {
        public static void main(String[] args) {
            //基数排序：通过分配再收集这种方式
            //基数排序，如果数组中有负数，排不了
            int[] arr = {1, 2, 45, 90, 43, 65, 87, 99};
            //进行基数排序
            sortArray(arr);
            System.out.println(Arrays.toString(arr));
        }

        private static void sortArray(int[] arr) {
            //定义一个二维数组，里面放十个桶
            int[][] tempArr = new int[10][arr.length];
            //定义一个统计数组，
            int[] counts = new int[10];
            //获取数组中的最大值
            int max = getMax(arr);
            //获取最大数的位数，确定我们要分配收集的轮次
            int len = String.valueOf(max).length();
            //len = 1;
            for (int i = 0, n = 1; i < len; i++, n *= 10) {
                //获取每个位上的数字
                for (int j = 0; j < arr.length; j++) {
                    int ys = arr[j] / n % 10;
                    //根据每个位上的数字得放入对应的桶中
                    tempArr[ys][counts[ys]++] = arr[j];
                }
                //取出桶中的数据
                遍历统计数组
                int index = 0;
                for (int k = 0; k < counts.length; k++) {
                    if (counts[k] != 0) {
                        for (int h = 0; h < counts[k]; h++) {
                            //取出桶中的数据，放回原数组
                            arr[index] = tempArr[k][h];
                            index++;
                        }
                        //取完之后，清除上次统计的个数
                        counts[k]=0;
                    }
                }
            }

            //for (int i = 0; i < tempArr.length; i++) {
            //    System.out.println(Arrays.toString(tempArr[i]));
            //}
            //System.out.println("------------------------------------");
            //System.out.println(Arrays.toString(counts));
        }

        private static int getMax(int[] arr) {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        }
    }


/**
[1, 2, 43, 45, 65, 87, 90, 99]*/