数组的应用

（1）在数组中找最大值/最小值

public class TestMaxValue {
    public static void main(String[] args) {
        int[] arr = {4,5,2,1,3};

                              
        //第一步：假设arr[0]中的元素最大
        int max = arr[0]; 
        int index = 0; //0是代表目前最大值的下标
        //第二步：用max变量中的数据与arr中后面的元素一一比较
        //如果有比max还大的，就修改max的值，否则就不改
        //这里i从1开始，是表示要比较的范围是[1, arr.length-1]，因为arr[0]已经给max，不需要比较了
        for(int i=1; i<arr.length; i++){
            if(arr[i] > max){
                max = arr[i];
                index = i;  //现在最大值下标是i
            }
        }
        //输出一个变量的值，快捷模板，soutv
        System.out.println("max = " + max);
        System.out.println("index = [" + index + "]");
    }
}

（2）在数组中对元素进行统计分析

求所有元素的累加和

求所有偶数的个数

public class TestAnalyze {
    public static void main(String[] args) {
        int[] arr = {3,2,5,1,8};
        
        //先声明一个变量，sum，用存储和
        int sum = 0;
        //遍历数组，累加元素
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        //显示结果
        System.out.println("sum = " + sum);

        System.out.println("--------------------------");
        //求所有偶数的个数
        //先声明一个变量，count，用来存储个数
        int count = 0;
        //遍历数组，查找偶数
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]%2==0){
                count++;
            }
        }
        //显示结果
        System.out.println("偶数的个数count = " + count);
    }
}

（3）在数组中查找目标：

关于字符串的查找，比较特殊。因为字符串是引用数据类型，不用用==比较。

用 .equals(String类型数据）比较。

①顺序查找法：从左往右依次查找，不要求数组的元素是有序的

                        最好的情况：一次命中，可以提前结束查找
                        最坏的情况：所有元素都比较一遍，发现没找到
                        时间复杂度：O(n）

public class TestOrderFind {
    public static void main(String[] args) {
        String[] names = {"张三","李四","王五"};

        //键盘输入一个姓名，判断它是否在数组中
        Scanner scanner = new Scanner(System.in);//ctrl+alt+v

        System.out.print("请输入你要查找的姓名：");
        String target = scanner.next();//ctrl+alt+v

        //遍历数组的快捷模板  itar
        int index = -1;
        for (int i = 0; i < names.length; i++) {
            //target 与 names数组的元素比较
            //target 与 names[i]比较
//            if(target == names[i]){ //比较的是字符串的内存地址
            if(target.equals(names[i])){ //比较字符串的内容
                index = i;
                break;
            }
        }
        if(index == -1){
            System.out.println("没找到");
        }else{
            System.out.println("找到了，下标：" + index);
        }
    }
}

②二分查找：要求数组是有序的，否则无法判断该抛弃哪一半。

          对折对折再对折，每次都比较中间的元素，第一次是所有元素的中间位置的元素比较， 第二次是左边/右边一半的中间位置的元素比较。

                   最好的情况：一次命中，可以提前结束查找
                   最坏的情况：一半的一半的一半...
                   时间复杂度：Log(n)

public class TestBinarySearch {
    public static void main(String[] args) {
        
        int[] arr = {2,6,11,57,89};

        int target = 57;
        
       
        //声明一些变量
        int left = 0;//左边界的下标  ，初始化为[0] 第一个元素
        int right = arr.length-1; //右边界的下标，初始化为[arr.length-1] 最后一个元素
        //第一次比较是，所有元素取中间

        int index = -1;
        int mid = (left+right)/2; //中间元素的下标
        
        int count = 0;

        while(left<=right) { //当left > right说明不用找了
            count++;
            if (arr[mid] == target) {
                index = mid;
                break;
            } else if (target > arr[mid]) {
                //查找目标在后半部分
                //修改左边界，
                left = mid + 1;//因为arr[mid]比较过了，下次不用参与了
            } else {
                //查找目标在前半部分
                //修改右边界，
                right = mid - 1;//因为arr[mid]比较过了，下次不用参与了
            }
            mid = (left + right) / 2;
        }

        if(index == -1){
            System.out.println("没找到");
        }else{
            System.out.println("找到了，下标：" + index);
        }
        System.out.println("查找次数count = " + count);
    }
}

（4）数组的反转

public class TestReverse {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};

        //思路：首尾交换法
        //for循环的次数代表 交换的次数
     
        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;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

 (5）冒泡排序

最最经典的一个排序算法，几乎所有编程语言的学习，都要讲它。
虽然它的效率不是最高。思想是非常经典。

思想：通过相邻元素的比较，如果它俩的顺序不符合目标顺序，就交换。
    经过几轮之后实现最终的排序。

结论：5个元素，需要比较4轮，实现排序
    第一轮：比较4次
    第二轮：比较3次
    第三轮：比较2次
    第四轮：比较1次

public class TestBubbleSort {
    public static void main(String[] args) {
        int[] arr =  {4,7,9,2,1};

        
        //需要双重循环，循环嵌套
        //外循环，控制轮数
        //arr.length=5
        //循环的变量i=1,2,3,4  当i=5时，条件不成立结束
        for(int i=1; i<arr.length; i++){
            
            for(int j=0; j<arr.length-i; j++){
                if(arr[j] > arr[j+1]) {//从小到大排序，要求arr[j]<arr[j+1]，否则就交换
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

System.out.print("==================================");
//进阶版

public class TestBubbleSort2 {
    public static void main(String[] args) {

        int[] arr =  {1,2,3,4,5};
        
        int count = 0;//统计比较的轮数
        for(int i=1; i<arr.length; i++){
            count++;
            boolean flag = true;//假设数组已经有序了
            for (int j=0; j<arr.length-i; j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            if(flag){//如果flag是true，说明内循环中没有发生过交换
                break;//结束的是外循环
            }
        }

        System.out.println("比较了几轮：" +count);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}