编程导航算法村第三关 | 青铜挑战

编程导航算法村第三关 | 青铜挑战

数据的基本操作

查找指定元素

   /**
     * 查护照元素
     */
    public static int finElmenet(int[] arrya, int size, int key) {
        for (int i = 0; i < size; i++) {
            if (arrya[i] == key) {
                return i;
            }
        }
        return -1;
    }

插入元素

• size代表现在此数组的长度，数据的可访问的最后一个元素下标是size-1

 /**
     * 插入一个元素
     */
    public static int addElement(int[] arrys, int size, int key) {
//        此时该数组已满，不能增加数据
        if (size >= arrys.length) {
            return -1;
        }
//        移动到待插入数据的前一个数据
        int index = size; // 如果插入的位置是末尾，直接插入即可
        int i;
        for (i = 0; i < size; i++) {
            if (arrys[i] >= key) {
                index = i;
                break;
            }
        }

//        将后续的元素全部向后移动
        for (int j = size; j > index; j--) {
            arrys[j] = arrys[j - 1];
        }

        arrys[index] = key;
        return index;
    }

删除元素

• 先找到待删除元素的位置index
• 从index开始，后一个元素赋值给前一个元素，最后一个元素应该是size-1

 /**
     * 删除元素
     */
    public static int removeElement(int[] arrays, int size, int key) {
//
        int index = -1;
        for (int i = 0; i < size; i++) {
            if (arrays[i] == key) {
                index = i;
                break;
            }
        }
//        此时index就是元素的位置
        if (index != -1) {
            for (int i = index; i < size - 1; i++) {
                arrays[i] = arrays[i + 1];
            }

            return index;
        }


        return -1;
    }

LeetCode 839 是否是单调数组

• 如果对于所有 i <= j，nums[i] <= nums[j]，那么数组 nums 是单调递增的。 如果对于所有 i <= j，nums[i]> = nums[j]，那么数组 nums 是单调递减的。

public boolean isMonotonic(int[] nums) {
//        一次遍历实现递增递减的判断
        boolean isinsrease = true; // 递增
        boolean isreduce = true; // 递减
        for (int i = 0; i < nums.length - 1; i++) {
//            判断是否是递增
            if (nums[i] > nums[i + 1]) {
                isinsrease = false;
            }

//          判断是否是递减
            if (nums[i] < nums[i + 1]) {
                isreduce = false;
            }

        }

//        if (isinsrease && !isreduce) {
//            return true;
//        }
//        if (!isinsrease && isreduce) {
//            return true;
//        }
//        if (isinsrease && isreduce) {
//            return true;
//        }
//   优化：直接用一个或符号代替
        return isinsrease || isreduce;
    }

数组合并（Leetcode 88）

• 从后往前寻找最大的元素，并入到新数组中，直到有一个数组合并完成
• 将未完成合并的一个数据的元素加入到新数组中

 public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m + n - 1; // 1
        int n1 = m - 1; // 0
        int n2 = n - 1; //0

//        找到n个两个数组中的最大值，然后赋值给最后
        while (n1 >= 0 && n2 >= 0) {
            if (nums1[n1] >= nums2[n2]) {
                nums1[i] = nums1[n1];
                i--;
                n1--;
                if (n1 == -1) {
                    break;
                }
            }

            if (nums1[n1] <= nums2[n2]) {
                nums1[i] = nums2[n2];
                i--;
                n2--;

            }
        }


//        判断一下哪个数组还没有移动完成
        while (n1 != -1) {
            nums1[i] = nums1[n1];
            i--;
            n1--;
        }

        while (n2 != -1) {
            nums1[i] = nums2[n2];
            i--;
            n2--;
        }
    }