【Java】【基礎篇】day04:數組

前言

本期任務:畢向東老師Java視頻教程學習筆記(共計25天)


一、進制轉換

 /*
 需求:進制轉換:十進制轉二進制、八進制、十六進制
 
 思路:
    - 使用&運算,取最低位數
        - 二進制取1位(&1)
        - 八進制取3位(&7)
        - 十六進制取4位(&15)
    - 使用>>>運算,移動最低位數
        - 二進制右移1位
        - 八進制右移3位
        - 十六進制右移4位

 步驟:
    - 一重循環
        - 取最低位數(&)
        - 右移最低位數(>>>)
        - 若當前數值爲0時,跳出循環
 */


public class HexConversion {
    public static void main(String[] args) {
        int number = 60;
        System.out.println("十進制:" + number);

        System.out.print("二進制:");
        printArray(toBin(number));

        System.out.print("八進制:");
        printArray(toOctal(number));

        System.out.print("十六進制:");
        printArray(toHex(number));
    }

    public static char[] toBin(int num) {
        return hexConversion(num, 1, 1);
    }

    public static char[] toOctal(int num) {
        return hexConversion(num, 3, 7);
    }

    public static char[] toHex(int num) {
        return hexConversion(num, 4, 15);
    }


    // 進制轉換(通用)
    public static char[] hexConversion(int num, int base, int offset) {
        char[] chs = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        char[] res = new char[32];

        int i = 0;
        while (num != 0) {
            int temp = num & offset;
            res[i++] = chs[temp];
            num = num >>> base;
        }
        return res;
    }

    // 打印數組所有元素
    public static void printArray(char[] arr) {

        for (int i = arr.length - 1; i >= 0; i--) {
            if (arr[i] != '\u0000') {
                if (i > 0)
                    System.out.print(arr[i]);
                else
                    System.out.print(arr[i]);
            }
        }
        System.out.println();
    }
}

二、數組排序

/*
 需求:數組排序實現
    - 支持升序,降序
 
 思路:
    - 冒泡排序
    - 選擇排序
    - 插入排序
 
 步驟:
    - 交換函數
    - 打印數組函數
    - 排序函數
 */


public class ArraySort {
    public static void main(String[] args) {
        int[] array = {1, 3, 2, 5, 4};
        printArray(array);  // 打印排序完成的數組

        System.out.println("-----冒泡排序算法-----");
        bubbleSort(array, false);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的數組
        bubbleSort(array, true);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的數組

        System.out.println("-----選擇排序算法-----");
        selectionSort(array, false);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的數組
        selectionSort(array, true);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的數組

        System.out.println("-----插入排序算法-----");
        insertionSort(array, false);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的數組
        insertionSort(array, true);  // 使用冒泡排序算法排序array
        printArray(array);  // 打印排序完成的數組
    }

    // 交換數組中的兩個元素
    public static void swap(int[] arr, int x, int y) {
        int temp;
        temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }

    // 實現冒泡排序算法
    public static void bubbleSort(int[] arr, boolean reverse) {
        /*
         需求:冒泡排序算法的實現
            - 支持升序,降序

         思路:
            - 兩重循環
            - 比較
            - 交換

         步驟:
            - 交換函數
            - 打印數組函數
            - 冒泡排序函數
                - 遍歷n-1輪,降序關係則交換位置
                - 優化:設置哨兵,若本輪無需交換,說明排序完成,不再繼續下一輪遍歷
         */
        if (arr.length <= 1)    // 若數組長度小於等於1,無需排序
            return;

        boolean flag;
        for (int i = 0; i < arr.length - 1; i++) {
            flag = true;   // 提前結束遍歷的信號
            for (int j = 0; j < arr.length - 1 - i; j++)    // 冒泡排序,每次升序降序,每次都是從首個位置開始
                if (reverse) {
                    if (arr[j] < arr[j + 1]) {
                        swap(arr, j, j + 1);
                        flag = false;       //
                    }

                } else {
                    if (arr[j] > arr[j + 1]) {
                        swap(arr, j, j + 1);
                        flag = false;       //
                    }
                }

            if (flag)   // 若本輪已無需交換,則退出
                break;
        }
    }

    // 實現選擇排序算法
    public static void selectionSort(int[] arr, boolean reverse) {
        /*
         需求:選擇排序算法的實現
            - 支持升序,降序

         思路:
            - 兩重循環
            - 比較
            - 交換(每輪交換0次或1次)

         步驟:
            - 交換函數
            - 打印數組函數
            - 選擇排序函數
                - 遍歷n-1輪,每輪交換0次或1次
         */
        if (arr.length <= 1)    // 若數組長度小於等於1,無需排序
            return;

        for (int i = 0; i < arr.length - 1; i++) {
            int k = i;
            for (int j = i + 1; j <= arr.length - 1; j++)
                if (reverse) {
                    if (arr[j] > arr[k]) {
                        k = j;
                    }

                } else {
                    if (arr[j] < arr[k]) {
                        k = j;
                    }
                }
            if (k != i)
                swap(arr, k, i);
        }
    }

    // 實現插入排序算法
    public static void insertionSort(int[] arr, boolean reverse) {
        /*
         需求:插入排序算法的實現
            - 支持升序,降序

         思路:
            - 兩重循環
            - 比較
            - 移動數組元素

         步驟:
            - 交換函數
            - 打印數組函數
            - 插入排序函數
                - 遍歷n輪,每輪移動多次
         */
        if (arr.length <= 1)    // 若數組長度小於等於1,無需排序
            return;

        for (int i = 0; i < arr.length; i++) {
            int value = arr[i]; // 保存當前位置的值
            int j = i - 1;
            for (; j >= 0; j--) { // 從當前數組最後一個位置開始遍歷
                if (reverse) {
                    if (value > arr[j])
                        arr[j + 1] = arr[j];// 當前位置比目標小,後移一位
                    else
                        break;  // 此時說明已找到插入的位置,退出
                } else {
                    if (value < arr[j])
                        arr[j + 1] = arr[j];      // 當前位置比目標大,後移一位
                    else
                        break;  // 此時說明已找到插入的位置,退出
                }
            }
            arr[j + 1] = value; //初始時有減一操作,插入時需加一
        }
    }

    // 打印數組所有元素
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i < arr.length - 1)
                System.out.print(arr[i] + ", ");
            else
                System.out.print(arr[i] + "]");
        }
        System.out.println();
    }
}
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章