數組的研究和學習

獲取數組的最值

需求：獲取數組{ 77, 66, 43, 96, 2800, 777, 4396, 7} 的最大值和最小值。算法

{（{4396，777，你在暗示什麼？？？？？}）}數組

分析實現的方法：數據結構

先求最大值，先假設第一個元素就是最大值，並賦值給maxValue變量保存，而後依次取出數組中的元素和maxValue做比較，若是取出元素大於maxValue，那麼把該元素設置爲最大值。數據結構和算法

最小值同理。spa

public class ArrayTest01 {
    public static void main(String[] args) {
        int[] arr = { 77, 66, 43, 96, 2800, 777, 4396, 7 };
        int max = getMaxValue(arr);
        System.out.println("最大值爲" + max);

        int min = getMinValue(arr);
        System.out.println("最小值爲" + min);
    }

    /**
     * 獲取數組元素的最大值
     * 
     * @param arr 須要判斷的數組
     * @return 返回數組元素的最大值
     */
    public static int getMaxValue(int[] arr) {
        // 1.假設第一個元素就是最大值
        int max = arr[0];
        // 2.遍歷數組元素，讓max和數組的別的元素開始比較
        for (int i = 1; i < arr.length; i++) {
            // 3.讓arr[i]和max做比較
            if (arr[i] > max) {
                max = arr[i]; // 更新最大值
            }
        }
        return max;
    }

    /**
     * 獲取數組元素的最小值
     * 
     * @param arr
     * @return 返回數組元素的最小值
     */
    public static int getMinValue(int[] arr) {
        // 1.假設第一個元素就是最小值
        int min = arr[0];
        // 2.遍歷數組元素，讓min和數組中的第二個元素開始做比較
        for (int i = 1; i < arr.length; i++) {
            // 3.比較arr[i]和min的大小
            if (arr[i] < min) {
            in = arr[i];
            }
        }
        return min;
    }

}

獲取數組中最值的索引

根據上面一題進行引伸，求數組中的最值在第幾位，是第幾位數索引

分析：求索引隊列

public class ArrayTest02 {
    public static void main(String[] args) {
        int[] arr = { 77, 66, 43, 96, 2800, 777, 4396, 7 };
        int maxIndex = getMaxIndex(arr);
        //索引從0開始,數組索引的取值範圍爲：[0，數組長度-1]
        System.out.println("索引最大值，在第" + (maxIndex + 1) + "位");
        int minIndex = getMinIndex(arr);
        System.out.println("索引最小值，在第" + (minIndex + 1) + "位");
    }
    /**
     * 獲取數組最大值的索引
     * @param arr
     * @return 返回最大值的索引
     */
    public static int getMaxIndex(int[] arr) {
        // 1.假設第一個元素就是最大值
        int maxIndex = 0; // 保存最大值的索引
        // 2.讓arr[maxIndex]和數組中第二個元素開始作比較
        for (int i = 1; i < arr.length; i++) {
            // 3.判斷arr[maxIndex]和arr[i]的大小
            if (arr[maxIndex] < arr[i]) {
                // 4.更新最大值索引
                maxIndex = i;
            }
        }
        return maxIndex;
    }
    /**
     * 獲取數組最小值的索引
     * @param arr
     * @return 返回最小值的索引
     */
    public static int getMinIndex(int[] arr) {
        // 1.假設第一個元素就是最小值
        int minIndex = 0; // 保存最小值的索引
        // 2.讓arr[minIndex]和數組中第二個元素開始作比較
        for (int i = 1; i < arr.length; i++) {
            // 3.判斷arr[minIndex]和arr[i]的大小
            if (arr[minIndex] > arr[i]) {
                // 4.更新最小值索引
                minIndex = i;
            }
        }
        return minIndex;
    }
}

經過值獲取索引

需求：獲取元素777在數組{ 77, 66, 43, 96, 2800, 777, 4396, 7} 中的索引。內存

實現：經過for循環來遍歷數組，把須要查詢的值和數組中的元素一一作比較，若是須要查詢的值和某個元素相等，則返回索引值並結束方法。若是循環完畢都沒查找到，則返回-1。get

方案一：io

ublic class ArrayTest03 {
    public static void main(String[] args) {
        int[] arr = { 77, 66, 43, 96, 2800, 777, 4396, 7 };
        int value = 777;
        int[] arr = {5, 12, 90, 18, 77, 76, 45, 28, 59, 72};
        int value = 59;
        int index = getIndexByValue(arr, value);
        if(index == -1) {
            System.out.println("沒找到");
        }
        else {
            System.out.println(value + "在arr中的索引值爲：" + index);
        }
    }
    /**
     * 經過元素在數組中尋找索引值
     * @param arr 須要查找的數組
     * @param value 須要查找的元素
     * @return 返回元素在數組中的索引，若是沒找到則返回-1
     */
    public static int getIndexByValue(int[] arr, int value) {
        // 1.經過循環，獲取數組中的每個元素值
        for (int i = 0; i < arr.length; i++) {
            // 2.判斷arr[i]是否和value的值相等
            if (arr[i] == value) {
                return i;
            }
        }
        // 3.找不到，則返回-1
        return -1;
    }
}

方案二

public class ArrayTest04 {
    public static void main(String[] args) {
        int[] arr = { 77, 66, 43, 96, 2800, 777, 4396, 7 };
        int value = 777;
        // 0.定義一個變量，用於保存索引
        int index = -1; // 假設找不到
        // 1.經過循環，獲取數組中的每個元素值
        for(int i = 0; i < arr.length; i++) {
        // 2.判斷arr[i]是否和value的值相等
            if(arr[i] == value) {
                index = i;
                break;
            }
        }
        System.out.println(value + "在arr中的索引值爲：" + index);
    }
}

數組反序輸出

需求：將數組反序輸出，原數組{77, 66, 43, 96, 2800, 777, 4396, 7}，反序輸出後{7,4396,777,2800,96,43,66,77}。

方案一：

引入一個外部數組變量，用於保存反序後的數組，而後把原數組中的元素倒序保存於新建立的數組中。

public class ArrayTest05 {
    public static void main(String[] args) {
    int[] arr1 = { 77, 66, 43, 96, 2800, 777, 4396, 7 };
    int[] newArr = reverseOrderArray1(arr1);
    for (int value : newArr) {
        System.out.print(value + " ");
    }
    }

    public static int[] reverseOrderArray1(int[] arr) {
    // 1.新建一個數組，用於保存反序以後的數組元素
    int[] newArr = new int[arr.length];
    // 2.經過循環，獲取arr數組中的所有元素
    for (int i = 0; i < arr.length; i++) {
        // 3.實現數組元素反序
        newArr[arr.length - i - 1] = arr[i];
    }
        return newArr;
    }
}

方案二：

直接對數組中的元素進行首尾交換。

public class ArrayTest06 {
    public static void main(String[] args) {
    int[] arr2 = { 77, 66, 43, 96, 2800, 777, 4396, 7 };
    reverseOrderArray2(arr2);
    for(int value : arr2) {
        System.out.print(value + " ");
    }
}
    public static void reverseOrderArray2(int[] arr){
        // 1.經過循環遍歷arr.length/2以前的元素
        for (int i = 0; i < arr.length / 2; i++) {
            // 2.首尾元素交換值
            // arr[i] 和 arr[arr.length - i - 1]
            int temp = arr[i];
            arr[i] = arr[arr.length - i -1];
            arr[arr.length - i - 1] = temp;
        }
    }
}

1.數據結構和算法

數據結構：數組、鏈表、圖、棧、隊列、哈希表、二叉樹

2.數組的數據結構

核心特色：
a)數組是一塊連續的內存空間
b)數組一旦建立成功，空間長度就不能改變了

數組的優點和劣勢
優點：經過索引來查找速度很是很是快！
劣勢：插入和刪除效率低下，須要本身手動實現數組擴容操做。

數組元素刪除

需求：刪除數組{77, 66, 43, 96, 2800, 777, 4396, 7}索引爲2的元素，刪除後：{77, 66, 96, 2800, 777, 4396, 7}。

分析實現的方法：

把數組索引2之後的元素向前移動一位，最後把數組的最後一個元素的值設置爲默認值（整數類型的默認值爲0）。

public class ArrayTest07 {
    public static void main(String[] args) {
        int[] arr = {77, 66, 43, 96, 2800, 777, 4396, 7};
        int delIndex = 2;

        deleteValueByIndex(arr, delIndex);
        
        for(int value : arr) {
            System.out.print(value + " ");
        }
    }
    
    /**
     * 根據索引刪除數組中的元素
     * @param arr 數組
     * @param delIndex 索引
     */
    public static void deleteValueByIndex(int[] arr, int delIndex) {
        // 1.變量delIndex以後的全部元素
        for(int i = delIndex; i < arr.length - 1; i++) {
            // 2.後一個元素往前拖動一位
            arr[i] = arr[i + 1];
        }
        // 3.把最後一個元素設置爲默認值
        arr[arr.length - 1] = 0;        
    }
}

數組元素插入

需求：在數組{77, 66, 43, 96, 2800, 777, 4396, 7}索引爲2的位置插入元素222，插入後：{77, 66, 222，43, 96, 2800, 777, 4396, 7}。

方希實現的方法：

首先準備給數組擴容，而後把插入索引位置以後的元素日後移動一位，最後在插入索引的位置插入元素。

public class ArrayTest08 {
    public static void main(String[] args) {
        int[] arr = {77, 66, 43, 96, 2800, 777, 4396, 7};
        int insertIndex = 66;
        int insertValue = 222;
        
        int[] newArr = insertValueByIndex(arr, insertIndex, insertValue);
        
        for(int value : newArr) {
            System.out.print(value + " ");
        }
    }
    
    public static int[] insertValueByIndex(int[] arr, int insertIndex, int insertValue) {
        // 0.判斷插入索引是否越界
        if(insertIndex < 0 || insertIndex >= arr.length) {
            throw new IndexOutOfBoundsException("" + insertIndex);
        }
        
        // 用於保存數組實際存放元素的個數
        int count = 8; 
        // 1.判斷數組是否須要擴容
        if(count == arr.length) { // 知足條件，則須要擴容
            // 1.1建立一個比原數組空間更大的一個數組
            int[] newArr = new int[arr.length + 1];
            // 1.2把原數組中的元素拷貝進入新的數組
            for(int i = 0; i < arr.length; i++) {
                newArr[i] = arr[i];
            }
            // 1.3讓原數組指向新建立的數組
            arr = newArr;
        }
        // 2.把插入元素索引以後的元素日後拖動一位
        for(int i = arr.length - 2; i >= insertIndex; i--) {
            arr[i + 1] = arr[i];
        }
        // 3.在數組插入位置執行賦值操做
        arr[insertIndex] = insertValue;
        // 4.返回插入完畢的數組
        return arr;
    }
}