算法是什麼（一）數組的算法記錄

算法是什麼（一）數組的算法記錄

 

liuyuhang原創，未經容許禁止轉載

 

目錄

算法是什麼（〇） 

 

從入門一個一個來吧，先說數組的算法：

 

一、求極值

 

        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);

 

 

二、排序

 

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();
    }

 

三、求交集

 

    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();
    }

 

四、求並集

 

    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();
    }

 

五、求補集

 

    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();
    }