[leetcode笔记003]数组之移除元素移除元素

最新推荐文章于 2023-09-14 14:21:27 发布

Plusmile1

最新推荐文章于 2023-09-14 14:21:27 发布

阅读量94

点赞数

分类专栏： leetcode 文章标签： leetcode 算法数据结构 javascript

本文链接：https://blog.csdn.net/qq_29589765/article/details/129134775

版权

leetcode 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

知识点

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
快指针：寻找新数组的元素，新数组就是不含有目标元素的数组，指向当前要处理的元素
慢指针：指向更新新数组下标的位置，即下一个将要赋值的位置
不必拘泥指针是指向首部还是末尾，比较灵活
思路：暴力解法需要两遍for循环时，考虑双指针
时间复杂度O(n)，空间复杂度O(1)

27. 移除元素

我的方法，在数组尾部放了一个指针，这个方法的优缺点：优点最坏两个指针合起来也只需遍历一次，避免了需要保留的元素的重复赋值操作。，缺点是相对位置变了
快慢指针法优缺点：优点相对位置未改变，缺点重复赋值和最坏两个指针都要遍历一遍。

var removeElement = function(nums, val) {
	let i
	let j = nums.length-1
	let temp
	for ( i = 0; i <= j; i++ ){
		if ( nums[i] === val ) {
			//复习了下splice的用法
			//nums.splice( i, 1, ums[j])
			temp = nums[i]
			nums[i] = nums[j]
			nums[j] = temp
			j--
			i--
		}
	}
	return nums[j] === val ? i+1 : j+1
};

快慢指针法：

var removeElement = function(nums, val) {
	let i
	let j = 0
	for ( i = 0; i < nums.length; i++ ){
		if ( nums[i] !== val ) {
			nums[j] =  nums[i]
			j++
		}
	}
	return j
};

26. 删除有序数组中的重复项

var removeDuplicates = function(nums) {
	let fast
	let slow = 0
	if (nums.length === 1) {
		return 1
	}
	for ( fast = 0; fast < nums.length; fast++ ) {
		if (nums[fast] !== nums[slow]) {
			slow++
			nums[slow] = nums[fast]
		}
	}
	return slow + 1
};

283. 移动零

var moveZeroes = function(nums) {
	let fast
	let slow = 0
	for (fast = 0; fast < nums.length; fast++) {
		if(nums[fast] !== 0) {
		nums[slow] = nums[fast]
		slow++
		}
	}
	for (slow; slow <nums.length; slow++) {
		nums[slow] = 0
	}
	return nums
};

844. 比较含退格的字符串

官方的方法一用了栈，虽然空间复杂度不符合，但是一个思路
官方的方法二，非常棒的思路，因为普通字符只受后面的#约束，所以从末尾开始遍历并记录#的数量，契合空间复杂度
我的方法，还是覆盖，缺点还是操作数多，而且如果转数组的操作空间复杂度>O(1)，则我的方法也不符合空间复杂度

var backspaceCompare = function(s, t) {
	let fast= 0
	let s_slow = 0
	let t_slow = 0
	//先转化为数组
	s = s.split("")
	t = t.split("")  

	for ( ; fast<s.length; fast++) {
		if (s[fast] !== "#"){
		// s是字符串时，这样的修改是无效的
			s[s_slow] = s[fast]
			s_slow++
		} else {
			s_slow === 0 ? 0 : s_slow--
		}
	}
	for (fast = 0; fast < t.length; fast++) {
		if (t[fast] !== "#"){
			t[t_slow] = t[fast]
			t_slow++
		} else {
			t_slow === 0 ? 0 : t_slow--
		}
	}

	// 上面俩应该可以写成一个函数，懒，不写了
	//转化回字符串
	s = s.toString()
	t = t.toString()

	// 复习下slice(start,end),不包括end
	// 注意此处是字符串，可以这么比较，但如果是数组则不能使用 == 和 === 需要逐个比较
	return (s_slow === t_slow) && (s.slice(0, s_slow) == t.slice(0, t_slow))
};

977. 有序数组的平方

var sortedSquares = function(nums) {
	let left = 0
	let right = nums.length - 1
	let numsRes = [...nums]
	let rightRes = right  
	while ( left <= right) {
		if (Math.abs(nums[left]) <= Math.abs(nums[right])) {
			numsRes[rightRes] = nums[right] * nums[right]
			right --
		} else {
			numsRes[rightRes] = nums[left] * nums[left]
			left ++
		}
		rightRes --
	}
	return numsRes
};