[Java]Java中各种排序算法

Java中各种排序算法

package untils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class _Sort {

    //冒泡排序
    public static void bubbleSort (List<Integer> array) {
        for(int i=1;i<array.size();i++) {
            for(int j=0;j<array.size()-i;j++) {
                if(array.get(j)>array.get(j+1)) {
                    int temp=array.get(j);
                    array.set(j,array.get(j+1));
                    array.set(j+1,temp);
                }
            }
        }
    }
    //选择排序
    public static void selectSort(List<Integer> array) {
        for (int i = 0; i < array.size() - 1; i++) {
            int minIndex = i; // 用来记录最小值的索引位置，默认值为i
            for (int j = i + 1; j < array.size(); j++) {
                if (array.get(j) < array.get(minIndex)) {
                    minIndex = j; // 遍历 i+1~length 的值，找到其中最小值的位置
                }
            }
            // 交换当前索引 i 和最小值索引 minIndex 两处的值
            if (i != minIndex) {
                int temp=array.get(i);
                array.set(i,array.get(minIndex));
                array.set(minIndex,temp);
            }
            // 执行完一次循环，当前索引 i 处的值为最小值，直到循环结束即可完成排序
        }
    }


    /*
     * 插入排序方法
     */
    public static void insertSort(List<Integer> array){
        for(int index = 1; index<array.size(); index++){//外层向右的index，即作为比较对象的数据的index
            int temp = array.get(index);//用作比较的数据
            int leftindex = index-1;
            while(leftindex>=0 && array.get(leftindex)>temp){//当比到最左边或者遇到比temp小的数据时，结束循环
                array.set(leftindex+1,array.get(leftindex));
                leftindex--;
            }
            array.set(leftindex+1,temp);//把temp放到空位上
        }
    }

    /**
     * 堆排序
     * https://www.jianshu.com/p/11655047ab58
     */
    public static void headSort(int[] list) {
        //构造初始堆,从第一个非叶子节点开始调整,左右孩子节点中较大的交换到父节点中
        for (int i = (list.length) / 2 - 1; i >= 0; i--) {
            headAdjust(list, list.length, i);
        }
        //排序，将最大的节点放在堆尾，然后从根节点重新调整
        for (int i = list.length - 1; i >= 1; i--) {
            int temp = list[0];
            list[0] = list[i];
            list[i] = temp;
            headAdjust(list, i, 0);
        }
    }

    private static void headAdjust(int[] list, int len, int i) {
        int k = i, temp = list[i], index = 2 * k + 1;
        while (index < len) {
            if (index + 1 < len) {
                if (list[index] < list[index + 1]) {
                    index = index + 1;
                }
            }
            if (list[index] > temp) {
                list[k] = list[index];
                k = index;
                index = 2 * k + 1;
            } else {
                break;
            }
        }
        list[k] = temp;
    }

    /*
    * 归并排序
    * https://blog.csdn.net/qq_36442947/article/details/81612870
    * */
    public void mergeSort(int [] a,int start,int end){
        if(start<end){//当子序列中只有一个元素时结束递归
            int mid=(start+end)/2;//划分子序列
            mergeSort(a, start, mid);//对左侧子序列进行递归排序
            mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
            merge(a, start, mid, end);//合并
        }
    }
    //两路归并算法，两个排好序的子序列合并为一个子序列
    public void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];//辅助数组
        int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }
        while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while(p2<=right) tmp[k++]=a[p2++];//同上
        //复制回原素组
        for (int i = left; i <=right; i++)
            a[i]=tmp[i];
    }

    /**
     * 希尔排序
     * @param arr 待排数组
     * https://blog.csdn.net/qq_28081081/article/details/80598960
     * https://blog.csdn.net/stoneWang_L/article/details/89217137
     */
    public static void shellSort(int[] arr) {
        for(int gap=arr.length/2; gap>0; gap/=2) { /*步长逐渐减小*/
            for(int i=gap; i<arr.length; i++) { /*在同一步长内*/
                //同一步长内排序方式是插入排序
                int temp = arr[i], j; //待排元素
                //j-gap代表有序数组中最大数的下标，j-pag表示有序数组的前一个元素，减pag是减去偏移量就是步长
                for(j=i; j>=gap && temp<arr[j-gap]; j-=gap)
                    arr[j] = arr[j-gap]; //原有序数组最大的后移一位
                arr[j] = temp; //找到了合适的位置插入
            }
        }
    }

    /* 基数排序
    *  https://www.cnblogs.com/developerY/p/3172379.html
    * */
    private static void radixSort(int[] array,int d) {
        int n=1;//代表位数对应的数：1,10,100...
        int k=0;//保存每一位排序后的结果用于下一位的排序输入
        int length=array.length;
        int[][] bucket=new int[10][length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
        int[] order=new int[length];//用于保存每个桶里有多少个数字
        while(n<d) {
            //将数组array里的每个数字放在相应的桶里
            for(int num:array) {
                int digit=(num/n)%10;
                bucket[digit][order[digit]]=num;
                order[digit]++;
            }
            //将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
            for(int i=0;i<length;i++) {
                //这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
                if(order[i]!=0){
                    for(int j=0;j<order[i];j++) {
                        array[k]=bucket[i][j];
                        k++;
                    }
                }
                order[i]=0;//将桶里计数器置0，用于下一次位排序
            }
            n*=10;
            k=0;//将k置0，用于下一轮保存位排序结果
        }

    }

    /* java内置sort函数 对数组排序 集合类排序在集合的整理之中*/
    public void arraySort(int[] arr){
        //int[] arr = {1,4,6,333,8,2};
        Arrays.sort(arr);//使用java.util.Arrays对象的sort方法
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    public static void main(String args[]) {
        List<Integer> lists = new ArrayList<>();
        int[] ins = {2,3,5,1,23,6,78,34};
        shellSort(ins);
        //headSort(ins);
        for (Integer i:ins
             ) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i = 0; i < ins.length; i++) {
            lists.add(ins[i]);
        }
        insertSort(lists);
        System.out.println(lists);
    }
}