java数组中的八大基本排序

冒泡排序

package com.YouHaoXin.sort;

import java.util.Arrays;

public class SortDemo04 {
    public static void main(String[] args) {
        //冒泡排序
        /*
        排序原理：
        1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
        2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
        3.针对所有的元素重复以上的步骤，除了最后一个。
        4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
         */
        int[] sort={5,1,58,51,26,32,48,88,9,2};
        sort(sort);
        System.out.println(Arrays.toString(sort));

    }
    public static void sort(int[] sort){
        int count=0;//定义一个临时变量，使前后数字可以互换
        for (int i = 0; i <sort.length-1 ; i++) {
            for (int j = 0; j <sort.length-1-i ; j++) {
                if (sort[j + 1] < sort[j]) {
                    count = sort[j + 1];
                    sort[j + 1] = sort[j];
                    sort[j] = count;
                }
            }
        }
  }
 }

选择排序

package com.YouHaoXin.sort;

import java.util.Arrays;

public class SortDemo05 {
    public static void main(String[] args) {
        /*
        选择排序
        1.从未排序序列中，找到关键字最小的元素
        2.如果最小元素不是未排序序列的第一个元素，将其和未排序序列第一个元素互换
        3.重复1、2步，直到排序结束
        。
         */
        int[] arrays ={50,5,51,44,62,81,0,125,418,320,2};
        for (int i = 0; i <arrays.length-1 ; i++) {
            for (int j =i+1; j<arrays.length ; j++) {
                if (arrays[j]<arrays[i]){
                    int count=arrays[j];
                    arrays[j]=arrays[i];
                    arrays[i]=count;
                }
            }

        }
System.out.println(Arrays.toString(arrays));//[0, 2, 5, 44, 50, 51, 62, 81, 125, 320, 418]

直接插入排序

package com.YouHaoXin.sort;


import java.util.Arrays;

public class SortDemo06 {
    public static void main(String[] args) {
        /*
        直接插入排序
       1.从第一个元素开始，该元素可以认为已经被排序
       2.取出下一个元素，在已经排序的元素序列中从后向前扫描
       3.如果该元素（已排序）大于新元素，将该元素移到下一位置
       4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
       5.将新元素插入到该位置后
       6.重复步骤2~5
         */
        int[] arrays={5,51,21,0,41,100,5,2,1,21,58};
        for (int i = 1; i <arrays.length ; i++) {
            for (int j = i; j >0&&arrays[j]<arrays[j-1] ; j--) {
                int count=arrays[j];
                arrays[j]=arrays[j-1];
                arrays[j-1]=count;
            }

        }

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

希尔排序

package com.YouHaoXin.sort;

import java.util.Arrays;

public class SortDemo07 {
    public static void main(String[] args) {
        /*
        希尔排序
        1.希尔排序就是对直接插入排序的优化，核心思想就是选择合适的增量
        2.然后不断缩小增量，进行插入排序，直到增量为1，那么整个排序结束
        3.直接插入排序可以理解为增量为1的希尔排序
        4.希尔排序的增量可以选择数组长度的一半，然后不断减半
        5.希尔排序的增量也可通过克努特（Knuth）序列来算出，最适合该数组的增量
         */
        int[] arrays={5,51,8418,718,125,52,10,20,10,20};
        for (int h = arrays.length/2; h>0 ;h=h/2 ) {
            for (int i = h; i < arrays.length; i++) {
                for (int j = i; j > h - 1; j = j - h) {
                    if (arrays[j] < arrays[j - h]) {
                        int count = arrays[j];
                        arrays[j] = arrays[j - h];
                        arrays[j - h] = count;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(arrays));
        System.out.println("=================================");
        /*
        通过Kunth序列算出最佳增量
        1.h=1
        2.h=h*3+1
        3.一些数组长度比较大的数组就需要使用Kunth序列来定义增量
         */
        int[] arrays1={5,51,8418,718,125,52,10,20,10,20,10,5,848,51,518,812,94,10,8,6,91,517,};
        int kunth=1;
        while(kunth<=arrays1.length/3){
            kunth=kunth*3+1;
        }

        for (int h = kunth; h>0 ;h=(h-1)/3 ) {
            for (int i = h; i < arrays1.length; i++) {
              for (int j = i; j > h - 1; j = j - h) {
                    if (arrays1[j] < arrays1[j - h]) {
                       int count = arrays1[j];
                       arrays1[j] = arrays1[j - h];
                        arrays1[j - h] = count;
                }
              }
        }
        }

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

快速排序

package com.YouHaoXin.sort;

import java.util.Arrays;

public class SortDemo08 {
    public static void main(String[] args) {
        /*
        快速排序
        1.定义一个数组中的数作为基数（一般为数组的第一个数）
        2.从最右边开始进行比较，当最右边的数出现第一个比基数小的数字时，记录该数
        3.从最左边开始进行比较，当最左边的数出现第一个比基数小的数字时，记录该数
        4.将记录的数进行左右调换
        5.左右两边继续扫描调换（左边的下标不能大于右边的下标）
        6.当左右两边的下标相重合时，将该下标所对应的值与基数进行调换
        7.由此，在基数左边的数都小于基数，在基数右边的数都大于基数
        8.利用递归，将该方法在重复对基数左右两边的数进行排序，当最左边的下标大于最右边的下标，结束递归
         */
        int[] arrays={25,52,51,65,51,251,251,23,81,2,51,851,9,0,-5};
        quickSort(arrays,0,arrays.length-1);
        System.out.println(Arrays.toString(arrays));


    }
    public static void quickSort(int[] arrays,int left,int right){
        if(arrays.length==0|| arrays==null){
          return;
        }
        if(left>right){
            return;//递归头，当条件不满足时，结束递归，返回值
        }
        int key=arrays[left];
        int l=left;
        int r=right;
        while(l!=r) {
            while (arrays[r]>key && l < r) {
                r--;
            }
            while(arrays[l]<=key&& l<r){
                l++;
            }
            if(l<r){
                int temp=arrays[l];
                arrays[l]=arrays[r];
                arrays[r]=temp;
            }
        }
        arrays[left]=arrays[l];
        arrays[l]=key;
        quickSort(arrays,left, l-1 );
        quickSort(arrays,l+1,right);
    }
}

归并排序

package com.YouHaoXin.sort;

import java.util.Arrays;

public class SortDemo09 {
    public static void main(String[] args) {
        /*
        归并排序：
        归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，
        即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
         */
        int[] arrays={2,51,51,85,12,41,5,69,287,163,13};
        splitSort(arrays,0,arrays.length-1);
        System.out.println(Arrays.toString(arrays));

    }
    //归并的方法
    public static void mergeSort(int[] arrays,int start,int center,int end){
        //定义一个临时数组
        int[] tepmArrays=new int[end-start+1];
        //定义左边的起始索引
        int i=start;
        //定义右边的起始索引
        int j=center+1;
        //定义一个临时数组的起始索引
        int tepm=0;
        //比较左右两个数组的元素大小，往临时数组里面放
        while(i<=center&&j<=end){
            if(arrays[i]<=arrays[j]){
                tepmArrays[tepm]=arrays[i];
                i++;
            }else{ tepmArrays[tepm]=arrays[j];
                j++;
            }
            tepm++;
        }
        //处理剩余元素
        while(i<=center){
            tepmArrays[tepm]=arrays[i];
            i++;
            tepm++;
        }
        while(j<=end){
            tepmArrays[tepm]=arrays[j];
            j++;
            tepm++;
        }
        //将临时数组的元素取到原数组中
        for (int k = 0; k <tepmArrays.length ; k++) {
            arrays[k+start]=tepmArrays[k];

        }

    }
    //拆分的方法
    public static void splitSort(int[] arrays,int start,int end){
        //计算中间索引
        int center=(start+end)/2;
        if(start<end){
            //利用递归持续拆分
            splitSort(arrays,start,center);
            splitSort(arrays,center+1,end);
            //拆分结束后，进行合并
            mergeSort(arrays,start,center,end);

        }
    }
}

基数排序

package com.YouHaoXin.sort;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.util.Arrays;

public class SortDemo10 {
    public static void main(String[] args) {
        /*
        基数排序:将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。
        然后，从最低位开始，依次进行一次排序。
        这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
        通过分配再收集的方式进行排序
         */

        int[] arrays={84,0,51,5151,121,451,15,8518,151,81,0,60,25,62};
        sortArrays(arrays);
        System.out.println(Arrays.toString(arrays));


    }
    public static void sortArrays (int[] arrays) {
        //定义一个二维数组，存放基数
        int[][] tepm = new int[10][arrays.length];
        //定义一个统计数组
        int[] num = new int[10];
        //获取数组的最大值来确定轮次
        int max = max(arrays);
        //获取最大值字符串的长度
        int length = String.valueOf(max).length();
        //定义循环轮次
        for (int i = 0, n = 1; i < length; i++, n = n * 10) {
            for (int j = 0; j < arrays.length; j++) {
                //获取没有位置上的数字
                int count = arrays[j] / n % 10;
                tepm[count][num[count]++] = arrays[j];
            }
            //取出桶中的元素
            int a=0;
            for (int k = 0; k < num.length; k++) {
                if(num[k]!=0){
                    for (int h = 0; h < num[k]; h++) {
                        //从桶中取出元素赋值与原数组
                        arrays[a]=tepm[k][h];
                        a++;
                    }
                    num[k]=0;//清除上一次元素的统计

                }
                
            }
            
        }
    }

    
    public static int max(int arrays[]) {
        //获取数组的最大值方法
        int max=arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i]>max){
                max=arrays[i];
            }
        }
        return max;
    }
}

堆排序

package com.YouHaoXin.sort;

import java.util.Arrays;

public class SoutDemo11 {
    public static void main(String[] args) {
        /*
        堆排序:此处以大顶堆为例，堆排序的过程就是将待排序的序列构造成一个堆，
        选出堆中最大的移走，再把剩余的元素调整成堆，找出最大的再移走，重复直至有序。
        */
        int[] arrays={15,51,21,7,41,56,28,14,78,11,22,55};
        //定义开始调整的位置
        int start=(arrays.length-1)/2;
        //循环调整位置，使其变成一个大顶堆
        for (int i = start; i >=0 ; i--) {
            toMax(arrays,arrays.length,i);
        }
        //把根元素与最后一个元素进行调换
        for (int i = arrays.length-1; i >0 ; i--) {
            int a=arrays[0];
            arrays[0]=arrays[i];
            arrays[i]=a;
            //调换完后，需形成大顶堆，再继续调换
            toMax(arrays,i,0);
        }
        System.out.println(Arrays.toString(arrays));

    }

    /**
     *
     * @param arrays 要排序的数组
     * @param size 调整的元素个数
     * @param index 从哪里开始调整
     */
    public static void toMax(int[] arrays,int size,int index){
        //获取左右字节的索引
        int left=index*2+1;
        int right=index*2+2;
        //查找最大节点所在的索引
        int max=index;
        if(left<size&&arrays[left]>arrays[max]){
            max=left;
        }
        if(right<size&&arrays[right]>arrays[max]){
            max=right;
        }
        //将最大元素与起始索引的元素调换位置
        if(arrays[max]!=arrays[index]){
            int a=arrays[index];
            arrays[index]=arrays[max];
            arrays[max]=a;
            toMax(arrays,size,max);

        }

    }
}