经典排序算法的总结（Java实现）

冒泡排序

算法思想

1. 比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换

2. 这样对数组的第0个数据到N-1个数据进行一次遍历后，大的一个数据就“沉”到数组第 N-1个位置

3. N=N-1，如果N不为 0就重复前面二步，否则排序完成

演示

代码

    //冒泡排序
    public static void bubbleSort(int [] arr,int n){
        int i,j;
        for(i=0;i<n;i++){
            for(j=1;j<n-i;j++){
                if(arr[j-1]>arr[j]){
                    int temp;
                    temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

选择排序

算法思想

1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
3. 重复第二步，直到所有元素均排序完毕

演示

代码

	//选择排序
    public static void select_sort(int [] arr){
        // 总共要经过 N-1 轮比较
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
    }

插入排序

算法思想

1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面）

演示

代码

	//插入排序
    public static void insert_sort(int [] arr){
        for(int i = 1;i < arr.length;i++){
            //插入的数
            int insertVal = arr[i];
            //插入的位置
            int index = i - 1;
            while(index > 0 && insertVal < arr[index]){
                //arr[index]向后移
                arr[index + 1] = arr[index];
                //index向前移
                index --;
            }
            //把插入数放到合适的位置
            arr[index + 1] = insertVal;
        }
    }

快速排序

算法思想

1. 选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的）， 比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。
2. 一次循环：从后往前比较，用基准值和后一个值比较，如果比基准值小的交换位置，如果没有 继续比较下一个，直到找到第一个比基准值小的值才交换。
3. 找到这个值之后，又从前往后开始比 较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的 值才交换。
4. 直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值 来说，左右两边就是有序的了。

演示

代码

 	//快速排序
    public static void fast_sort(int [] arr,int low,int high){
        int start = low;
        int end = high;
        int key = arr[low];

        while(start < end){
            //从后向前
            while(start < end && arr[end] >= key){
                end --;
            }
            if(arr[end]<=key){
                int temp = arr[end];
                arr[end] = arr[start];
                arr[start] = temp;
            }
            //从前向后
            while(start < end && arr[start] <= key){
                start ++;
            }
            if(arr[start]>=key){
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
        }
        //递归
        if(start>low) fast_sort(arr,low,start-1);
        //左边序列。第一个索引位置到关键值索引-1
        if(end<high) fast_sort(arr,end+1,high);
        //右边序列。从关键值索引+1到后一个
    }

希尔排序

算法思想

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

演示

代码

	//希尔排序
    public static void shell_sort(int [] arr){
        int dk = arr.length/2;
        while( dk >= 1  ){
            Shell_Insert_Sort(arr, dk);
            dk = dk/2;
        }

    }

    private static void Shell_Insert_Sort(int[] a, int dk) {
        //类似插入排序，只是插入排序增量是1，这里增量是dk,把1换成dk就可以了
        for(int i=dk;i<a.length;i++){
            if(a[i]<a[i-dk]){
                int j;
                int x=a[i];//x为待插入元素
                a[i]=a[i-dk];
                for(j=i-dk;  j>=0 && x<a[j];j=j-dk){
                    //通过循环，逐个后移一位找到要插入的位置。
                    a[j+dk]=a[j];
                }
                a[j+dk]=x;//插入
            }
        }
    }

归并排序

算法思想

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

演示

代码

 	//归并排序
    public static void merge_sort(int [] arr){
        sort(arr,0,arr.length-1);
    }

    private static  void sort(int [] arr,int left,int right){
        if(left >= right){
            return;
        }
        // 找出中间索引
        int center = (left + right) / 2;
        // 对左边数组进行递归
        sort(arr, left, center);
        // 对右边数组进行递归
        sort(arr, center + 1, right);
        // 合并
        merge(arr, left, center, right);
    }

    private static void merge(int [] arr,int left,int center,int right){
        // 临时数组
        int[] tmpArr = new int[arr.length];
        // 右数组第一个元素索引
        int mid = center + 1;
        // third 记录临时数组的索引
        int third = left;
        // 缓存左数组第一个元素的索引
        int tmp = left;
        while (left <= center && mid <= right) {
            // 从两个数组中取出小的放入临时数组
            if (arr[left] <= arr[mid]) {
                tmpArr[third++] = arr[left++];
            } else {
                tmpArr[third++] = arr[mid++];
            }
        }
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
        while (mid <= right) {
            tmpArr[third++] = arr[mid++];
        }

        while (left <= center) {
            tmpArr[third++] = arr[left++];
        }
        // 将临时数组中的内容拷贝回原数组中
        // （原left-right范围的内容被复制回原数组）
        while (tmp <= right) {
            arr[tmp] = tmpArr[tmp++];
        }
    }

桶排序

算法思想

基本思想： 把数组 arr 划分为 n 个大小相同子区间（桶），每个子区间各自排序， 后合并 。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

1. 找出待排序数组中的大值max、小值min
2. 我们使用 动态数组 ArrayList 作为桶，桶里放的元素也用 ArrayList存储。桶的数量为(maxmin)/arr.length+1
3. 遍历数组 arr，计算每个元素 arr[i] 放的桶
4. 每个桶各自排序

演示

代码

 	//桶排序算法
    public static void bucket_sort(int [] arr){

        // 计算最大值与最小值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < arr.length; i++){
            max = Math.max(max, arr[i]);
            min = Math.min(min, arr[i]);
        }

        //创建桶
        int bucketNum = (max - min) / arr.length + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
        for(int i = 0; i < bucketNum; i++){
            bucketArr.add(new ArrayList<Integer>());
        }

        //将每个元素放入桶
         for(int i = 0; i < arr.length; i++){
            int num = (arr[i] - min) / (arr.length);
            bucketArr.get(num).add(arr[i]);
         }

        //对每个桶进行排序
        for(int i = 0; i < bucketArr.size(); i++){
            Collections.sort(bucketArr.get(i));
        }

        // 将桶中的元素赋值到原序列
        int index = 0;
        for(int i = 0; i < bucketArr.size(); i++){
            for(int j = 0; j < bucketArr.get(i).size(); j++){
                arr[index++] = bucketArr.get(i).get(j);
            }
        }

    }

基数排序

算法思想

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

演示

代码

 	//基数排序
    public static void radix_sort(int [] arr){
        //首先确定排序的趟数;
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        int time = 0;
        //判断位数
        while(max > 0){
            max/= 10;
            time++;
        }

        //建立10个队列
        List<ArrayList> queue=new ArrayList<ArrayList>();
        for(int i=0;i<10;i++){
            ArrayList<Integer> que = new ArrayList<Integer>();
            queue.add(que);
        }

        //进行time次分配和收集
        for (int i=0;i<time;i++){
            //分配数组元素
            for(int j=0;j<arr.length;j++){
                //得到数字的第time+1位数;
                int x=arr[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
                ArrayList<Integer>queue2=queue.get(x);
                queue2.add(arr[j]);
                queue.set(x, queue2);
            }
            int count=0;//元素计数器;
            // 收集队列元素;
            for(int k=0;k<10;k++){
                while(queue.get(k).size()>0){
                    ArrayList<Integer> queue3=queue.get(k);
                    arr[count]=queue3.get(0);
                    queue3.remove(0);
                    count++;
                }
            }
        }
    }

本文章的演示图片引用菜鸟教程图片