算法通关村第三关-----不简单的数组增删改查

不简单的数组增删改查

1. 一图理解线性表的分类

2. 数组的概念和初始化

概念

数组是一种存储多个相同类型的元素的数据结构。它可以是一维的，也可以是多维的，每个元素都有一个唯一的索引或键来访问。

初始化

以java创建int数组为例

创建指定长度默认值的数组

int[] ints = new int[10];

创建指定值的数组

int[] ints = new int[]{1,2,3,4,5,6,7,8,9};

int[] ints = {1,2,3,4,5,6,7,8,9,10};

3.查找元素

无序数组查找元素

/**
     * 在无序数组中查找元素
     * @param array 数组
     * @param element 待查找元素
     * @param size 数组大小(已存储元素的个数)
     * @return 待查找元素在数组中的下标(-1表示未找到)
     */
    public static int findElementInUnSortedArray(int[] array, int element,int size){
        for(int i=0;i<size;i++){
            if(array[i]==element){
                return i;
            }
        }
        return -1;
    }

有序数组中查找元素(以升序为例)

/**
     * 在升序数组中查找元素
     * @param array 数组
     * @param element 待查找元素
     * @param size 数组大小(已存储元素的个数)
     * @return 待查找元素在数组中的下标(-1表示未找到)
     */
    public static int findElementInAscendingArray(int[] array, int element,int size){
        for(int i=0;i<size;i++){
            if(array[i]==element){
                return i;
            }
            if(array[i]>element){
                return -1;
            }
        }
        return -1;
    }

对比可以发现，在无序数组中查找元素需要遍历数组大小，而在有序数组(以升序为例)中，如果数组元素大于当前元素，可以提前返回查找不到。

4. 插入元素

    /**
     * 在升序数组中插入元素
     * @param array 数组
     * @param element 待查找元素
     * @param size 数组大小(已存储元素的个数)
     * @return 插入元素的下标(-1表示插入失败)
     */
    public static int insertElementInAscendingArray(int[] array, int element,int size){
        if (size>=array.length){
            return -1;
        }
        int index = size;
        for(int i=0;i<size;i++){
            if (element<array[i]){
                index = i;
                break;
            }
        }
        for (int i=size;i>index;i--){
            array[i] = array[i-1];
        }
        array[index] = element;
        size++;
        return index;
    }

5.删除元素

/**
     * 在升序数组中删除元素
     * @param array 数组
     * @param element 待查找元素
     * @param size 数组大小(已存储元素的个数)
     * @return 删除元素的下标(-1表示删除失败)
     */
    public static int removeElementInAscendingArray(int[] array, int element,int size){
        if (size==0){
            return -1;
        }
        int index = -1;
        for(int i=0;i<size;i++){
            if (element==array[i]){
                index = i;
                break;
            }
        }
        if (index!=-1){
            for (int i=index+1;i<size;i++){
                array[i-1] = array[i];
            }
        }
        size--;
        return index;
    }

5. 单调数组问题

问题描述

已知一个数组，对于所有的下标i、j，如果i<j时，array[i]<=array[j]，则数组是单调递增的。对于所有的下标i、j，如果i<j时，array[i]>=array[j]，则数组是单调递减的，给定一个数组，判断数组是否是单调的。详见leetcode

方法描述

按照题目中给出的单调性定义，设置两个变量分别代表单调递增和单调递减，遍历数组，返回结果。

代码实现

public boolean isMonotonic(int[] nums) {
        boolean inc = true;
        boolean dec = true;
        int size = nums.length;
        for(int i=0;i<size-1;i++){
            if(nums[i]>nums[i+1]){
                inc = false;
            }
        }
        for(int i=0;i<size-1;i++){
            if(nums[i]<nums[i+1]){
                dec = false;
            }
        }
        return inc||dec;
    }

6.合并有序数组

问题描述

已知两个有序数组，nums1和nums2，nums1的元素个数为m,nums2的元素个数为n,将num2和并到nums1，使nums1仍为有序数组。(nums1的长度为m+n).

方法描述

方法一

可以直接将nums2拼接到nums1的尾部，然后对num1进行排序(不推荐，后面排序算法之后完善这里)

方法二

可以创建一个数组,比较nums1和nums2的大小，将较小元素放素心创建的数组，然后将新创建的数组元素拷贝到nums1,如此相当于多用了O（n）的空间，而且需要多遍历一次数组进行拷贝操作。(不推荐)

方法三

直接从尾部比较nums1和nums2的元素大小，将较大元素放入nums1的尾部。

代码实现

public void merge(int[] nums1, int m, int[] nums2, int n) {
        int i = m - 1;
        int j = n - 1;
        int size = m+n;
        size--;
        while(i>=0&&j>=0){
            if(nums1[i]>nums2[j]){
                nums1[size--] = nums1[i--];
            }else{
                nums1[size--] = nums2[j--];
            }
        }
        while(i!=-1){
            nums1[size--] = nums1[i--];
        }
        while(j!=-1){
            nums1[size--] = nums2[j--];
        }
    }