数组-算法-排序

定义数组

public static void main(String[] args) {
    //我们的数组必须初始化，才能使用
    //动态出初始化：接受由我们指定的长度，由系统赋初始值
    int[] arr = new int[5];
    //静态初始化由我们赋值，由系统计算长度
    int[] arr2=new int[]{10,20,3,};
    //静态初始化数组的简写方式
    double[] arr3={10.0,20.1};
    //给数组赋值
    arr[0]=10;
    arr[1]=20;
    int num1=arr[0];
    int num2=arr[1];
    System.out.println(num1);
    System.out.println(num2);
    System.out.println(arr[2]);
}

数组的常见操作

  1. 数组的元素的遍历

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //遍历数组
    System.out.print("获取数组中元素的个数：");
    int length = arr.length;//获取数组中元素的个数
    System.out.println(length);
    for (int i=0;i<=arr.length;i++){
        System.out.println(arr[i]);
    }
}

  2. 数组常见的角标越界异常：ArrayIndexOutOfBoundsException

  3. 数组元素的反向遍历

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //数组的反向遍历
    for (int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
    }
}

  4. 获取数组中的元素的最大值或最小值

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //获取数组中的元素的最大值或最小值
    //定义一个参照值
    int max=arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i]<max){
            max=arr[i];
        }
    }
    System.out.println("最小值："+max);
}
    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    //获取数组中的元素的最大值或最小值
    //定义一个参照值
    int max=arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i]>max){
            max=arr[i];
        }
    }
    System.out.println("最大值："+max);
}

  5. 数组元素的反转

    public static void main(String[] args) {
    //定义数组
    int[] arr=new int[]{10,2,30,42};
    for (int i=0;i<arr.length/2;i++){
        int t=arr[i];
        arr[i]=arr[arr.length-1-i];
        arr[arr.length-1-i]=t;
    }
    //遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+" ");
    }
}

数组之常见的排序算法

  1. 冒泡排序（07：数组排序之冒泡排序哔哩哔哩bilibili）

    public class 冒泡排序 {
    public static void main(String[] args) {
        int[] arr = new int[]{80, 50, 2, 10, 42,102,8};
//        sort(arr);
        //优化冒泡排序
        bubbleSort(arr);
​
​
    }
​
    private static void sort(int[] arr) {
        //第一轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第二轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第三轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1 - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第三轮比较：会把最大的一个数字往后移
        for (int i = 0; i < arr.length - 1 - 1 - 1 - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                //交换位置
                int t = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
​
    //优化冒泡排序
    private static void bubbleSort(int[] arr) {
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int t = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
​
    }
}

  2. 选择排序（08：数组排序之选择排序哔哩哔哩bilibili）

    public class 选择排序 {
    public static void main(String[] args) {
        int[] arr = new int[]{80, 50, 2, 10, 42};
        //普通排序
        sort(arr);
        //优化排序
        selectSort(arr);
    }
    private static void sort(int[] arr){
        //第一轮比较从0索引开始比
        int index=0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第二轮比较从1索引开始比
        index=1;
        for (int i = 1+index; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第三轮比较从1索引开始比
        index=2;
        for (int i = 1+index; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第四轮比较从1索引开始比
        index=3;
        for (int i = 1+index; i < arr.length; i++) {
            if (arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    private static void selectSort(int[] arr){
        for (int index = 0; index < arr.length - 1; index++) {
            for (int i = 1+index; i < arr.length; i++) {
                if (arr[index]>arr[i]){
                    int t=arr[index];
                    arr[index]=arr[i];
                    arr[i]=t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

  3. 插入排序（09：数组排序之直接插入排序哔哩哔哩bilibili）

    public class 插入排序 {
    //选择排序原理:从0索引开始，依次和后面的元素进行排序，小的元素往前放，经过一轮比较后，最小的元素就出来在了最小索引处
    public static void main(String[] args) {
        int[] arr = new int[]{80, 50, 2, 10, 42, 102, 8};
        //普通排序
        sort(arr);
        //优化排序
        insertSort(arr);
    }
​
    private static void sort(int[] arr) {
        //直接插入排序，从1索引处开始，将后面的元素，插入之前的有序列表
        //外层循环定义轮次
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    private static void insertSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j >0 ; j--) {
                if (arr[j]<arr[j-1]){
                    int t=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=t;
                }
​
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

  4. 希尔排序（10：数组排序之希尔排序哔哩哔哩bilibili）

    public class 希尔排序 {
    public static void main(String[] args) {
        //希尔排序，他是对插入排序的一个优化，核心的思想计算合理的选取增量，经过一轮排序后，就会让序列大致有序
        //然后再不断的缩小增量，进行插入排序，直到增量位1那整个排序结构
        //直接插入排序，其实计算增量位1的希尔排序
        int[] arr = new int[]{17, 55, 13, 42, 46, 94, 5, 70};
        //普通排序
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
        //优化排序
        hillsort(arr);
        //自己瞎搞
        hillsortTest(arr);
        System.out.println(Arrays.toString(arr));
        hillsort2(arr);
        System.out.println(Arrays.toString(arr));
    }
​
    private static void shellSort(int[] arr) {
        //定义一个增量
        //第一轮
        int h = 4;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }
        //第二轮
        h = 2;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }
        //第二轮
        h = 1;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    swapValue(arr, j, j - h);
                }
            }
        }
    }
​
    public static void swapValue(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
​
    public static void hillsort(int[] arr) {
        for (int h = 4; h > 0; h /= 2) {
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h - 1; j -= h) {
                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
​
    }
​
    public static void hillsort2(int[] arr) {
        for (int h = arr.length / 2; h > 0; h /= 2) {
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h - 1; j -= h) {
                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
    }
​
    public static void hillsortTest(int[] arr) {
        for (int h = 1; h < arr.length / 2; h++) {
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h - 1; j -= h) {
                    if (arr[j] < arr[j - h]) {
                        swapValue(arr, j, j - h);
                    }
                }
            }
        }
    }
​
​
}

  5. 快速排序（11：数组排序之快速排序哔哩哔哩bilibili）

  6. 归元排序

  7. 基础排序

  8. 堆排序

posted @ 2022-10-08 16:27  菜鸡前来  阅读(27)  评论(0)  编辑  收藏  举报