算法通关村第三关 | 数组青铜挑战

1. 线性表

具有相同特征数据元素的一个有限序列，其中所含的元素个数称为线性表的长度。

 2.数组的概念

        1. 数组的索引从0开始

        2. 数组中的元素在内存中是连续存储的，且每个元素占用相同的大小空间

        3. 数组的空间不一定是满的，100的空间可能只用了10个位置，所以需要注意数组中元素个数size和数组长度可能不一样，

2.1数组存储元素的特征

        1. 创建一个大小为10的数组，默认值是0

        2、可以初始化一部分位置，但必须从头开始且连续，必须从前往后的连续空间初始化，不可以出现空缺的情况。

        3. 删除元素之后，被删除的元素位置是什么？假如原数组{1，2，3，4，5，6，7，8，0，0}，删除4之后，从5开始向前移动，变成{1，2，3，5，6，7，8，8，0，0}，被删除后size-1，所以最后一个8不会被访问到，

3.数组的基本操作

3.1 数组的创建初始化，

int[] arr = new int[10];
//直接赋值也可以
int[] arr = {1,2,3,4,5,6};

3.2查找一个元素

    /**
     * 
     * @param arr
     * @param size  已存放元素的个数
     * @param key    待查找的元素
     * @return
     */
    public static int findElement(int[] arr,int size, int key){
        for (int i = 0; i < size; i++) {
            if (arr[i] == key){
                return arr[i];
            }
        }
        return -1;
    }

3.3增加一个元素

增加一个元素需要将增加位置之后所有的元素往后移动一位。

  /**
     *
     * @param arr
     * @param size      数组已经存储元素的数量
     * @param element   待插入元素
     * @return
     */
    public static int addElement(int[] arr, int size, int element){
        //1.先判断数组元素是否满的
        if (size >= arr.length){
            return -1;
        }
        //2.插入元素的索引初始化，是否是index=0，或者size-1
        int index = size;
        //3.循环找到索引的位置
        for (int i = 0; i < size; i++) {
            if (element < arr[i]){
                index = i;
                break;
            }
        }
        //4.将索引i及之后的元素向后移动,j为什么不是size -1 ,因为最后一个元素一定是空余的。
        //在中间插入，需要将元素都移动一位。
        for (int j = size; j > index;j--){
            arr[j] = arr[j-1];
        }
        //5.插入
        arr[index] = element;
        return index;
    }

3.4 删除一个元素

分为两步，先查询元素是否存在，存在则删除，

 /**
     *
     * @param arr
     * @param size  数组中元素个数
     * @param key   删除的目标值
     * @return
     */
    public static int removeElement(int[] arr, int size, int key){
        //如果元素不存在会返回-1；
        int index = -1;
        for (int i = 0; i < size; i++) {
            if (arr[i] == key){
                index = i;
                break;
            }
        }
        //元素存在，则删除,将元素向前移动一位
        if (index != -1){
            for (int i = index +1; i < size; i++)
                arr[i - 1] =arr[i];
            size--;
        }
        return size;
    }

4.单调数组问题

如果所有的位置有nums[i] <nums[i+1],则这个数组是单调增，反之则，单调减，代码实现思路是，假如在 i 和 i +1位置上nums[i] <nums[i+1]，只要其余地方有一个nums[j] <nums[j+1]，数组就不是单调了。

    /**
     * 只要两个都有出现则逻辑运算值返回false
     * @param nums
     * @return
     */
    public static boolean isNonotonic(int[] nums){
        boolean inc = true,dec = true;
        for (int i = 0; i < nums.length -1; i++) {
            if (nums[i] > nums[i + 1]){
                return  inc = false;
            }
            if (nums[i] < nums[i + 1]){
                return  dec = false;
            }
        }
        return inc || dec;
    }

5.数组合并专题

LeetCode88:给你两个按非递减顺序排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1 和nums2 中的元素数目，请你合并nums2到nums1上中，合并后的数组同样按非递减顺序排列。

    //nums初始长度为m+n
    public static void merage(int[] nums1,int nums1_len,int[] nums2,int nums2_len){
        for (int i = 0; i < nums2_len; i++) {
            nums1[nums1_len + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }

第二种方式是从后向前插入，A和B的元素数量是固定的，所以排序后最远的位置一定是A和B最大的那个，一次类推，每次都找最大的那个 向前填就可以了

    /**
     * 
     * @param nums1
     * @param len1  数组1长度
     * @param nums2
     * @param len2  数组2长度
     */
    public void merage(int[] nums1,int len1,int[] nums2,int len2){
        int i = len1 + len2 -1;
        int l1 = len1 -1; int l2 = len2 -1;
        while (l1 >= 0 && l2 >= 0){
            if (nums1[l1] >= nums2[l2]){
                nums1[i--] = nums1[l1--];
            }
            if (nums1[l1] <= nums2[l2]){
                nums1[i--] = nums2[l2--];
            }
        }
        //只剩一个数组的情况
        while (l1 >= 0) nums1[i--] = nums1[l1 --];
        while (l2 >= 0) nums1[i--] = nums1[l2 --];
    }