数组练习

数组获取最值

/*
            数组获取最值(获取数组中的最大值最小值)
            1、定义一个数组，存储一些元素（使用静态初始化）
            2、首先在数组中任意找一个元素进行比较，默认一开始它就是最大值
                一般来说，我们取第一个（选择排序）
            3、遍历其他的元素与第一个元素进行比较，如果找到了更大的元素，
                就将它取代，如果比它小，不管它继续和后面比较
            4、输出最大值

 */
public class ArrayDemo1 {
    public static void main(String[] args) {
        //定义一个数组（静态初始化的方式）
        int[] arr = {3, 2, 312, 41, 31, 324, 14, 12, 344, 1, 65, 534};

        //从数组取出任意一个元素进行比较（一般情况下取第一个，默认是最大值）
        int max = arr[0];

        //拿着这个元素，与其他的元素进行比较
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        //输出比较结束后的最大值
        System.out.println("数组中元素的最大值为：" + max);

        //使用方法改进一下
        System.out.println("=======方法获取数组最值===========");
        int maxNum = getMaxNum(arr);
        System.out.println("数组中元素的最大值为：" + maxNum);
        int minNum = getMinNum(arr);
        System.out.println("数组中元素的最小值为：" + minNum);

    }

    /**
     * 获取数组中的最大值
     *
     *  返回值类型：int
     *  参数：int[]
     *
     */
    public static int getMaxNum(int[] array){
        //从数组取出任意一个元素进行比较（一般情况下取第一个，默认是最大值）
        int max = array[0];

        //拿着这个元素，与其他的元素进行比较
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }

        return max;
    }


    /**
     * 获取数组中的最小值
     *  返回值类型：int
     *  参数列表：int[]
     *
     */
    public static int getMinNum(int[] array){
        //从数组取出任意一个元素进行比较（一般情况下取第一个，默认是最大值）
        int min = array[0];

        //拿着这个元素，与其他的元素进行比较
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
        }

        return min;
    }

}

数组元素逆序

/*
        数组元素逆序 (就是把元素对调)
 */
public class ArrayDemo2 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,2,3,4,5,6,7,8,9};

        //将第0索引位置的元素与length-1索引位置的元素进行交换位置
        //将第1索引位置的元素与length-1-1索引位置的元素进行交换位置
        //将第2索引位置的元素与length-1-2索引位置的元素进行交换位置
        //直到length/2
        //此时就停止交换


        //将第0索引位置的元素与length-1索引位置的元素进行交换位置
//        int temp = arr[0];
//        arr[0] = arr[arr.length-1];
//        arr[arr.length-1] = temp;
//
//        //将第1索引位置的元素与length-1-1索引位置的元素进行交换位置
//        int temp1 = arr[1];
//        arr[1] = arr[arr.length-1-1];
//        arr[arr.length-1-1] = temp;
//
//        //将第2索引位置的元素与length-1-2索引位置的元素进行交换位置
//        int temp2 = arr[2];
//        arr[2] = arr[arr.length-1-2];
//        arr[arr.length-1-2] = temp;

        System.out.println("逆序之前："); //123456789
        printArray(arr);

        //逆序
        int[] niXuResult2 = niXu(arr);
        System.out.println("逆序之后：");//987654321
        printArray(niXuResult2);

        int[] niXuResult = niXu2(arr);
        printArray(niXuResult);

    }

    /**
     *  返回值类型：void
     *  参数列表：int[]
     *
     */
    public static void printArray(int[] array){
        for(int i=0;i<array.length;i++){
            if(i==array.length-1){
                System.out.println(array[i]+"]");
            }else if(i==0){
                System.out.print("["+array[i]+",");
            }else {
                System.out.print(array[i]+",");
            }

        }
    }

    /**
     * 实现数组的逆序
     *  返回值类型：int[]
     *  参数列表：int[]
     *
     */
    public static int[] niXu(int[] array){
        //用for循环实现交换
        for(int i=0;i<array.length/2;i++){
            int temp = array[i];
            array[i] = array[array.length-1-i];
            array[array.length-1-i] = temp;
        }
        return array;
    }

    /**
     * 使用两个指针实现数组的逆序
     *  返回值类型：int[]
     *  参数列表：int[]
     *
     */
    public static int[] niXu2(int[] array){
        //使用两个指针实现
        for(int start=0,end=array.length-1;start<=end;start++,end--){
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
        }
        return array;
    }
}

数组查表法

/*
        数组查表法(根据键盘录入索引,查找对应星期)

        分析：
            1、创建数组，存储星期一到星期日的7个元素
            2、键盘录入1-7某个数字
            3、输出对应的星期
 */
import java.util.Scanner;
public class ArrayDemo3 {
    public static void main(String[] args) {
        //定义数组
        String[] week = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        while (true){
            System.out.println("请输入1-7中某一数字：");
            int number = sc.nextInt();
            if(1<=number & number<=7){
                System.out.println("对应的星期是："+week[number-1]);

            }else if(number==0){
                System.out.println("结束输入");
                break;
            }else {
                System.out.println("您输入的数有误，请重新输入。");
            }
        }
    }
}

数组元素查找

/*
        数组元素查找(查找指定元素第一次在数组中出现的索引)

        键盘录入一个数，去数组中查找

        3,13,21,3214,3,12,3,24,3,212,3,1,21,3124,21,3

 */

import java.util.Scanner;

public class ArrayDemo4 {
    public static void main(String[] args) {
        //定义一个数组（静态初始化的方式）
        int[] arr = {3, 13, 21, 3214, 3, 12, 3, 24, 3, 212, 3, 1, 21, 3124, 21, 3};

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的数字：");
        int number = sc.nextInt();

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                System.out.println(number + "数第一次出现在数组中的索引为：" + i);
                break;
            }

            if (i == arr.length - 1) {
                System.out.println("您输入的数：" + number + "在数组中没有找到！");
            }
        }


    }
}

数组排序和二分查找

数组排序和二分查找(后面在数组高级部分讲解)
在IT行业，数据结构尤为重要，后面大部分牵扯到底层优化，架构分析等操作的时候
数据结构跑不掉的。

面试的时候，重点会考察排序和查找算法（掌握非递归的形式实现）
排序：冒泡排序，选择排序，快速排序，堆排序
查找：二分查找