[力扣04]Array

已于 2023-06-30 16:41:45 修改
阅读量64 收藏
点赞数
文章标签： leetcode 算法 golang
于 2023-06-30 16:39:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwrasdzcc/article/details/130578016
版权

文章目录

一、思想或常用方法

二、力扣习题

1. 0011 Container With Most Water

在这里插入图片描述
题目大意 #
给出一个非负整数数组 a1，a2，a3，…… an，每个整数标识一个竖立在坐标轴 x 位置的一堵高度为 ai 的墙，选择两堵墙，和 x 轴构成的容器可以容纳最多的水。

解题思路 #
这一题也是对撞指针的思路。首尾分别 2 个指针，每次移动以后都分别判断长宽的乘积是否最大。

func maxArea(height []int) int {
    left, right, max := 0, len(height)-1, 0
    for left < right {
        high := Min(height[left],height[right])
        restmp := high*(right-left)
        if restmp > max {
            max = restmp
        }
        if height[left] > height[right] {
            right--
        }else{
            left++
        }
    }
    return max
}

func Min(a,b int) int {
    if a > b {
        return b
    }
    return a
}

2.0015 3Sum

在这里插入图片描述

//最优解 双指针 + 排序 O(n^2)
func threeSum(nums []int) [][]int {
    i, res, lenth := 0, make([][]int,0), len(nums)
    sort.Ints(nums)
    for ; i < lenth ; i++ {
        if i > 0 && nums[i] == nums[i-1] {
            continue
        }
        for j,k := i+1,lenth-1; j < k;  {
            sum := nums[i] + nums[j] + nums[k]
            if sum == 0 {
                res = append(res,[]int{nums[i],nums[j],nums[k]})
                j++
                k--
                // 跳过重复部分
                for j < k && (nums[j-1]==nums[j] || nums[k+1]==nums[k]){
                    if nums[j-1]==nums[j] {
                        j++
                    }else{
                        k--         
                    }
                }
            }else if sum < 0 {
                j++
            }else{
                k--
            }
        }
    }
    return res
}

3. 0018 4Sum

// 题目大意 #
// 给定一个数组，要求在这个数组中找出 4 个数之和为 0 的所有组合。

// 解题思路 #
// 用 map 提前计算好任意 3 个数字之和，保存起来，可以将时间复杂度降到 O(n^3)。这一题比较麻烦的一点在于，最后输出解的时候，要求输出不重复的解。数组中同一个数字可能出现多次，同一个数字也可能使用多次，但是最后输出解的时候，不能重复。例如 [-1，1，2, -2] 和 [2, -1, -2, 1]、[-2, 2, -1, 1] 这 3 个解是重复的，即使 -1, -2 可能出现 100 次，每次使用的 -1, -2 的数组下标都是不同的。

//这里就需要去重和排序了。map 记录每个数字出现的次数，然后对 map 的 key 数组进行排序，最后在这个排序以后的数组里面扫，找到另外 3 个数字能和自己组成 0 的组合。

// 法一：遍历set法（时间复杂度O(n^3)）较高
//1.获取“值-次数”map 和 值为key的set数组
//2.分别固定1,2,3层指针(每层指针对应一个for循环)，每层指针负责查找该层结果
func fourSum(nums []int, target int) [][]int {
    //1.获取“值-次数”map 和 值为key的set数组
    res, count := [][]int{}, map[int]int{}

    for _,value := range nums {
        count[value]++
    }

    numsSet := []int{}
    for key := range count{
        numsSet = append(numsSet,key)
    }
    sort.Ints(numsSet)
    
    //2.分别固定1,2,3层指针(每层指针对应一个for循环)，每层指针负责查找该层结果
    for i := 0; i < len(numsSet); i++ {
        if numsSet[i]*4 == target && count[numsSet[i]] > 3 {
            res = append(res,[]int{numsSet[i],numsSet[i],numsSet[i],numsSet[i]})
        }
        for j := i+1; j < len(numsSet); j++ {
            if numsSet[i]*3 + numsSet[j] == target && count[numsSet[i]] > 2 {
                res = append(res,[]int{numsSet[i],numsSet[i],numsSet[i],numsSet[j]})
            }
            if numsSet[j]*3 + numsSet[i] == target && count[numsSet[j]] > 2 {
                res = append(res,[]int{numsSet[j],numsSet[j],numsSet[j],numsSet[i]})
            }
            if numsSet[i]*2 + numsSet[j]*2 == target && count[numsSet[i]] > 1 && count[numsSet[j]] > 1 {
                res = append(res,[]int{numsSet[i],numsSet[i],numsSet[j],numsSet[j]})
            } 
            for k := j+1; k < len(numsSet); k++ {
                if numsSet[i]*2 + numsSet[j] + numsSet[k] == target && count[numsSet[i]] > 1 {
                    res = append(res,[]int{numsSet[i],numsSet[i],numsSet[j],numsSet[k]})
                }
                if numsSet[j]*2 + numsSet[i] + numsSet[k] == target && count[numsSet[j]] > 1 {
                    res = append(res,[]int{numsSet[j],numsSet[j],numsSet[i],numsSet[k]})
                }
                if numsSet[k]*2 + numsSet[j] + numsSet[i] == target && count[numsSet[k]] > 1 {
                    res = append(res,[]int{numsSet[k],numsSet[k],numsSet[j],numsSet[i]})
                }
                
                c := target - numsSet[i] - numsSet[j] - numsSet[k]
                if c > numsSet[k] && count[c] > 0 {
                    res = append(res,[]int{numsSet[i],numsSet[j],numsSet[k],c})
                }
            }
        }
    }
    return res
}


//法二：双指针法
//思想:固定i，j指针，让left和right双指针夹逼查找结果，期间跳过left和right重复数字
//双指针法，也叫碰撞指针
func fourSum(nums []int, target int) [][]int {
    length, res := len(nums), [][]int{}
    if length < 4 {
        return nil
    }
    sort.Ints(nums)
    for i := 0; i < length-3; i++ {
        if i > 0 && nums[i] == nums[i-1]{ //首个i不用查重，即i>0
            continue
        }
        for j := i+1; j < length-2 ; j++ {
            if j > i + 1 && nums[j] == nums[j-1]{//同理首个j不用查重,即j > i + 1
                continue
            }
            for left, right := j+1,length-1; left < right; {
                sum := nums[i] + nums[j] + nums[left] + nums[right]
                if sum == target {
                    res = append(res, []int{nums[i], nums[j] , nums[left] , nums[right]})
                    left++
                    right--
                    for left < right && (nums[left-1]==nums[left] || nums[right]==nums[right+1]){
                        if nums[left-1]==nums[left] {
                            left++
                        }else{
                            right--
                        }
                    }
                }else if sum < target {
                    left++
                }else{
                    right--
                }
            }
        }
    }
    return res
}

4.0042 Trapping Rain Water

在这里插入图片描述

1.按列求

//按列求
//1.遍历每个列,找到左右最高的墙
//2.然后比较"较小墙"与"待求列"的高低,只有"较小墙" > "待求列"时,才会有雨水堆积,值为"较小墙高" - "待求列高"
func trap(height []int) int {
    res := 0
    for i := 1;i < len(height)-1; i++ {
        leftMax, rightMax := 0, 0
        for left := i-1;left >= 0; left--{
            if height[left] > leftMax {
                leftMax = height[left]
            }
        }
        for right := i+1;right <= len(height)-1;right++{
            if height[right] > rightMax {
                rightMax = height[right]
            }
        }
        min := Min(leftMax,rightMax)
        if min > height[i] {
            res += min - height[i]
        }
    }
    return res
}

func Min(a,b int) int {
    if a < b {
        return a
    }
    return b
}

2.动态规划

我们注意到，解法二中。对于每一列，我们求它左边最高的墙和右边最高的墙，都是重新遍历一遍所有高度，这里我们可以优化一下。

首先用两个数组，max_left [i] 代表第 i 列左边最高的墙的高度，max_right[i] 代表第 i 列右边最高的墙的高度。（一定要注意下，第 i 列左（右）边最高的墙，是不包括自身的，和 leetcode 上边的讲的有些不同）

对于 max_left我们其实可以这样求。

max_left [i] = Max(max_left [i-1],height[i-1])。它前边的墙的左边的最高高度和它前边的墙的高度选一个较大的，就是当前列左边最高的墙了。

对于 max_right我们可以这样求。

max_right[i] = Max(max_right[i+1],height[i+1]) 。它后边的墙的右边的最高高度和它后边的墙的高度选一个较大的，就是当前列右边最高的墙了。

这样，我们再利用解法二的算法，就不用在 for 循环里每次重新遍历一次求 max_left 和 max_right 了。

作者：windliang
链接：https://leetcode.cn/problems/trapping-rain-water/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-8/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

//动态规划
//O(3n)
//1.前两遍遍历分别找到每列左右最高墙
//2.第三遍遍历直接使用i左右最大值计算即可
func trap(height []int) int {
    res := 0
    max_left,max_right := make([]int,len(height)),make([]int,len(height))
    for i := 1; i < len(height)-1; i++{ //边界不可能积水
        max_left[i] = Max(max_left[i-1],height[i-1])
    }
    for i := len(height)-2;i > 0;i-- {
        max_right[i] = Max(max_right[i+1],height[i+1])
    }
    for k := 1;k < len(height)-1;k++{
        min := Min(max_left[k],max_right[k])
        if min > height[k] {
            res += min - height[k]
        }
    }
    return res
}

func Max(a,b int)int {
    if a < b {
        return b
    }
    return a
}

func Min(a,b int) int {
    if a < b {
        return a
    }
    return b
}

3.双指针

//双指针
//也是考虑每列，不过是由对撞指针从两侧遍历
//如果左指针的高度比右指针的高度小，就不断的移动左指针，否则移动右指针。移动指针过程中，只要指针元素比局部最大值小，就增加“雨水” res 的值，否则更新局部最大高度。

func trap(height []int) int {
    left, right, maxLeft, maxRight, res := 0, len(height)-1, 0, 0, 0
    for left < right {
        if height[left] < height[right] {//height[left] < height[right] 至少有一个height[right]比height[left]要大，maxLeft-height[right]之间的列必有积水
            if height[left] < maxLeft {
                res += maxLeft - height[left]
            }else{
                maxLeft = height[left]
            }
            left++
        }else{ //height[left] >= height[right] 至少有一个height[left]比height[right]要大，height[left]-maxRight之间的列必有积水
            if height[right] < maxRight {
                res += maxRight - height[right]
            }else{
                maxRight = height[right]
            }
            right--
        }
    }
    return res
}

5.0075 Sort Colors

1.map

//map法
func sortColors(nums []int)  {
    m := map[int]int{
        0 : 0,
        1 : 0,
        2 : 0,
    }
    for i := 0;i < len(nums);i++{
        switch nums[i] {
        case 0:
            m[0]++
        case 1:
            m[1]++
        case 2:
            m[2]++
        }
    }

    i := 0
    for m[0] > 0 {
        nums[i] = 0
        i++
        m[0]--
    }
    for m[1] > 0 {
        nums[i] = 1
        i++
        m[1]--
    }
    for m[2] > 0 {
        nums[i] = 2
        i++
        m[2]--
    }

}

2.使用数组代替map

func sortColors(nums []int)  {
    count := []int{0, 0, 0}
    for i := 0;i < len(nums);i++{
        switch nums[i] {
        case 0:
            count[0]++
        case 1:
            count[1]++
        case 2:
            count[2]++
        }
    }

    i := 0
    for idx, value := range count {
        for value > 0 {
            nums[i] = idx 
            value--
            i++
        }
    }

}

3.快排

func sortColors(nums []int)  {
    QuickSort(0, len(nums)-1,nums)
}

func QuickSort(left ,right int,nums []int,){
    if left < right {
        pivotpos := findpivot(left,right,nums)
        QuickSort(left,pivotpos-1,nums)
        QuickSort(pivotpos+1,right,nums)
    }
}

func findpivot(left int,right int,nums []int) int {
    pivot := nums[left]
    for ;left < right;{
        for left<right && nums[right] >= pivot {
            right--
        }
        nums[left] = nums[right]
        for left<right && nums[left] <= pivot {
            left++
        }        
        nums[right] = nums[left]
    }
    nums[left] = pivot
    return left
}

6.0078 Subsets

1.回溯法

在这里插入图片描述

//法一：回溯法
func subsets(nums []int) [][]int {
    cur, res := []int{}, [][]int{}
    for k := 0;k <= len(nums); k++{
        generateSubsets(0, k, cur, nums, &res)
    }
    return res
}
//获取长度为k的所有子集
func generateSubsets(start, k int, cur []int,nums []int, res *[][]int) {
    if 0 == k {
        *res = append(*res,cur)
        return
    }

    for i:=start; i < len(nums); i++{//查找从i开始长度为k的所有子集
        cur = append(cur,nums[i])
        generateSubsets(i+1, k-1, cur, nums, res)//从i+1查找长度为k-1的所有子集
        cur = cur[:len(cur)-1] //弹出当前节点，从下一个节点开始查找长度为k的子集
    }
}

2.位运算

在这里插入图片描述


//法一：位运算
func subsets(nums []int) [][]int {
    if len(nums) == 0 {
		return nil
	}
	res := [][]int{}
	sum := 1 << uint(len(nums))
	for i := 0; i < sum; i++ {
		stack := []int{}
		tmp := i // i 从 000...000 到 111...111
		for j := len(nums) - 1; j >= 0; j-- { // 遍历tmp的每一位
			if tmp & 1 == 1 {//如果对应位为1
				stack = append([]int{nums[j]}, stack...)//将该位对应的数字加入临时子集stack中
			}
			tmp >>= 1
		}
		res = append(res, stack)
	}
	return res
}

7.0079 Word Search

8.0074 Search a 2D Matrix

9.0084 Largest Rectangle in Histogram

10.0088 Merge Sorted Array

11.0090 Subsets II

12.0126 Word Ladder II

13.0216 Combination Sum III

14.0287 Find the Duplicate Number

15.0907 Sum of Subarray Minimums

qwrasdzcc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
力扣二分查找
dayday学习的博客
09-03 506
力扣二分查找704 二分查找1.要求2.思路69 x 的平方根1.要求744 寻找比目标字母大的最小字母1.要求2.思路540有序数组中的单一元素1.要求2.思路153. 寻找旋转排序数组中的最小值1.要求2.思路 704 二分查找 1.要求 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标...
力扣
12-22
力扣（LeetCode）是一个知名的在线编程挑战平台，它提供了各种算法题目，旨在提升程序员的技能，特别是数据结构和算法的运用。其中，题目88“合并两个有序数组”是一道典型的数组操作问题，要求将两个已排序的整数数...
力扣刷题——Array
eaTTimedog的博客
09-29 87
数组
189. Rotate Array【力扣】
xiexie1357的专栏
02-13 187
题意理解 给一个整数数组，旋转k次，每次将最后一个数放到最前面，求最后的数组 问题分析 步骤1，将整个数组全部翻转 步骤2，将前k个数组再翻转（掉转回来） 步骤3，将后n-k个数组再翻转（调转回来） 这样性能是o(n)，空间是o(1) 其他 按照模拟思路，每次移动n次，k次就要移动n*k，这样性能就是o(n*n)，耗时在1500ms左右 按照上面思路，3次翻转，性能从平方降低到线...
88. Merge Sorted Array【力扣】
xiexie1357的专栏
05-28 84
题意理解 两个有序的数组合并成一个有序的数组，顺序不变 问题分析 尾插法 注意要在第一个有序数组上原地构造新的有序数组。 具体思路是双指针从后向前遍历，两序列中大的数就是整个序列中大的数，插到第一个序列的末尾。当第二个序列没有遍历完，将剩余的第二个序列的元素倒着插入第一个序列中。 void merge(vector<int>& nums1, int m, ...
力扣算法整理
Leesure_CSDN的博客
05-08 3039
力扣算法整理
力扣刷题总结
weixin_43270322的博客
01-12 677
总结刷过的力扣题目的一些思路
全排列（力扣）
lzsan_的博客
09-16 183
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列。你可以 按任意顺序 返回答案。链接：https://leetcode.cn/problems/permutations。著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。输入：nums = [1,2,3]输出：[[0,1],[1,0]]输入：nums = [0,1]输入：nums = [1]
java 力扣算法
weixin_53700782的博客
02-09 1406
public class Solution { public static void main(String[] args) { int nums[] = {5,4,3,2,1}; int res = countKDifference(nums,4); System.out.println(res); } public static int countKDifference(int[] nums, int k) { .
Array格式化
08-13 5724
Array格式化，是一种处理数组值的定位问题的数据处理办法，把源数组的值当做临时数组的下标，把源数组值出现的次数 统计为临时数组的值。 这样做虽然会丢失源数组的顺序，但能突出源数据的一些关键值和他们出现的顺序，还可以避免双层循环。 使用场景 我们有时候会遇到定范围的数组值的数组，比如果char[]或者我们已知数据范围的int[]。我们可是使用Array格式化来处理数据。 理解要点 A...
384. Shuffle an Array【力扣】
xiexie1357的专栏
03-05 190
题意理解 给定接口，设计一个完整类 问题分析 对于随机数的生成设计思路 用到stdlib中的rand函数，应用随机数的地方一般会限制生成范围，可以用rand% num,表示生成0...num-1的随机数。对于排序数的等概率随机生成。参考https://leetcode.com/articles/shuffle-an-array/，用Fisher-Yates algorithm处理。 对于...
【力扣刷题】数组-链表-哈希-双指针
06-21
可以通过指针运算符来访问数组元素，例如cout << &array[0][0] << " " << &array[0][1] << " " << &array[0][2] ;cout << &array[1][0] << " " << &array[1][1] << " " << &array[1][2] ;。 二分查找是一种常用的...
leetcode:力扣刷题记录
05-02
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为提升算法技能和准备技术面试而设计。在这个平台上，用户可以找到各种难度级别的编程题目，涵盖了多种编程语言，包括JavaScript。本文将深入探讨在力扣上...
leetcode跳跃-LeetCode:力扣刷题70道！
06-30
Array 力扣 485 最大连续1的个数 | Max Consecutive One 力扣 283 移动零 | Move Zeroes 力扣 27 移除元素 | Remove Element 链表 Linked List 力扣 203 移除链表元素 | Remove Linked List Elements 力扣 206 反转...
lrucacheleetcode-beihu-leetcode:力扣算法
06-29
Array Stack LinkedList Queue/PriorityQueue(heap) Set/Disjoint Set Map/HashTable Tree/Binary Search Tree/Spanning tree Trie 字母树 BloomFilter LRU Cache 算法 Sorting 排序算法 Graph 图 Hashing 哈希 ...
力扣 102题 二叉树的层次遍历 记录
最新发布
m0_49800270的博客
07-22 272
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
stack(leetcode练习题)
2301_81692739的博客
07-19 390
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
【LeetCode】分隔链表
qq_26521261的博客
07-20 368
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 174
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
力扣刷题：掌握数组、链表、哈希与双指针技巧
在C++中，数组与`std::array`有区别，尽管`std::vector`底层实现可能基于`std::array`，但`vector`作为容器提供了更灵活的操作，如动态扩容和迭代器支持。 **链表**： 链表则是一种动态数据结构，每个节点包含数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值