数组排序——八大排序方法

1. 冒泡排序

1. 冒泡排序的思想
   ⚫ 从头开始两两比较，把较大的元素与较小的元素进行交换
   ⚫ 每轮把当前最大的一个元素存入到数组当前的末尾。
2. 代码

@Test
    public void Maopao(){
        int[] arr = {23,645,34,675,435,4,65,324,45,234};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j]>arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i+" ");
        }
    }
    4 23 34 45 65 234 324 435 645 675 

2. 选择排序

1. 选择排序的思想
   ⚫在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
   ⚫从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
   ⚫以此类推，直到所有元素均排序完毕
2. 代码

     @Test
    public void Xuanze(){
        int[] arr = {23,645,34,675,435,4,65,324,45,234};

        for (int i = 0; i < arr.length-1; i++) {
            int min = i;
            for (int j = i+1; j < arr.length; j++) {
                if (arr[j]<arr[min]){
                    min =j;
                }
            }
            if (min!=i){
                int temp = arr[i];
                arr[i]=arr[min];
                arr[min]=temp;
            }
        }
        System.out.println(Arrays.toString(arr));
        }
    4 23 34 45 65 234 324 435 645 675 

3. 快速排序

1. 快速排序的思想
   通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
2. 代码

    public static void Kuaisu(int[] arr,int begin,int end){
        //判断数组起始位置和重点位置是否合理
        if (begin<end){
            //将数组第一位存入基准位
            int temp= arr[begin];
            int i =begin;
            int j = end;
            //循环判断
            while (i<j){
                //如果最右边的数不小于基准位，就一直从右边往左比较
                while (i<j&&arr[j]>=temp){
                    j--;
                }
                //右边的数小于基准位，将此书存到数组起始位
                arr[i]=arr[j];
                //新存入的数肯定小于基准位，所以要i++，i位向右移动
                //如果最左边的数不大于基准位，就一直从左边往右比较
                while (i<j&&arr[i]<=temp){
                    i++;
                }
                //左边的数大于基准位，将此书存到数组末位，即刚才复制到首位的位置
                arr[j]=arr[i];
            }
            //循环一次后，i与j相等，跳出循环
            //将基准位放入中间位置
            arr[i]=temp;
            System.out.println(Arrays.toString(arr));
            //将数组以第一次的基准位为中间点，将数组分为左右两部分，进行递归循环
            Kuaisu(arr,begin,i-1);
            Kuaisu(arr,i+1,end);
        }
    }

    public static void main(String[] args) {
        int[] num= {57,68,59,52,72,28,96,33,24};
        int n = 9;
        System.out.println(Arrays.toString(num));
        Kuaisu(num,0,n-1);
        System.out.println(Arrays.toString(num));
    }
}

4. 插入排序

1. 插入排序的思想
   ⚫从第一个元素开始，该元素可以认为已经被排序；
   ⚫取出下一个元素，在已经排序的元素序列中从后向前扫描；
   ⚫如果该元素（已排序）大于新元素，将该元素移到下一位置；
   ⚫重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
   ⚫将新元素插入到该位置后；
   ⚫重复步骤2~5。
2. 代码

 public class Charupaixu {
    /**
     * 插入排序
     * */
    public static void Charu(int[] arr){
        
        int l = arr.length;
        int j=0;
        int nowNum=0;
        for (int i = 1; i < arr.length; i++) {
            j = i-1;
            nowNum = arr[i];
            //当最新的下标小于前一个下标对应的数，则前一个下标的数赋值到当前坐标，向前推进。
            while (j>=0&&arr[j]>nowNum){
                arr[j+1]=arr[j];
                j--;
            }
            //最新下标大于前一个下标，则赋值给这个坐标当前数。
            arr[j+1]=nowNum;
        }
    }
    public static void main(String[] args) {
        int[] num= {57,68,59,52,72,28,96,33,24};
        Charu(num);
        System.out.println(Arrays.toString(num));
    }
}