基于Java的十大排序算法

一 、冒泡

    public static void main(String[] args) {
        int[] arr = new int[]{3, 5, 6, 7, 8, 2, 1};
        int i,j;
        for ( i = 0; i <arr.length-1;i++)
        {
            for (j = 0; j<arr.length-1-i;j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("排序");
        for (i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + " ");
        }
    }

二、 快排

 public static void QuickSort(int []arr,int low,int high)
    {
        if (low < high)
        {
            int i = low;
            int j = high;
            int k = arr[low];
            while (i < j)
            {
                while(i < j && arr[j] >= k)     // 从右向左找第一个小于k的数
                {
                    j--;
                }
                if(i < j)
                {
                    arr[i++] = arr[j];
                }

                while(i < j && arr[i] < k)      // 从左向右找第一个大于等于k的数
                {
                    i++;
                }

                if(i < j)
                {
                    arr[j--] = arr[i];
                }
            }

            arr[i] = k;

            // 递归调用
            QuickSort(arr, low, i - 1);     // 排序k左边
            QuickSort(arr, i + 1, high);    // 排序k右边
        }
    }
    public static void display(int array[], int maxlen)
    {
        int i;
        for(i = 0; i < maxlen; i++)
        {
            System.out.print(array[i]+"\t");
        }

    }

    public static void main(String[] args) {
        int [] array= {16,85,25,12,34,23,49,95,17,61};
        int maxlen = array.length;

        System.out.println("排序前的数组");
        display(array, maxlen);

        QuickSort(array, 0, maxlen-1);  // 快速排序

        System.out.println("\n排序后的数组");
        display(array, maxlen);
    }

三、直插

  public static void main(String[] args) {
        int[] array={12,73,45,69,35};
        int i,j,temp;
        for(i=1;i<array.length;i++) {
            temp=array[i];
            for(j=i-1;j>=0;j--) {
                if (temp > array[j])
                {
                    break;
                }
                else {
                    array[j+1] = array[j];
                }
            }
            array[j+1]=temp;
        }
        System.out.println(Arrays.toString(array));
    }

四、 希尔

  public static void main(String[] args) {
        int arr[]={9,1,2,5,7,4,8,6,3,5};
        int len=arr.length;
        //希尔排序
        int k=len/2;
        while(k>=1)
        {
            for(int i=k;i<len;i++)
            {
                int t=arr[i];
                int j=i-k;
                for(;j>=0 && arr[j]>t;j-=k)
                {
                    arr[j+k]=arr[j];
                }
                arr[j+k]=t;
            }
            k/=2;
        }
        for(int i:arr)
        {
            System.out.print(arr[i]+" ");
        }
    }

五、选择

   public static void main(String[] args) {
        int[] arr={1,3,2,45,65,33,12};
        System.out.println("交换之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }

        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k+1 ; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }

六、归并

public static void main(String[] args) {
        int[] arrs = {14, 12, 15, 13, 11, 16};
        System.out.println(Arrays.toString(merge_sort(arrs)));
    }

    // 定义一个方法：拆分子序列
    public static int[] merge_sort(int[] arrs){
        if(arrs.length <= 1 || arrs == null){  //
            return arrs;
        }
        int mid = arrs.length / 2;
        int[] left = Arrays.copyOfRange(arrs, 0, mid);
        int[] right = Arrays.copyOfRange(arrs, mid, arrs.length);
        return merge(merge_sort(left), merge_sort(right));
    }

    // 定义一个方法：将两个无序序列归并成有序
    public static int[] merge(int[] left, int[] right){
        int[] result = new int[left.length + right.length];  // 申请一个空间存储归并后的数组
        int index_left = 0, index_right = 0;    // 定义两个游标 分别指向两个序列的开始位置 作用：归并的换位插入
        // 两个元素的比较
        for(int i = 0; i<result.length; i++){
            if(index_left >= left.length){  // 当左序列全部进入结果后，右序列直接插入即可
                result[i] = right[index_right++];
            }else if(index_right >= right.length){  // 当右序列全部进入结果后,左序列直接插入即可
                result[i] = left[index_left++];
            }else if(left[index_left] <= right[index_right]){    // 升序，左边小于右边，左边保存
                result[i] = left[index_left++];
            }else{
                result[i] = right[index_right++];
            }
        }
        return result;
    }

七 、计数

 public static void main(String[] args) {
        int[] arr=new int[]{56,21,67,45,32,87,34,89,45,74};
        simpleCount(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void simpleCount(int[] arr){
        int max=arr[0];
        for (int i:arr){
            max=Math.max(max,i);
        }
        int result[] = new int[max+1];//动态初始化
        for (int i=0;i<arr.length;i++){
            result[arr[i]]++;
        }
        int index=0;
        for (int i=0;i<result.length;i++){
            while (result[i]>0){
                arr[index++]=i;
                result[i]--;
            }
        }
    }

八、堆

 public static void main(String[] args) {
        int[] arr={1,12,5,8,7,6};
        heapSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    private static void heapSort(int[] arr) {
        for (int i = (arr.length - 1) / 2; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }
        for (int i = arr.length - 1; i > 0; i--) {
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, i);
        }
    }

    private static void adjustHeap(int[] arr, int parent, int length) {
        int temp = arr[parent];
        int lChild = 2 * parent + 1;
        while (lChild < length) {
            int rChild = lChild + 1;
            if (rChild < length && arr[lChild] < arr[rChild]) {
                lChild++;
            }
            if (temp >= arr[lChild]) {
                break;
            }
            arr[parent] = arr[lChild];
            parent = lChild;
            lChild = 2 * lChild + 1;
        }
        arr[parent] = temp;
    }

九 、桶

  public static int[] bucketSort( int[] arr) {
        int max = arr[0],min = arr[0];//  ---- 初始化
        for(int val:arr){//             -------求出最大最小
            max = max>val?max:val;
            min = min<val?min:val;
        }

        int bucketSize = arr.length;//
        List<Integer>[] bukcet = new ArrayList[bucketSize+1];
        for(int i = 0; i < bukcet.length;i++){
            bukcet[i] = new ArrayList<Integer>();
        }
        for(int val : arr){
            int i = (val - min)*bucketSize/(max - min);
            bukcet[i].add(val);
        }
        for(int i = 0; i < bukcet.length;i++){
            Collections.sort(bukcet[i]);
        }
        int k = 0;
        for(int i = 0; i < bukcet.length;i++){
            for(int j = 0; j < bukcet[i].size();j++)
                arr[k++] = bukcet[i].get(j);
        }
        return arr;
    }
    public static void main(String[] args) {
        int arr[]={18,11,28,45,23,50};
        System.out.println(Arrays.toString(bucketSort(arr)));

    }

十 、基数

public static void main(String[] args) {
        int[] arr={9,10,222,1,223,100,7,50,78};

        int maxarr=arr[0];
        for (int i:arr ) {
            if (maxarr<i){
                maxarr=i;
            }
        }
        System.out.println("最大："+maxarr);


        int len=0;
        for (int temp=maxarr;temp!=0;temp/=10){
            len++;
        }
        System.out.println("位数："+len);

        arr=sort(arr, len);

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

    private static int[] sort(int[] arr,int len){
        int sz=10;
        int dev=1;

        for (int i = 0; i <len ; i++,dev*=10,sz*=10) {
// 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
//            int[][] ints = new int[sz*2][0];
            int[][] ints = new int[10][0];

            for (int j = 0; j <arr.length ; j++) {

//                int bucket = ((arr[j]%sz)/dev)+sz;.
                int bucket = ((arr[j]%sz)/dev);

                System.out.println(arr[j]+"->"+bucket);

                ints[bucket]=arrappend(ints[bucket],arr[j]);
            }
            System.out.println("==========");

            int pos = 0;
            for (int[] bucket : ints) {
                for (int value : bucket) {
                    arr[pos++] = value;
                }
            }
        }
        return arr;
    }
    private static int[] arrappend(int[] arr,int value){

        arr=Arrays.copyOf(arr,arr.length+1);
        arr[arr.length-1]=value;
        return arr;
    }