力扣刷题 | 数组专题

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

MH梦回

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

阅读量386

点赞数

分类专栏：刷题打卡文章标签： golang 数据结构算法

本文链接：https://blog.youkuaiyun.com/weixin_45904051/article/details/123515690

版权

刷题打卡专栏收录该内容

4 篇文章

订阅专栏

本文介绍了如何通过双指针法调整数组顺序使奇数在偶数前，实现两数之和问题的高效搜索，探讨了扑克牌顺子的判断规则，以及数组中找到第K大元素的两种常见算法——快速排序和堆排序。同时涵盖了有效字母异位词的检查技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

各自努力，最高处见！加油！

一、调整数组顺序使奇数位于偶数前面

在这里插入图片描述

func exchange(nums []int) []int {
    length:=len(nums)
    // array:=make([]int,length)
    var odd,even int=0,length-1

    for odd<even{
        if nums[odd]&1==0{//偶数
            if nums[even]&1!=0{
                temp:=nums[odd]
                nums[odd]=nums[even]
                nums[even]=temp
            }else{
                even--
            }
        }else{
            odd++
        }
    }
    return nums

}

双指针操作数组，一个从头到尾遍历，遇到偶数就与末尾的奇数进行交换。

二、和为s的两个数字

在这里插入图片描述

func twoSum(nums []int, target int) []int {
    
    
    headPtr,endPtr:=0,len(nums)-1

    for headPtr!=endPtr{
        if target-nums[endPtr]<nums[headPtr]{
            endPtr--
        }else if target-nums[endPtr]>nums[headPtr]{
            headPtr++
        }else{
            returnArray:=make([]int,2)
            returnArray[0]=nums[headPtr]
            returnArray[1]=nums[endPtr]
            return returnArray
        }
    }
    return nil

}

向大佬学习：

判断条件最好不要用相加后的结果，应该用target - nums[i] 跟 nums[j]比较，这样保证不会溢出。虽然这题中不会出错。同样的例子还有二分查找，(left + right) / 2 可以用left +((rigth - left) >> 1))代替

三、扑克牌中的顺子

在这里插入图片描述

func isStraight(nums []int) bool {
	//数组中的最大值-最小值<5（这里的最小值是不包括0的最小值）

    min:=13//除0外的最小值
    max:=0
    count:=0
    temp:=make(map[int]int)
    for i:=0;i<5;i++ {
        if nums[i]==0{
            count++
            continue
        }
        if _,ok:=temp[nums[i]];ok{
            return false
        }else{
            temp[nums[i]]=0
        }
        if nums[i]<min{
            min=nums[i]
        }
        if nums[i]>max{
            max=nums[i]
        }
    }
    if max-min<5{
        return true
    }
    return false

}

四、数组中的第K个最大元素

在这里插入图片描述

方法一：快速排序

//排序，输出第k个元素
func findKthLargest(nums []int, k int) int {
    quickSort(nums,0,len(nums)-1)

    return nums[len(nums)-k]
}

func quickSort(nums []int, start int, end int) {
	if start > end {
		return
	}

	pivot := partition(nums, start, end)
	
	quickSort(nums,start,pivot-1)
	
	quickSort(nums,pivot+1,end)

}

func partition(nums []int, start int, end int) int {
	index := start
	pivot := nums[start] //基准变量
	left := start
	right := end

	for left < right {
		for left < right { //左指针处于一个坑中，需要从右边找一个小于pivot的数来填补
			if nums[right] < pivot {
				nums[left] = nums[right]
				index = right
                left++
				break //交换完成后退出循环，右边指针的位置变成一个新的坑等待填补
			} else {
				right--
			}
		}

		for left < right {
			if nums[left] > pivot {
				nums[right] = nums[left]
				index = left
                right--
				break //交换完成后退出循环，左边边指针的位置变成一个新的坑等待填补
			}else {
				left++
			}
		}
	}
	nums[index] = pivot
	return index

}

方法二：堆排序

五、螺旋矩阵 II

在这里插入图片描述

代码随想录解题思路

func generateMatrix(n int) [][]int {
	loop := n / 2 //循环的圈数
	start_x := 0  //行起始位置
	start_y := 0  //列起始位置
	num := 1
	LineOffset := 1
	ColumnOffset := 1

	i := start_y
	j := start_x

	result := make([][]int, 0)
	for i := 0; i < n; i++ { //构造一个n*n的二维数组
		temp := make([]int, n)
		result = append(result, temp)
	}

	for loop > 0 {
		for j = start_y; j <= n-LineOffset-1; j++ { //从左到右
			result[start_x][j] = num //这里为什么用start_x不用i：因为i在上一次循环的时候，都会回到原来的起点，而不是下一个圈的起点
			num++
		}
		for i = start_x; i <= n-ColumnOffset-1; i++ { //上到下
			result[i][j] = num
			num++
		}
		for ; j >= start_y+1; j-- { //从右往左
			result[i][j] = num
			num++
		}
		for ; i >= start_x+1; i-- { //从下往上
			result[i][j] = num
			num++
		}
		loop--
		start_y++
		start_x++
		LineOffset += 1
		ColumnOffset += 1

	}
	if n%2 != 0 {
		result[n/2][n/2] = num
	}
	return result
}

六、有效的字母异位词

在这里插入图片描述

我的解答：

func isAnagram(s string, t string) bool {
    mapStr:=make(map[byte]int)
    for i:=0;i<len(s);i++{
        if _,ok:=mapStr[s[i]];ok{
            mapStr[s[i]]++
        }else{
            mapStr[s[i]]=1
        }
    }
    for i:=0;i<len(t);i++{
        if _,ok:=mapStr[t[i]];ok{
            mapStr[t[i]]--
            if mapStr[t[i]]==0{
                delete(mapStr,t[i])
            }
        }else{
            return false
        }
    }
    if len(mapStr)==0{
        return true
    }
    return false
}

很简单的一道题，不过我就是想不出有什么简便的方法，我自己用的是暴力的解法，看到代码随想录里收录了一个解法，很巧妙，特此记录一下。用一个空数组和操作的数组来进行比较。但是要注意的一个点是：在开始初始化的时候不能把record声明为切片，虽然在go中的切片和数组在使用上很相似，但是在底层的实现不一样，这两个不是相同的类型。这一点对于老同志更需注意，基础的东西还是不能放。

func isAnagram(s string, t string) bool {
    record := [26]int{}
    for _, r := range s {
        record[r-rune('a')]++
    }
    for _, r := range t {
        record[r-rune('a')]--
    }

    return record == [26]int{}
}