数组的研究和学习

获取数组的最值

需求：获取数组{ 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;
    }
}