数组的增删改查

数组的增删改查看似简单，但是还要多去操作才能更好的掌握边界值的判断。

1. 增加一个元素

def add_by_element_sequence(arr, size, key):
    index = size
    for i in range(0, size):
        if key < arr[i]:
            index = i
            break

    for j in range(size, index, -1):
        arr[j] = arr[j - 1]
    arr[index] = key
    return index

2. 删除一个元素

注意：这里要判断array里到底有没有要删除的元素

def remove_by_element(arr, size, key):
    index = -1
    for i in range(0, size):
        if arr[i] == key:
            index = i
            break
    if index != -1:
        for i in range(index + 1, size):
            arr[i - 1] = arr[i]
        size = size - 1
    return size

3. 查找元素

python里查找元素很简单

def find_element(arr, size, key):
    index = -1
    for i in range(size):
        if arr[i] == key:
            index = i
    return index

4. 判断单调数组

这里简单的方法是初始化两个值increase 和 decrease， 然后遍历数组两两比较大小，最后返回知否为单调

    def is_monotonic(self, nums):
        inc = True
        dec = True
        n = len(nums) - 1
        for i in range(n):
            if nums[i] > nums[i + 1]:
                inc = False
            if nums[i] < nums[i + 1]:
                dec = False
        return inc or dec

这里还可以再优化一下，使用二分查找可以提高查找效率

    def searchInsert(self, nums, target):
        left, right = 0, len(nums) - 1

        while left <= right:
            # 中点
            mid = (left + right) // 2
            if nums[mid] == target:
                return mid
            elif target > nums[mid]:
                left = mid + 1
            else:
                right = mid - 1
        return left

5. 数组的合并

python里有函数可以很简单的合并两个数组，并且排序，但是一般面试不会让用

    def merge(self, nums1, m, nums2, n):
        nums1[m:] = nums2
        nums1.sort()

如果有两个单调增的数组，把他们合并可以采用后插法，如果从前往后插入，每次都需要改动后面所有的元素值，但是从后往前插入则会避免这种情况。

或者新建一个list，依次插入，最后再同步num1.

    def merge2(self, nums1, m, nums2, n):
        sorted = []
        p1, p2 = 0, 0
        while p1 < m or p2 < n:
            if p1 == m:
                sorted.append(nums2[p2])
                p2 += 1
            elif p2 == n:
                sorted.append(nums1[p1])
                p1 += 1
            elif nums1[p1] < nums2[p2]:
                sorted.append(nums1[p1])
                p1 += 1
            else:
                sorted.append(nums2[p2])
                p2 += 1
        nums1[:] = sorted