内部排序

①：插入排序

 

    package 排序算法;
    
    import java.util.Arrays;
    
    public class 插入排序 {
    
        static int[] b = InitArray.initArrays(10);
        /*
         * 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法， 冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
         */
    
        /*
         * 插入排序 1：先记住要进来的第一个数 2将这个数和之前的数进行比较
         * 3比前面的数小，前面的数就往后移一位，给它空出一位，知道前面的书比他小，她就插入到那个被比较标记的位置
         * 这里用temp来保存进行比较的数值，因为当前面进行比较后，如果用arr[i]的话，arr[i]会变化，不能再while中进行比较
         * 时间复杂度：O(n^2); 
         * 最好：每次与前面一个元素进行比较，不进行移动，n-1次 最坏：比较次数为(n-1)(n+2)/2;移动次数为(n-1)(n+4)/2次；
         */
        public static void insertSort(int[] arr) {
            int k, temp;
            int n = arr.length;
            for (int i = 1; i < n; i++) {
                temp = arr[i];
                k = i;
                while (k > 0 && arr[k - 1] > temp) {
                    arr[k] = arr[k - 1];
                    k--;
                }
                arr[k] = temp;
            }
        }
    
        
    
        public static void main(String[] args) {
            System.out.println(Arrays.toString(b));
            // insertSort(b);
            insertSort(b);
            System.out.println("排序后的" + Arrays.toString(b));
    
        }
    }

 

②：快速排序

package 排序算法;

import java.util.Arrays;

public class 快速排序 {

    static int[] array = InitArray.initArrays(5);

    public static void quickSort(int[] arr, int begin, int end) {
        if (end - begin <= 1)
            return;
        int x = arr[begin];// 标尺元素
        int p1 = begin;
        int p2 = end;
        boolean dr = true;// 向右筛选
        L1: while (p1 < p2) {
            if (dr) {
                for (int i = p2; i > p1; i--) {
                    if (arr[i] <= x) {
                        arr[p1++] = arr[i];
                        p2 = i;
                        dr = !dr;
                        continue L1;
                    }
                }
                p2 = p1;
            } else {
                for (int i = p1; i < p2; i++) {
                    if (arr[i] >= x) {
                        arr[p2--] = arr[i];
                        p1 = i;
                        dr = !dr;
                        continue L1;
                    }
                }
                p1 = p2;

            }

        }
        arr[p1] = x;
        quickSort(arr, begin, p1 - 1);
        quickSort(arr, p1 + 1, end);
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(array));
        // quickSort(array);
        // System.out.println(Arrays.toString(array));
        quickSort(array, 0, array.length - 1);
        System.out.println(Arrays.toString(array));
    }

}

 

③：选择排序

package 排序算法;

import java.util.Arrays;

public class 选择排序 {
    static int[] b = InitArray.initArrays(10);
    static int[] v = InitArray.initArrays(10);

    // 从大到小排序
    static void selectSort(int[] arr) {
        int min;
        int k;
        int temp;
        for (int i = 0; i < arr.length; i++) {
            k = i;
            min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {

                if (arr[j] > min) {
                    min = arr[j];
                    k = j;
                }
            }
            temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }
    }

    // 从小到大排序
    public static void selectedSort(int[] v) {

        // 1.从原有数组中设置未排序的第一个为最小的
        for (int i = 0; i < v.length; i++) {
            int min = v[i];
            int temp;
            int index = i;
            // 2.从剩余未排序的数组中挑选出一个最小的
            for (int j = i + 1; j < v.length; j++) {
                if (v[j] < min) {
                    min = v[j];
                    index = j;
                }
            }
            // 3.将找出的最小的一个数与应该排在应排好的数的后面
            temp = v[i];
            v[i] = min;
            v[index] = temp;
        }
    }
//不稳定，时间复杂度 O(n^2)
    public static void selectSortCopy(int[] arr){
        int index,temp;
        for(int i = 0; i < arr.length; i ++){
            index = i;
            int min = arr[i];
            for(int j = i+1; j < arr.length; j ++){
                if(min > arr[j]){
                    min= arr[j];
                    index = j;
                }
            }
            temp = arr[i];
            arr[i] = min;
            arr[index] = temp;
        }
    }

    public static void main(String[] args) {
        System.out.println("Before：" + Arrays.toString(v));
        selectSortCopy(v);
        System.out.println("After2：" + Arrays.toString(v));

    }
}

 

InitArray.class

package 排序算法;

import java.util.Arrays;

public class InitArray {
    public static int[] initArrays(int length) {
        int a;
        int[] b = new int[length];
        for (int i = 0; i < length; i++) {
            a = (int) (Math.random() * 10);
            b[i] = a;
        }
        return b;
    }


    public static void swap(int[] arr,int a,int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }


    public static void main(String[] args) {
        int[] a = new int[10];
        a = initArrays(10);
        System.out.println(Arrays.toString(a));
    }

}