算法是什么（一）数组的算法记录

算法是什么（一）数组的算法记录

 

liuyuhang原创，未经允许禁止转载

目录

算法是什么（〇） 

从入门一个一个来吧，先说数组的算法：

1、求极值

        int[] arr01 = { 1, 3, 5, 76, 23, 44, 15, 33, 9, -2, -9 };
        int[] arr02 = { 2, 3, 7, 42, 23, 14, 55, 13, 0, -1, -7 };

        int length = 11;
        int temp = arr01[0];
        // 求最大值
        for (int i = 1; i < length; i++) {
            if (arr01[i] > temp) {
                temp = arr01[i];
            }
        }
        System.out.println("the max in arr01 is : " + temp);
        // 求最小值
        for (int i = 1; i < length; i++) {
            if (arr01[i] < temp) {
                temp = arr01[i];
            }
        }
        System.out.println("the min in arr01 is : " + temp);

2、排序

public static void main(String[] args) {
        int[] arr01 = { 1, 3, 5, 76, 23, 44, 15, 33, 9, -2, -9 };
        int[] arr02 = { 2, 3, 7, 42, 23, 14, 55, 13, 0, -1, -7 };
        int[] arr03 = { 1, 4, 9, 12, 33, 24, 25, 73, -4, -9, -17 };
        int[] arr04 = { 0, 2, 11, 41, 63, 19, 51, -3, -2, 0, 3 };
        int length = 11;

        //还有可快速排序法,使用拆分数组,将一个数组拆成两个数组进行排序,一直拆到数组只剩下2个元素,使用递归的方式进行
        //java有实现
        System.out.println("jdk自带的快速排序法");
        Arrays.sort(arr01);
        printArr(arr01);

        System.out.println("冒泡排序法,倒序遍历,将最大的元素向后移动");
        for (int i = length - 1; i > 0; i--) {//倒序遍历
            for (int j = 0; j < i; j++) {//正序遍历
                if (arr02[j] > arr02[j + 1]) {//相邻比较
                    int temp = arr02[j];
                    arr02[j] = arr02[j + 1];
                    arr02[j + 1] = temp;
                }
            }
        }
        printArr(arr02);

        System.out.println("选择排序法,逐次[选择]出当前index后的最小元素,然后安排到当前index位置");
        for (int i = 0; i < length - 1; i++) {
            int min = i;// 记录当前index
            for (int j = i + 1; j < length; j++) {
                if (arr03[min] > arr03[j]) {// 与当前对比,若有个更小的元素,则更换index为更小的index,循环后找到最小的元素的index
                    min = j;
                }
            }
            if (min != i) {// 若最小元素的index与当前index不等,则交换当前元素与最小元素的index
                int temp = arr03[i];
                arr03[i] = arr03[min];
                arr03[min] = temp;
            }
        }
        printArr(arr03);

        System.out.println("交换排序法,逐次[交换]出当后续最小的元素,与当前元素交换位置");//貌似我平时用的是这种
        for (int i = 0; i < length - 1; i++) {
            for (int j = i + 1; j < length; j++) {
                if (arr04[i] > arr04[j]) {//将后续最小的元素提到当前元素位置
                    int temp = arr04[i];
                    arr04[i] = arr04[j];
                    arr04[j] = temp;
                }
            }
        }
        printArr(arr04);

    }

    // 遍历
    public static void printArr(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

3、求交集

    public static void main(String[] args) {
        Integer[] arr01 = { 1, 3, 5, 76, 23, 44, 15, 33, 9, -2, -9 };
        Integer[] arr02 = { 2, 3, 7, 42, 23, 14, 55, 13, 0, -1, -7 };


        Integer[] result = new Integer[0];//建议使用ArrayList,可免去扩容麻烦,但是效率稍有降低
        for (int i = 0; i < arr01.length; i++) {
            for (int j = 0; j < arr02.length; j++) {
                if (arr01[i].equals(arr02[j])) {
                    result = Arrays.copyOf(result, result.length + 1);//结果集扩容
                    result[result.length - 1] = arr02[i];
                    break;//中断arr02循环
                }
            }
        }
        printArr(result);//[3,23]

    }

    // 遍历
    public static void printArr(Integer[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

4、求并集

    public static void main(String[] args) {
        Integer[] arr01 = { 1, 3, 5, 76, 23, 44, 15, 33, 9, -2, -9 };
        Integer[] arr02 = { 2, 3, 7, 42, 23, 14, 55, 13, 0, -1, -7 };


        //双数组对比求并集，ArrayList
        Integer[] result = new Integer[0];//建议使用ArrayList,可免去扩容麻烦,但是效率稍有降低
        result = Arrays.copyOf(arr01, arr01.length);
        for (int i = 0; i < arr02.length; i++) {
            boolean flag = true;
            for (int j = 0; j < result.length; j++) {
                if (arr02[i].equals(result[j])) {//若当前元素与结果集中的元素相同
                    flag = false;//标记false,不插入
                    break;//有重复元素则停止循环
                }
            }
            if (flag == true) {
                result = Arrays.copyOf(result, result.length + 1);//结果集扩容
                result[result.length - 1] = arr02[i];
            }
        }
        printArr(result);//[1,3,5,76,23,44,15,33,9,-2,-9,2,7,42,14,55,13,0,-1,-7]

    }

    // 遍历
    public static void printArr(Integer[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

5、求补集

    public static void main(String[] args) {
        Integer[] arr01 = { 1, 3, 5, 76, 23, 44, 15, 33, 9, -2, -9 };
        Integer[] arr02 = { 2, 3, 7, 42, 23, 14, 55, 13, 0, -1, -7 };//求arr01对arr02的补集,应从arr01中去除与arr02的交集
        Integer[] result = new Integer[0];//建议使用ArrayList,可免去扩容麻烦,但是效率稍有降低
        result = Arrays.copyOf(arr01, arr01.length);
        Integer[] flag = new Integer[0];//标记集
        for (int i = 0; i < arr02.length; i++) {
            for (int j = 0; j < result.length; j++) {
                if (arr02[i].equals(result[j])) {//若当前元素与结果集中的元素相同
                    flag = Arrays.copyOf(flag, flag.length + 1);//扩展标记集,标记的是元素内容,而并非index
                    flag[flag.length - 1] = arr02[i];//记录要删除的元素的index
                }
            }
        }
        printArr(flag);//交集[3 23 ]
        if (flag.length > 0) {
            for (int i = 0; i < flag.length; i++) {//遍历flag
                result = removeEleByEle(flag[i], result);//逐个以flag中的元素删除
            }
        }
        printArr(result);//补集[1 ,5 ,76 ,44 ,15 ,33 ,9 ,-2 ,-9 ]
    }

    //删除指定index的元素
    public static Integer[] removeEleByEle(Integer ele, Integer[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(ele)) {//若当前元素与要删除的参数相同
                for(int j = i;j<arr.length-1;j++){//从该元素开始所有元素前移一位
                    arr[j] = arr[j + 1];
                }
                arr = Arrays.copyOf(arr, arr.length - 1);//删除末尾元素
            }
        }
        return arr;
    }

    // 遍历
    public static void printArr(Integer[] arr) {
        for (Integer i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }