数组练习题总结

---

数组练习题总结

要求

1. 所有操作必须完成方法
2. 代码实现过程必须有严格的文档注释
3. 方法设计要求合情合理

1. 指定数组找出数组中最大值下标位置

代码如下（）：

public class Demo1 {
    public static void main(String[] args) {
        // 源数据数组
        int[] arr = {1, 3, 5, 7, 9, 21, 4, 6, 8, 10};

        int maxIndex = getMaxValueIndex(arr);

        System.out.println("最大值下标位置:" + maxIndex);
    }

    /**
     * 获取指定数组中最大值下标位置
     *
     * @param arr 目标 int 类型数组
     * @return 数组中最大值下标位置
     */
    public static int getMaxValueIndex(int[] arr) {
        // 假设下标为 0 的元素是最大值
        int maxIndex = 0;

        /*
         arr.length 数组长度
         循环结束，可以保证 maxIndex 存储的下标位置一定是最大值下标位置

         循环变量 i 可以从 1 开始，因为假设的最大值下标是 0
         */
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[maxIndex]) {
                maxIndex = i;
            }
        }

        return maxIndex;
    }
}

2.指定数组找出数组中最小值下标位置

代码如下：

public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {11, 3, 5, 7, 9, 21, 0, 6, 8, 10};

        int minIndex = getMinIndex(arr);

        System.out.println(minIndex);
    }

    /**
     * 找出数组中最小值下标位置
     *
     * @param arr 目标 int 类型数组
     * @return 最小值下标位置
     */
    public static int getMinIndex(int[] arr) {
        int minIndex = 0;

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[minIndex]) {
                minIndex = i;
            }
        }

        return minIndex;
    }
}

3.指定数组中最大值元素个数

代码如下：

public class Demo3 {
    public static void main(String[] args) {
        int[] arr = {0, 21, 5, 21, 9, 21, 4, 6, 21, 10};
        int count = getMaxValueCount(arr);
        System.out.println("数组中最大值个数:" + count);
    }

    /**
     * 找出数组中最大值数据个数
     *
     * @param arr 指定查询数据的 int 类型数组
     * @return 最大值数据个数
     */
    public static int getMaxValueCount(int[] arr) {
       //假设数组中最大值数据个数为1
        int count = 1;
        //假设数组中的第一个数据为最大值
        int max = arr[0];

        // 遍历整个数组
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
                count = 1;
            } else if (max == arr[i]) {
                // max 和当前数组中下标 i 的元素一致，count 计数
                count += 1;
            }
        }

        return count;
    }
}

4. 指定数组中最大值元素所有对应下标位置，要求存储到另一个数组中

代码如下：

public class Demo4 {
    public static void main(String[] args) {
        // 【方案一】存储下标的数组容量和源数组容量一致
        int[] arr = {3, 21, 5, 21, 9, 21, 4, 6, 21, 10};
        int[] indexArray = new int[arr.length];

        /*
        常规思路:
            1. 利用循环，找出最大值下标位置
            2. 利用循环，比较数据和对应下标存储数据情况，将目标下标存储到 indexArray
         */
        int maxValue = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxValue) {
                maxValue = arr[i];
            }
        }

        /*
        尾插法使用的计数器:
            1. count 计数当前目标数组中有多少个有效元素
            2. 用于记录下一次存储数据的下标位置。
         */
        int count = 0;

        for (int i = 0; i < arr.length; i++) {
            if (maxValue == arr[i]) {
                indexArray[count++] = i;
            }
        }

        System.out.println("最大元素个数:" + count);
        // Stream 流 + FunctionReference
        Arrays.stream(indexArray)
                .limit(count)
                .forEach(System.out::println);
    }
}

5.找出指定元素在指定数值中第一次出现的下标位置

public class Demo5 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};

        // 第一次出现的下标位置，需要从下标为 0 的位置开始搜索数据。
      
        int num = 15;
        int index = indexOf(arr, num);

        if (index != -1) {
            System.out.println("目标数据下标位置:" + index);
        } else {
            System.out.println("Not Found 404");
        }
    }

    /**
     * 在目标数组中，找到目标数据的第一次下标位置
     *
     * @param arr 用户指定的 int 类型目标数组
     * @param num 用户指定的 int 类型目标数据
     * @return 如果目标数据存在，返回值大于等于 0，否则返回值为 -1
     */
    public static int indexOf(int[] arr, int num) {
    /*
    index 初始化为 -1
        如果目标数据找到，index 大于等于 0
        如果目标数据未找到，index == -1
     */
        int index = -1;

        for (int i = 0; i < arr.length; i++) {
            if (num == arr[i]) {
                index = i;
                break;
            }
        }
        return index;
    }
}

6.找出指定元素在指定数值中最后一次出现的下标位置

public class Demo6 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};

        int num = 5;

        int index = lastIndexOf(arr, num);

        if (index != -1) {
            System.out.println("目标数据最后一次下标位置:" + index);
        } else {
            System.out.println("Not Found 404");
        }
    }

    /**
     * 在目标数组中，找到目标数据的最后一次下标位置
     *
     * @param arr 用户指定的 int 类型目标数组
     * @param num 用户指定的 int 类型目标数据
     * @return 如果目标数据存在，返回值大于等于 0，否则返回值为 -1
     */
    public static int lastIndexOf(int[] arr, int num) {
        int index = -1;


        for (int i = arr.length - 1; i >= 0; i--) {
            if (num == arr[i]) {
                index = i;
                break;
            }
        }
        return index;
    }
}

7.从数组中指定下标开始，到指定下标结束，获取数据存储到新数组中

public class Demo7 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        // 定义变量用于存储用户指定的截取范围
        int start = 0;
        int end = 0;
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入起始和终止下标:");
        start = scanner.nextInt();
        end = scanner.nextInt();

        int[] subArray = subArray(arr, start, end);

        System.out.println(Arrays.toString(subArray));
    }

    /**
     * 数组内容截取，从指定数组中，用户要求的下标位置 start 开始到 end 下标结束
     * 截取目标子数组内容
     *
     * @param arr   源数据数组
     * @param start 用户指定的开始下标
     * @param end   用户指定的结束下标
     * @return 返回值是截取的子数组内容，返回值类型是一个 int[] 数组
     */
    public static int[] subArray(int[] arr, int start, int end) {
        /*
        出现问题是因为用户提供的起始和终止下标不符合代码需求
        错误条件:
            1. end < start
            2. end > arr.length - 1
            3. end < 0 无效条件
            4. start > arr.length - 1 无效条件
            5. start < 0

         start > end || start < 0 || end > arr.length - 1
         数组容量为 10，有效下标为 0 ~ 9
            start = 15 end = 18; 错误条件
            start = 5 end = -5; 错误条件
            start = 5 end = 3; 错误条件
            start = -5 end = 6; 错误条件

         */
        if (start > end || start < 0 || end > arr.length - 1) {
            throw new IllegalArgumentException("截取数组下标不合法");
            /*
            如果封装方法，方法对外的返回值数据类型明确为 int[]
            没有合适的返回值数据内容来表明当前代码错误，也无法要求
            方法有两个类型的返回值
            【引入异常处理】
             */
        }

        /*
        计算新数组的容量
            Java 开发中，范围数据，通常在截取操作过程中，采用方式是要头不要尾
            指定 start = 1 end = 5
            新数组容量为 4
         */
        int[] subArray = new int[end - start];
        int count = 0;
        for (int i = start; i < end; i++) {
            subArray[count++] = arr[i];
        }

        return subArray;
    }
}

8.复制指定数组数据内容到新数组

public class Demo8 {
    public static void main(String[] args) {
        // 源数据数组
        int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        int[] newArray = copyOf(arr);

        System.out.println(Arrays.toString(newArray));
    }

       /**
     * 拷贝一个指定数据内容，将数组数据内容，拷贝到新数组
     *
     * @param arr 源数据数组
     * @return 存储源数据数组的新数组
     */
    public static int[] copyOf(int[] arr) {
        int[] newArray = new int[arr.length];

        for (int i = 0; i < arr.length; i++) {
            newArray[i] = arr[i];
        }
        return newArray;
    }
}

9. 指定数组内容逆序

public class Demo9 {
    public static void main(String[] args) {
        // 源数据数组
        int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        reverse(newArray);
        System.out.println(Arrays.toString(newArray));
    }
   /**
     * 数组内容逆序
     * @param arr 进行逆序操作的数组
     */
    public static void reverse(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
    }
 }

10.在数组指定下标位置添加元素

public class Demo10 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};

        // 用户指定添加数据的下标位置
        int index = 5;
        // 添加的数据内容
        int number = 20;

        add(arr, index, number);

        System.out.println(Arrays.toString(arr));
    }

    /**
     * 在指定下标位置，添加目标数据
     *
     * @param arr    添加数据的目标数组
     * @param index  指定下标位置
     * @param number 添加的数据内容
     * @return 添加操作成功返回 true，否则返回 false
     */
    public static boolean add(int[] arr, int index, int number) {
        if (index > arr.length - 1 || index < 0) {
            return false;
        }

        /*
         需要利用循环进行数组元素移动
         起始:
            最后一个有效元素位置
         终止:
            目标添加数据的下标位置
         */
        for (int i = arr.length - 1; i > index; i--) {
            arr[i] = arr[i - 1];
        }

        // 指定下标位置添加目标元素
        arr[index] = number;
        return true;
    }
}

11. 删除数组中指定下标元素内容

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

        // 用户指定的下标位置
        int index = 5;

        int temp = remove(arr, index);


        System.out.println(Arrays.toString(arr));
        System.out.println("被删除的数据为:" + temp);
    }

    /**
     * 指定数组中，删除指定下标元素，返回值是被删除的元素数据内容
     *
     * @param arr   删除操作的源数据数组
     * @param index 指定删除的下标位置
     * @return 被删除的数据内容
     */
    public static int remove(int[] arr, int index) {
        if (index < 0 || index > arr.length - 1) {
            throw new IllegalArgumentException("下标数据不合法！");
            /*
            方法设计当前返回值是被删除的数据内容，这里错误情况返回任何一个整数
            都有可能是一个被删除数据，无法明确的告知调用者当前方法运算失败，
            引入【异常处理】
             */
        }

        // 【核心】使用一个变量，存储被删除数据内容
        int temp = arr[index];

        // 利用循环移动数据，进行删除操作 从删除数据下标位置开始，到最后一个有效元素结束
        for (int i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }

        // 原本数组最后一个有效元素位置赋值为 0
        arr[arr.length - 1] = 0;
        return temp;
    }
}

12. 选择排序算法推演

public class Demo6 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        System.out.println(Arrays.toString(arr));

        selectSort(arr);

        System.out.println(Arrays.toString(arr));
    }

    // public static <T> void selectSort(T[] arr, Comparator<? super T> compare) {}
    /**
     * 针对于 int 类型数组选择排序算法实现
     *
     * @param arr int 类型数组
     */
    public static void selectSort(int[] arr) {
        // 完成排序算法操作，执行的核心模块次数是当前数组有效元素个数 - 1
        for (int i = 0; i < arr.length - 1; i++) {
            // 按照排序规则要求，找极值对应的下标位置
            int index = i;

            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] < arr[j]) {
                    index = j;
                }
            }

            // 进行数据交换操作，和目标存储极值对应的下标数据进行交换
            if (index != i) {
                int temp = arr[index];
                arr[index] = arr[i];
                arr[i] = temp;
            }
        }
    }
}

13.冒泡排序

public class Demo13 {
        public static void main(String[] args) {
            int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

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

            System.out.println(Arrays.toString(arr));
        }
    
}

---

。