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

本文链接：https://blog.csdn.net/qq_41488033/article/details/132020235

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

从语言实现角度：一体式和分离式
从存储角度看：顺序型和链表型
从访问限制的角度：栈和队列
从扩容的角度：动态顺序表

在这里插入图片描述

数组：数组是线性表最基本的结构，特点是元素是一个紧密在一起的序列，相互之间不需要记录彼此的关系就能访问。在大多数编程语言中，索引是从 0 算起。

数组空间不一定是满的，100的空间可能只用了10个位置，所以要注意数据个数的变量size和数组长度length可能不一样。

1.数组的创建及增删改查

// 创建数组
let arr = [];
let arr = [1,2,3,4,5];

// 查找一个元素
/**
 * @param size 已经存放的个数
 * @param key 待查找的元素
 * */

let findByElement = function(arr, size, key) {
	for (let i = 0; i < size; i++) {
		if (arr[i] === key) {
			return i
		}
	}
	return -1;
}

// 作业：如果数组是递增的，此时查找时如果相等或者当前位置元素比目标值更大就停下了
let findByElement = function(arr, size, key) {
	for (let i = 0; i < size; i++) {
		if (arr[i + 1] >= arr[i]) {	
			if (arr[i] === key) {
				return i;
			};
		} else {
			i = size;
		};
	};
	return -1;
}

// 增加一个元素
/**
 * @param arr
 * @param size 数组已经存储的元素数量，从1开始编号
 * @param element 待插入的元素
 * @return 
 * */
let addByElementSequence = function(arr, size, element) {
	// 问题①：是否应该是size > arr.length
    // 注意这里的size是从1开始编号的，表示的就是实际元素的个数。而arr.length也是从1开始的，当空间满的时候就是size=arr.length，此时就不能再插入元素了。
	if (size >= arr.length) {
		return -1;

		// 问题2：想想这里是否是index=0或者size-1
        /* 只能令index=size， 0或者size-1都不对。例如已有序列为{3,4,7,8}，如果插入的元素比8大，例如9，假如index=0，则最后结果是{9,3,4,7,8}。假如index=size-1，最后结果就是{3,4,7,9,8}。
        */
		let index = size;
		// 找到新元素的插入位置。问题3：这里是否应该是size-1
        // i < size就表明只遍历到数组最后一个数据
		for (let i = 0; i < size; i++) {
			if (element < arr[i]) {
				index = i;
				break;
			}
		}
		// 元素后移，问题4：想想这里为什么不是size-1
        // 后移时要从插入位置的后面开始
		for (let i = size; i > index; i--) {
			arr[i] = arr[i - 1]; // index下标开始的元素后移一个位置
		}
		arr[index] = element;
		return index;
	}
}

// 删除一个元素
/**
 * @param arr
 * @param size 数组中的元素数量，从1开始编号
 * @param element 要删除的元素
 * */
let removeByElement = function(arr, size, element) {
	let index = -1;
	for (let i = 0; i < size; i++) {
		if (arr[i] === element) {
			index = i;
			break;
		}
	}
	if (index !== -1) {
		for (let i = index + 1; i < size; i++) {
			arr[i - 1] = arr[i];
			size--;
		}
	}
	return size;
}

2.单调数组问题

力扣896题，判断一个给定的数组是否为单调数组。

分析：第一种情况如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。第二种情况如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。只需要遍历数组执行判定条件即可，由于有递增和递减两种情况，所以需要执行两次循环。

let isMonotonic = function(nums) {
	return isSorted(nums, true) || isSorted(nums, false);
}

let isSorted = function(nums, increment) {
	let lengthOfNums = nums.length;
	for (let i = 0; i < lengthOfNums; i++) {
		if (increment) {
			if (nums[i] > nums[i + 1]) {
				// 与下一个数进行比较看是否小于下个数
				return false;
			}
		} else {
			if (nums[i] < nums[i + 1]) {
				// 与下一个数进行比较看是否大于下个数
				return false;
			}
		}
	}
	return true;
}

/*---------------------------------------------------*/
// 对判断数组是否单调的函数进行优化,利用了或运算
let isMonotonic = function(nums) {
	return isSorted(nums);
}

let isSorted = function(nums) {
	let isIncrement = isDecrement = true;
	let lengthOfNums = nums.length;
	for (let i = 0; i < lengthOfNums; i++) {
		if (nums[i] > nums[i + 1]) {
			isIncrement = false;
		}
		if (nums[i] < nums[i + 1]) {
			isDecrement = false;
		}
	}
	return isIncrement || isDecrement;
}

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

用二分查找来解决：

// 二分查找插入数
let insertNumBySplit = function(nums, target) {
	let lengthOfNums = nums.length;
	let ans = lengthOfNums;
	let left = 0;
	let right = lengthOfNums - 1;

	while (left <= right) {
		let middlePosition = ((right - left) >> 1) + left;
		if (target <= nums[middlePosition]) {
			ans = middlePosition;
			right = middlePosition - 1;
		} else {
			left = middlePosition + 1
		}
	}
	return ans
}

3.数组合并问题

力扣88，给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m和n ，分别表示 nums1 和 nums2 中的元素数目。请你合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。
注意：最终合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 应忽略。nums2 的长度为 n 。

分析：比较好的解决办法是从后向前插入，nums1和nums2的元素数量是固定的，所以排序后最远位置一定是nums1和nums2元素都最大的那个，每次都找最大的那个从后向前填就可以了。

// 逆向双指针
let mergeOrderArray = function(nums1, m, nums2, n) {
	let lengthOfTwoArray = m + n;
	let lengthOfNums1 = nums1.length;
	let lengthOfNums2 = nums2.length;
	while (lengthOfNums1 >=0 && lengthOfNums2 >= 0) {
		if (nums1[lengthOfNums1] <= nums2[lengthOfNums2]) 
			nums1[lengthOfTwoArray--] = nums2[lengthOfNums2--];
		else if (nums1[lengthOfNums1] > nums2[lengthOfNums2])
			nums1[lengthOfTwoArray--] = nums1[lengthOfNums1--];
	}
	// 假如A或者B数组还有剩余
	while (lengthOfNums2 !== -1) nums1[lengthOfTwoArray--] = nums2[lengthOfNums2--];
	while (lengthOfNums1 !== -1) nums1[lengthOfTwoArray--] = nums1[lengthOfNums1--];
}

// 优化之后的代码
let mergeOrderArray = function(nums1, m, nums2, n) {
	let p1 = m - 1, p2 = n - 1;
	let tailNum = m + n -  1;
	let currentNum;

	while (p1 >= 0 || p2 >= 0) {
		if (p1 === -1) currentNum = nums2[p2--];
		else if (p2 === -1) currentNum = nums1[p1--];
		else if (nums1[p1] > nums2[p2]) currentNum = nums1[p1--];
		else currentNum = nums2[p2--];
		nums1[tailNum--] = currentNum;
	}
}