day07_算法训练

案例零：整数反转（大整数算法）

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

暂时不用考虑数据太大的问题，把本题的核心思路写出来即可

比如：

输入：x = 123
输出：321

输入：x = -123
输出：-321

输入：x = 120
输出：21

输入：x = 0
输出：0

要注意，考虑到特殊情况：数字大于2147483647，反转之后就超出范围了，此时就要返回0

public class Test00 {
    /*
        给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
        暂时不用考虑数据太大的问题，把本题的核心思路写出来即可
        比如：
            输入：x = 123
            输出：321

            输入：x = -123
            输出：-321

            输入：x = 120
            输出：21

            输入：x = 0
            输出：0
        要注意，考虑到特殊情况：数字大于2147483647，反转之后就超出范围了，此时就要返回0
     */
    public static void main(String[] args) {
        System.out.println(reverse(123));
        System.out.println(reverse(-123));
        System.out.println(reverse(2147483647));
        System.out.println(reverse(-2147483647));
    }

    //把num进行反转,如果超过了整型的最大范围,需要返回0
    public static int reverse(int num) {// 12345  -12345
        //1.把num变成一个字符串
        String numStr = num + ""; //"12345" "-12345"

        //2.定义变量,记录反转后的结果
        String reverseStr = "";//默认为空字符串,倒序遍历原有的字符串,然后依次拼接到reverseStr上即可

        //3.判断正负性
        if (num >= 0) {
            //倒序遍历numStr字符串
            char[] chars = numStr.toCharArray();
            for (int i = chars.length - 1; i >= 0; i--) {
                reverseStr += chars[i];
            }
        } else {
            //"-12345"
            numStr = numStr.substring(1);//"12345"
            //倒序遍历numStr字符串
            for (int i = numStr.length() - 1; i >= 0; i--) {
                reverseStr += numStr.charAt(i);
            }

            //"54321"
            reverseStr = "-"+reverseStr;
        }

        //把字符串转换成整数
        long resultLong = Long.parseLong(reverseStr);
        //判断是否超出整型的最大范围
        if (resultLong > Integer.MAX_VALUE || resultLong<Integer.MIN_VALUE){
            return 0;
        }else{
            return (int)resultLong;
        }
    }

}

案例一：两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以按任意顺序返回答案。

public class Test01 {
    /*
        给定一个整数数组 nums和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。
          
            你可以按任意顺序返回答案。
     */
    public static void main(String[] args) {
        //int[] arr = {1, 4, 2, 3, 0, 5, 3};
        int[] arr = {1, 2, 3, 2, 4, 5, 2, 7, 2};//{0,2}  {1,3} {1,6}  {1,8}   {3,6}  {3,8}  {6,8}
        //int target = 5;//{0,1} {2,3} {4,5} {2,6}   new int[2];
        int target = 4;
        Collection<int[]> cs = find(arr, target);
        for (int[] c : cs) {
            System.out.println(Arrays.toString(c));
        }
    }

    //定义方法完成
    public static Collection<int[]> find(int[] arr, int target) {
        //1.创建集合,用于存储多个数组(满足要求的两个数的索引)
        Collection<int[]> cs = new ArrayList<>();

        //2.遍历数组,得到每一个元素
        for (int i = 0; i < arr.length - 1; i++) {
            //3.拿着当前的元素和数组中其它索引处的元素求和
            for (int j = i + 1; j < arr.length; j++) {
                //如果当前元素和其它元素是同一个元素,则不计算
                /*if (i==j){
                    continue;
                }*/
                int sum = arr[i] + arr[j];
                //4.比对,如果一样,则把对应的两个坐标封装到一个长度为2的数组中,并存储到cs集合中
                if (sum == target) {
                    //两个坐标封装到一个长度为2的数组中,并存储到cs集合中
                    int[] locations = new int[]{i, j};
                    cs.add(locations);
                }
            }
        }

        return cs;
    }


}

案例二：只出现一次的数字

给你一个非空整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素

比如：

输入：nums = [2,2,1] 输出：1

输入：nums = [4,1,2,1,2] 输出：4

输入：nums = [1] 输出：1

public class Test02 {
    /*
        给你一个非空整数数组`nums`，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素
        比如：
            输入：nums = [2,2,1]	输出：1
            输入：nums = [4,1,2,1,2]	输出：4
            输入：nums = [1]		输出：1
     */
    public static void main(String[] args) {
        int[] arr = {4, 1, 2, 1, 2};
        System.out.println(findOnce(arr));
    }

    public static int findOnce(int[] arr) {
        //找出arr中只出现一次的元素
        /*
            {4,1,2,1,2}
            1. Map<Integer,Integer>: 元素:出现的次数
            2. 遍历数组,当前元素作为键,次数作为值,存储到Map中
                如果该元素在Map中已经存储了,我把它删掉,如果没有存储,把它存进去
            3.map中剩余的就是出现了一次的元素
         */
        //1.创建map集合
        Map<Integer, Integer> map = new HashMap<>();
        //2.遍历数组,得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            int ele = arr[i];
            //判断在map中,有没有出现键为ele的键值对
            if (map.containsKey(ele)) {
                //如果有,则删除
                map.remove(ele);
            } else {
                //如果没有,则存储
                map.put(ele, 1);
            }
        }
        //3.map中剩余的就是出现了一次的元素
        Set<Integer> keys = map.keySet();
        Optional<Integer> first = keys.stream().findFirst();
        Integer ele = first.get();
        return ele;
    }
}




public class Test02 {
    /*
        给你一个非空整数数组`nums`，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素
        比如：
            输入：nums = [2,2,1]	输出：1
            输入：nums = [4,1,2,1,2]	输出：4
            输入：nums = [1]		输出：1
     */
    public static void main(String[] args) {
        int[] arr = {4, 1, 2, 1, 2};
        /*System.out.println(findOnce(arr));
        show();*/

        System.out.println(findOnce2(arr));
    }

    public static int findOnce(int[] arr) {
        //找出arr中只出现一次的元素
        /*
            {4,1,2,1,2}
            1. Map<Integer,Integer>: 元素:出现的次数
            2. 遍历数组,当前元素作为键,次数作为值,存储到Map中
                如果该元素在Map中已经存储了,我把它删掉,如果没有存储,把它存进去
            3.map中剩余的就是出现了一次的元素
         */
        //1.创建map集合
        Map<Integer, Integer> map = new HashMap<>();
        //2.遍历数组,得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            int ele = arr[i];
            //判断在map中,有没有出现键为ele的键值对
            if (map.containsKey(ele)) {
                //如果有,则删除
                map.remove(ele);
            } else {
                //如果没有,则存储
                map.put(ele, 1);
            }
        }
        //3.map中剩余的就是出现了一次的元素
        Set<Integer> keys = map.keySet();
        Optional<Integer> first = keys.stream().findFirst();
        Integer ele = first.get();
        return ele;
    }

    public static int findOnce2(int[] arr) {
        /*
            {4, 1, 2, 1, 2};
            0对数组中的每个元素做异或操作
               0^出现过一次的元素
         */
        int x = 0;
        for (int i = 0; i < arr.length; i++) {
            x ^= arr[i];
        }
        return x;
    }

    public static void show() {
        // ^: 做位运算的时候,相同位置的值一样,则结果为0,如果相同位置的值不一样,则结果为1
        /*
            0000 0011
          ^ 0000 0100
          ----------------
            0000 0111
         */
        System.out.println(3 ^ 4);

        //1.0和任何数做异或运算,结果是任何值
        //2.某个数字,被其它数字连续做两次异或运算,那么结果是当前的某个数字
        /*
            0000 0000
          ^ 0000 1011
          ------------
            0000 1011
         */
        System.out.println(0 ^ 7);
        System.out.println(0 ^ 8);
        /*
            0000 0010
         ^  0000 0111
         -------------
            0000 0101
         ^  0000 0111
         -------------
            0000 0010

         */
        System.out.println(2 ^ 7 ^ 7);
    }
}

案例三：寻找两个正序数组的中位数

给定两个正序数组 arr1和 arr2，请先合并数组，并找出合并之后数组的 中位数 。

1 2 3 4 5 6 7 8 9 中位数：5

1 2 3 4 5 6 中位数：（ 3 + 4 ） / 2

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

public class Test03 {
    /*
        	给定两个正序数组arr1和arr2，请先合并数组，并找出合并之后数组的中位数。
                1 2 3 4 5 6 7 8 9    中位数：5
                1 2 3 4 5 6     	 中位数：（ 3 + 4 ） / 2
     */
    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5};
        int[] arr2 = {2, 4, 6, 8, 10, 12,13};

        int[] newArr = merge(arr1,arr2);
        System.out.println(Arrays.toString(newArr));

        //取中位数
        int mid = newArr.length/2;
        if (newArr.length % 2 ==1){
            //长度为奇数
            System.out.println(newArr[mid]);
        }else {
            //长度为偶数
            System.out.println((newArr[mid]+newArr[mid-1])/2.0);
        }
    }

    public static int[] merge(int[] arr1, int[] arr2) {
        //合并
        //1.创建一个新数组,用于存储合并后的元素
        int[] newArr = new int[arr1.length + arr2.length];

        //2.定义两个变量,分别指向arr1和arr2的头部
        int i1 = 0;//arr1的指针
        int i2 = 0;//arr2的指针

        //3.遍历新数组,往新数组的每一个索引处存储元素
        for (int i = 0; i < newArr.length; i++) {
            //i代表新数组的指针,代表往新数组的哪个地方存储
            //4.处理特殊情况: 有没有哪个数组的元素已经存完了
            //判断arr1的元素有没有存储完毕
            if (i1 > arr1.length - 1){
                //arr1的元素存完了
                //把arr2数组的指针指向的元素存储到新数组的i所引处,并且把i2指针向后移动一位
                newArr[i] = arr2[i2++];
                continue;
            }

            //判断arr2的元素有没有存储完毕
            if (i2 > arr2.length-1){
                //arr2的元素存储完毕
                //把arr1数组的指针指向的元素存储到新数组的i所引处,并且把i1指针向后移动一位
                newArr[i] = arr1[i1++];
                continue;
            }

            //5.两个数组的元素都没有存储完毕,因此需要比较两个数组指针指向的元素的大小
            if (arr1[i1] < arr2[i2]){
                //把arr1数组的指针指向的元素存储到新数组的i所引处,并且把i1指针向后移动一位
                newArr[i] = arr1[i1++];
            }else{
                //把arr2数组的指针指向的元素存储到新数组的i所引处,并且把i2指针向后移动一位
                newArr[i] = arr2[i2++];
            }

        }
        return newArr;
    }
}

案例四：最长回文子串

需求：

给你一个字符串 s，找到 s 中最长的回文子串。

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

public class Test04 {

    /*
        需求：
            给你一个字符串 `s`，找到 `s` 中最长的回文子串。
            注意: 如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。
     */
    public static void main(String[] args) {
        /*System.out.println(isHuiWen("abc"));
        System.out.println(isHuiWen("aba"));*/
        System.out.println(findBiggestHuiWenString("abcdcefgabcdefggfedcba"));

    }

    //定义方法,求指定字符串的最长回文子串
    public static String findBiggestHuiWenString(String s){
        //求s的最长回文子串
        /*
            "abcdefghejklmnopqabaddabdwx" : 最大回文子串
            1.看字符串本身是不是回文子串
            2.看长度-1的子串是不是回文字符串
            3.看长度-2的子串是不是回文字符串
            4.看长度-3的子串是不是回文字符串
         */
        //1.定义变量,记录子串的长度
        int len = s.length();
        while (true){
            //2.定义变量,记录开始截取的索引以及结束截取的索引
            int begin = 0;
            int end = begin+len;
            //找到s中,所有长度为len的字符串进行判断
            while (true){
                //3.截取子串
                String substring = s.substring(begin, end);

                //4.判断当前子串是不是回文字符串
                if (isHuiWen(substring)){
                    //找到了最大的回文子串
                    return substring;
                }else{
                    //没有找到,继续找
                    begin++;
                    end++;
                    if (end>s.length()){
                        //len长度的字符串全部试验完毕
                        break;
                    }
                }
            }
            //长度-1
            len--;
        }
    }

    //定义方法,判断某个字符串是不是回文字符串: 正着和反着一样
    public static boolean isHuiWen(String str){
        //倒序遍历str,生成一个新的字符串,判断新的字符串和str是不是一样
        String reverseStr = "";
        for (int i = str.length()-1; i>=0; i--){
            reverseStr += str.charAt(i);
        }
        return reverseStr.equals(str);
    }

}

案例五：字符串相加

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。

你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。

public class Test05 {

    /*
        给定两个字符串形式的非负整数num1 和num2，计算它们的和并同样以字符串形式返回。
        注意: 你不能使用任何內建的用于处理大整数的库（比如 BigInteger），也不能直接将输入的字符串转换为整数形式。
     */
    public static void main(String[] args) {
        System.out.println(sum("123","989"));

    }

    public static String sum(String num1,String num2){
        //1.创建3个栈
        Stack<Character> num1S = new Stack<>();
        Stack<Character> num2S = new Stack<>();
        Stack<Character> resultS = new Stack<>();

        //把字符串num1中的字符和num2中的字符压入到对应的栈中
        for (int i = 0; i < num1.length(); i++) {
            num1S.push(num1.charAt(i));
        }
        for (int i = 0; i < num2.length(); i++) {
            num2S.push(num2.charAt(i));
        }
        //2.计算
        //定义一个变量,代表进位
        int residue = 0;
        while (!num1S.isEmpty() || !num2S.isEmpty()){
            //2.0 定义两个变量,用于代表本次做加法的两个字符
            char c1;
            char c2;
            //2.1从num1和num2中弹出元素
            if (num1S.isEmpty()){
                c1='0';
            }else{
                c1 = num1S.pop();
            }

            if (num2S.isEmpty()){
                c2='0';
            }else {
                c2 = num2S.pop();
            }

            //2.2做加法运算
            int result = c1-'0'+c2-'0' +residue;
            if (result>=10){
                //进位
                residue = 1;
                resultS.push((char)(result-10+'0'));//2+'0'=50  '2'---50
            }else{
                //不用进位
                residue = 0;
                resultS.push((char)(result+'0'));
            }
        }
        //考虑最后一次的结果有没有进位
        if (residue==1){
            resultS.push('1');
        }
        //3.把结果栈中的字符,拼接成字符串返回
        String resultNum = "";
        while (!resultS.isEmpty()){
            resultNum += resultS.pop();
        }

        return  resultNum;
    }

}

案例六：字符串中的第一个唯一字符

给定一个字符串 s ，找到第一个在字符串中，只存在一次的字符，并返回它的索引。如果不存在，则返回 -1 。

比如：

输入: s = “leetcode”
输出: 0

输入: s = “loveleetcode”
输出: 2

输入: s = “aabb”
输出: -1

public class Test06 {
    /*
        给定一个字符串`s`，找到第一个在字符串中，只存在一次的字符，并返回它的索引。如果不存在，则返回`-1`。

            比如：

                输入: s = "leetcode"
                输出: 0

                输入: s = "loveleetcode"
                输出: 2

                输入: s = "aabb"
                输出: -1
     */
    public static void main(String[] args) {
        System.out.println(findFirstOnceChar("leetcode"));
        System.out.println(findFirstOnceChar("loveleetcode"));
        System.out.println(findFirstOnceChar("aabb"));
    }

    public static int findFirstOnceChar(String s) {
        /*
            1.找到当前字符串中的每一个字符
            2.找到当前那字符串中的其它字符进行比较
                如果所有其它字符跟当前字符不一样,找到了
                否则没有找到
         */
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            char c = chs[i];
            //判断当前的字符c在字符数组其它位置有没有出现
            boolean flag = true;//表示当前字符c是否唯一,默认唯一
            for (int j = 0; j < chs.length; j++) {
                //其它字符
                if (i == j) {
                    continue;
                }
                if (c == chs[j]){
                    //c不唯一
                    flag = false;//修改标记位
                    break;
                }
            }
            //如果当前c唯一,则返回索引
            if (flag){
                return i;
            }
        }
        return -1;
    }


}

案例七：数组去重

给你一个非严格递增排列的数组 nums ，请你删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。

元素的相对顺序应该保持一致，返回 nums 中唯一元素的个数。

注意1：不能采取以下思路

创建一个新

数组，遍历老数组得到每一个元素，拿着每一个元素在新数组中判断是否存在，如果存在就舍弃，不存在就添加

注意2：

直接在原数组nums上进行操作

举例：
    nums数组为：0 1 1 2 3 3 3
    在原数组进行去重，打印结果为:
	不重复的元素有4个。
    遍历结果为0 1 2 3

代码示例:

public class Test07 {
    /*
        给你一个非严格递增排列的数组 `nums` ，请你删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。

        注意: 元素的相对顺序应该保持 一致 ，返回 `nums` 中唯一元素的个数。

            注意1：不能采取以下思路
                    创建一个新数组，遍历老数组得到每一个元素，拿着每一个元素在新数组中判断是否存在，如果存在就舍弃，不存在就添加
            注意2：
                    直接在原数组nums上进行操作
     */
    public static void main(String[] args) {
        int[] arr = {1, 2, 2, 3, 3, 3, 4, 5, 6};
        int count = countOnceNumber(arr);
        System.out.println(count);
        System.out.println(Arrays.toString(arr));
    }

    //返回唯一元素的个数
    public static int countOnceNumber(int[] arr) {
        //定义一个变量,记录唯一元素的个数
        int count = 0;
        //定义变量,记录当前判断了多少次
        int count2 = 0;
        //1.遍历数组，找到每一个元素
        for (int i = 0; i < arr.length - 1; i++) {
            //2.判断当前元素和下一个元素是否相等
            if (arr[i] == arr[i + 1]) {
                //3.把后面的元素往前移动一位
                for (int j = i; j < arr.length - 1; j++) {
                    arr[j] = arr[j + 1];
                }
                //当后面的元素移动到前面后, 当前位置的元素还需要再判断一次
                i--;

            } else {
                //证明当前元素唯一
                count++;
            }
            count2++;
            if (count2 >= arr.length - 1) {
                count++;
                break;
            }
        }

        return count;

    }
}



public class Test07 {
    /*
        给你一个非严格递增排列的数组 `nums` ，请你删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。

        注意: 元素的相对顺序应该保持 一致 ，返回 `nums` 中唯一元素的个数。

            注意1：不能采取以下思路
                    创建一个新数组，遍历老数组得到每一个元素，拿着每一个元素在新数组中判断是否存在，如果存在就舍弃，不存在就添加
            注意2：
                    直接在原数组nums上进行操作
     */
    public static void main(String[] args) {
        int[] arr = {1, 2, 2, 3, 3, 3, 4, 5, 6};
        //int count = countOnceNumber(arr);
        int count = countOnceNumber2(arr);
        System.out.println(count);
        System.out.println(Arrays.toString(arr));
    }

    //返回唯一元素的个数
    public static int countOnceNumber(int[] arr) {
        //定义一个变量,记录唯一元素的个数
        int count = 0;
        //定义变量,记录当前判断了多少次
        int count2 = 0;
        //1.遍历数组，找到每一个元素
        for (int i = 0; i < arr.length - 1; i++) {
            //2.判断当前元素和下一个元素是否相等
            if (arr[i] == arr[i + 1]) {
                //3.把后面的元素往前移动一位
                for (int j = i; j < arr.length - 1; j++) {
                    arr[j] = arr[j + 1];
                }
                //当后面的元素移动到前面后, 当前位置的元素还需要再判断一次
                i--;

            } else {
                //证明当前元素唯一
                count++;
            }
            count2++;
            if (count2 >= arr.length - 1) {
                count++;
                break;
            }
        }

        return count;

    }

    public static int countOnceNumber2(int[] arr){
        //1.定义快慢指针
        int p1 = 0;//指向所有唯一元素中最大的那个元素
        int p2 = p1+1;//指向慢指针右侧的第一个元素

        //2.使用用循环,多次移动指针,查找目标元素跟换位置
        while (p2<arr.length){
            //移动p2,找到第一个和p1指向的元素不同的元素
            while (true){
                if (arr[p2] != arr[p1]){
                    //找到了
                    //把p2指向的元素赋值给p1的下一个元素
                    arr[p1+1] = arr[p2];
                    //p1向后移动
                    p1++;
                }else{
                    //没有找到
                    p2++;
                    if (p2 == arr.length){
                        break;
                    }
                }
            }
        }

        //返回唯一元素的个数
        return p1+1;
    }
}

案例八：盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

**说明：**你不能倾斜容器。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

示例1:

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

代码示例：

public class Test08 {
    /*
        给定一个长度为 `n` 的整数数组arr(数组中的元素都为正数)  。有 `n` 条垂线，第 `i` 条线的两个端点是 `(i, 0)` 和 `(i, arr[i])` 。

        找出其中的两条线，使得它们与 `x` 轴共同构成的容器可以容纳最多的水。

        返回容器可以储存的最大水量。

        说明：你不能倾斜容器。
     */
    public static void main(String[] args) {
        int[] arr = {1, 8, 6, 2, 5, 4, 8, 3, 7};
        //System.out.println(getMax(arr));
        System.out.println(getMax2(arr));
    }

    public static int getMax(int[] arr) {
        //1.定义变量,记录最大的容量
        int max = 0;

        //2.先找到每一条边(找到每个索引对应的元素)
        for (int i = 0; i < arr.length; i++) {

            //3.找到其它的边
            for (int j = i + 1; j < arr.length; j++) {
                //计算两条边可以容纳的容积
                //找到最小的边
                int min = arr[i] < arr[j] ? arr[i] : arr[j];
                //计算容积
                int volume = (j - i) * min;
                if (volume > max) {
                    //修正容积
                    max = volume;
                }

            }
        }

        return max;
    }


    public static int getMax2(int[] arr) {
        /*
            容积 = 底*高

            最大容积: 足够高, 底足够宽

            底: index2-index1
            高: 每个索引处的值
         */
        //0.定义变量,记录最大的容量
        int max = 0;

        //1.定义两个变量,分别指向数组的头部和尾部
        int left = 0;
        int right = arr.length - 1;

        while (left<right) {
            //2.计算left和right代表的边可以组成的容积
            int min = arr[left] < arr[right] ? arr[left] : arr[right];
            int volume = min * (right - left);

            //比对
            if (volume > max) {
                max = volume;
            }

            //3.移动边
            if (arr[right] > arr[left]) {
                //高边是right指向的元素,移动left,让left指向更高的边
                left++;
            } else {
                //高边是left指向的元素,移动right,让right指向更高的边
                right--;
            }
        }

        return max;
    }
}

案例九：插入元素

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

不能使用循环嵌套

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

代码示例：

public class Test09 {
    /*
        给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
        不能使用循环嵌套
     */
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 5, 7, 9};
        System.out.println(calculate(arr,200));

    }

    public static int calculate(int[] arr, int target) {
        //从左往右遍历数组,找一个跟target相同的或者比target大的
        for (int i = 0; i < arr.length; i++) {
            //找到相同的了
            if (arr[i] >= target) {
                return i;
            }
        }

        //需要处理边界值
        return arr.length;
    }
}

案例九：插入元素

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

不能使用循环嵌套

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

代码示例：

public class Test09 {
    /*
        给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
        不能使用循环嵌套
     */
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 5, 7, 9};
        System.out.println(calculate(arr,200));

    }

    public static int calculate(int[] arr, int target) {
        //从左往右遍历数组,找一个跟target相同的或者比target大的
        for (int i = 0; i < arr.length; i++) {
            //找到相同的了
            if (arr[i] >= target) {
                return i;
            }
        }

        //需要处理边界值
        return arr.length;
    }
}