线性表:具有相同特征数据元素的一个有限序列,其中所含元素个数称为线性表的长度。从不同角度看,线性表有不同分类。
- 从语言实现角度:一体式和分离式
- 从存储角度看:顺序型和链表型
- 从访问限制的角度:栈和队列
- 从扩容的角度:动态顺序表
数组:数组是线性表最基本的结构,特点是元素是一个紧密在一起的序列,相互之间不需要记录彼此的关系就能访问。在大多数编程语言中,索引是从 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;
}
}
总结
对数组进行CRUD
(增删改查)尤其要注意边界条件。