简单算法之9种排序

Posted 2021-01-21

甭管什么，笔者就喜欢凑个9。这次，关于排序的算法还是9种，小结一下。排序的算法，尽管有很多的方法例子，但这次是自己总结的，挺有意思算法希望大家喜欢。直接上代码楼，以下算法，都经过笔者亲测，并修改使之有效（粘贴可用）。

package com.css.java.learning.massbag;
import java.util.Arrays;
/**算法：
 * 排序相关小结
 * @author Red_ant
 * 20181119
 */
public class OrderMethod {
    /*1、冒泡排序
     * 通过相邻两个元素比较的方式，依次选出合适的元素放到
     * 数组的第i位。
     */
    public static int[] bubbleSort(int[] nums){
        int num = 0;
        for (int i = 0; i < nums.length -1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {//两两比较，符合条件的元素居于前面
                if(nums[j] > nums[j + 1]){
                    num = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = num;
                }
            }
        }
        return nums;
    }
    /*2、选择排序
     * 每一趟从待排序列，选择最小的元素放到已排序好的序列末尾，剩下的为待排序序列，
     * 重复上述步骤，直至完成。
     */
    public static int[] selectSort(int[] nums){
        int num = 0;
        for (int i = 0; i < nums.length -1; i++) {
            int index = i;
            for (int j = i + 1; j < nums.length; j++) {//选择合适的元素，直接放到数组的第i位
                if(nums[index] > nums[j]){
                    index = j;
                }
                if(index != i){
                    num = nums[i];
                    nums[i] = nums[index];
                    nums[index] = num;
                }
            }
        }
        return nums;
    }
    /*3、选择排序：堆排序
     * 堆排序是一种树形结构选择排序
     * 堆排序需要两个过程，建立堆，堆顶与堆最后一个元素交换位置。所以堆排序有两个函数组成：
     * 建堆的***函数，反复调用***函数实现排序的函数
     * 基本思路：
     * 将序列建成一个堆，根据升序降序选择大顶堆或小顶堆
     * 将堆顶元素与末尾元素交换，将最大元素沉到数组末端
     * 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
     */
    public static int[] HeapSorts(int[] nums){
        //建立大顶
        for (int i = nums.length/2 - 1; i >= 0; i--) {
            //从第一个非叶子节点从下至上，从右至左调整结构
            suitHeap(nums, i, nums.length);
        }
        //调整堆结构，交换堆顶元素与 末尾元素
        for (int j = nums.length - 1; j > 0; j--) {
            exchangeNum(nums, 0, j);//交换堆顶元素与末尾元素
            suitHeap(nums, 0, j);
        }
        return nums;
    }

    private static void exchangeNum(int[] nums, int i, int i2) {
        int index = nums[i];
        nums[i] = nums[i2];
        nums[i2] = index;
    }
    private static void suitHeap(int[] nums, int i, int length) {
        int index = nums[i];//取出当前元素
        for (int j = i*2 + 1; j < length; j = j*2+1) {
            //从i节点的左节点开始，即2i+1处
            if(j+1 < length && nums[j] < nums[j+1]){
                //如果，左子节点小于右子节点，j指向右子节点
                j++;
            }
            if(nums[j] > index){
                //如果子节点大于父节点，将子节点赋值给父节点
                nums[i] = nums[j];
                i = j;
            }else{
                break;
            }
        }
        nums[i] = index;//将index值放到最终位置
    }

    /*4、java Arrays排序
     * 该方法是Arrays类的静态方法，在需要对数组进行排序时，非常好用
     */
    public static int[] ArraySort(int[] nums){
        Arrays.sort(nums);
        return nums;
    }
    /*5、插入排序：直接插入排序
     * 将数组分为两部分，将后部分元素逐一与前部分元素比较
     * 然后依据比较结果进行移动元素
     */
    public static int[] insertSort(int[] nums){
        //从头部第一个当做已经排序好的，把后面的一个一个的插入到已经排序好的列表中
        for (int i = 1; i < nums.length; i++) {
            int j;
            int index = nums[i];//index为待插入的元素
            for (j = i; j > 0 && index < nums[j - 1]; j--) {
                nums[j] = nums[j -1];
            }
            nums[j] = index;
        }
        return nums;
    }

    /*6、插入排序：希尔排序
     * 建堆，对顶与堆的最后一个元素进行排序
     * 希尔排序是插入排序的一种，先取一个小于n的整数作为第一个增量，把文件的全部记录分组。
     * 所有距离为d1的倍数的记录放在同一个组中，先在各组内进行直接插入排序。实际上是一种分组插入排序的方法。
     */
    public static int[] shellSrot(int[] nums){
        int index = nums.length/2;
        while (index >= 1) {
            for (int i = index; i < nums.length; i++) {
                if(nums[i] < nums[i - index]){
                    int j;
                    int x = nums[i];//当前待插入的元素
                    nums[i] = nums[i - index];
                    for (j = i - index; j >= 0 && x < nums[j]; j = j-index) {
                        nums[j + index] = nums[j];
                    }
                    nums[j + index] = x;//插入元素
                }
            }
            index = index/2;
        }
        return nums;
    }
    /*7、交换排序：快速排序
     * 基本思想：
     * A选择一个基准元素，通常选择第一个元素或最后一个元素
     * B通过一趟排序将待排序的记录分割成独立的两部分：记录均值比基准元素值小，元素值比基准元素值大
     * C此时基准元素在排序好的正确位置
     * D分别对这两部分记录，用同样的方法继续进行排序，直到整个序列有序。
     */
    public static int[] quickSort(int[] nums, int...is){
        int low,hight;
        if(is.length == 0){
            low = 0;
            hight = nums.length - 1;
        }else{
            low = is[0];
            hight = is[1];
        }
        if(low < hight){//判断，让递归函数退出，否则无限循环
            int middle = getMiddle(nums, low, hight);
            quickSort(nums, 0, middle - 1);//基准元素小
            quickSort(nums, middle + 1, hight);//比基准元素大
        }
        return nums;
    }
    //获取，均值
    private static int getMiddle(int[] nums, int low, int hight) {
        int index = nums[low];//选择基准元素
        while (low < hight) {
            //从hight开始，找出比基准小的，与low换位置
            while (low < hight && nums[hight] >= index) {
                hight--;
            }
            nums[low] = nums[hight];
            //从low开始找比基准大，放到之前hight空出来的位置上
            while (low < hight && nums[low] <= index) {
                low++;
            }
            nums[hight] = nums[low];
        }
        //此时low = hight是基准元素的位置，也是空缺的位置
        nums[low] = index;
        return low;
    }
    /*
     * 8、归并排序
     * 基本思想：
     * 归并排序是，将两个或两个以上有序表合并成一个新的有序表。
     * 即把待排序的序列分为若干个子序列，每个子序列是有序的，然后再把有序序列合并成整体有序序列
     */
    public static int[] mergeSort(int[] nums){
        sortmerge(nums, 0, nums.length - 1);
        return nums;
    }
    private static void sortmerge(int[] nums, int i, int j) {
        if(i >= j){
            return;
        }
        //找出中间索引
        int middle = (i + j)/2;
        //对左边数组进行递归
        sortmerge(nums, i, middle);
        //对右边数组进行递归
        sortmerge(nums, middle + 1, j);
        //合并数组
        merge(nums, i, middle, j);
    }
    private static void merge(int[] nums, int i, int middle, int j) {
        //创建临时中间量数组
        int[] tmpArr = new int[nums.length];
        //右数组第一个元素索引
        int mid = middle + 1;
        //记录临时数组索引
        int second = i;
        //缓存左侧数组第一个元素的索引
        int tmp = i;
        while (i <= middle && mid <= j) {
            //从两个数组中取出最小的放到临时数组中
            if(nums[i] <= nums[mid]){
                tmpArr[second++] = nums[i++];
            }else{
                tmpArr[second++] = nums[mid++];
            }
        }
        //剩余部分依次放入临时数组
        while (mid <= j) {
            tmpArr[second++] = nums[mid++];
        }
        while (i <= middle) {
            tmpArr[second++] = nums[i++];
        }
        //将临时数组中内容，拷贝到原数组中
        while (tmp <= j) {
            nums[tmp] = tmpArr[tmp++];
        }
    }
    /*9、基数排序（桶）
     * 将数组中的所有元素按照元素中最长的位数进行统一格式，不足位数的前面补充0
     * 然后，一次比较每一位的数字，得到最终的比较结果
     * 基本思想：
     * A遍历找出最大的数（确定最大的数是几）
     * B开辟临时数组，用于中间过程的计算
     * C用一个count数组统计原数组中某一位(从低位向高位统计)相同的数据出现的次数；
     * D用一个start数组计算原数组中某一位(从最低位向最高位计算)相同数据出现的位置；
     * E将桶中数据从小到大用临时数组收集起来；
     * F重复(3)(4)(5)直到所有位都被统计并计算过，用临时数组收集起来；
     * G将临时数组拷回到原数组中；
     */
    public static int[] radixSort(int[] nums) {
                int exp;    // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
                int max = getMax(nums);    // 数组a中的最大值
                // 从个位开始，对数组a按"指数"进行排序
                for (exp = 1; max/exp > 0; exp *= 10) {
                    countSort(nums, exp);
                }
                return nums;
        }
    //获取数组中最大的元素
    private static int getMax(int[] nums) {
        int i, max;
            max = nums[0];
            for (i = 1; i < nums.length; i++)
                    if (nums[i] > max)
                            max = nums[i];
            return max;
    }
    /*
     * 对数组按照"某个位数"进行排序(桶排序)
     * 参数说明：
     * exp -- 指数。对数组a按照该指数进行排序。
     * (01) 当exp=1表示按照"个位"对数组a进行排序
     * (02) 当exp=10表示按照"十位"对数组a进行排序
     * (03) 当exp=100表示按照"百位"对数组a进行排序
     */
    private static void countSort(int[] a, int exp) {
        int[] output = new int[a.length]; // 存储"被排序数据"的临时数组
        int[] buckets = new int[10];
        // 将数据出现的次数存储在buckets[]中
        for (int i = 0; i < a.length; i++)
            buckets[(a[i] / exp) % 10]++;
        // 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
        for (int i = 1; i < 10; i++)
            buckets[i] += buckets[i - 1];
        // 将数据存储到临时数组output[]中
        for (int i = a.length - 1; i >= 0; i--) {
            output[buckets[(a[i] / exp) % 10] - 1] = a[i];
            buckets[(a[i] / exp) % 10]--;
        }
        // 将排序好的数据赋值给a[]
        for (int i = 0; i < a.length; i++) {
            a[i] = output[i];
        }
        // 用完清空
        output = null;
        buckets = null;
    }

    public static void main(String[] args) {
        int[] nums = {1221,232,1242,24,12,4,1,43,14,4,21,4,14,4,1,41,2};
        //nums = bubbleSort(nums);冒泡
        //nums = selectSort(nums);选择
        //nums = ArraySort(nums);数组
        //nums = insertSort(nums);插入
        //nums = shellSrot(nums);希尔
        //nums = HeapSorts(nums);选择排序：堆排序
        //nums = quickSort(nums);快速
        //nums = mergeSort(nums);归并
        nums = radixSort(nums);
        for (int k = 0; k < nums.length; k++) {
            System.err.println("排序之后的"+nums[k]);
        }
    }
}