LeetCode刷题-数组-排序

目录

LeetCode977. 有序数组的平方

一、题目

二、实现方法 

方法一：双指针

三、可直接执行代码块

LeetCode1996. 游戏中弱角色的个数

一、题目

二、实现方法 

方法一：

三、可直接执行代码块 

持续更新...

---

LeetCode977. 有序数组的平方

一、题目

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]

输出：[0,1,9,16,100]

解释：平方后，数组变为 [16,1,0,9,100]

排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]

输出：[4,9,9,49,121]

提示：

1 <= nums.length <= 104

-104 <= nums[i] <= 104

nums 已按 非递减顺序 排序

二、实现方法 

方法一：双指针

因为有时间复杂度的要求，所以只能遍历一次，考虑使用双指针

循环条件的左右指针可以相等，因为会有单数的情况，

如果不能相等的话，就会把中间的元素漏掉

时间复杂度O(n)，空间复杂度O(n)

func sortedSquares(nums []int)(ans []int){
	n:=len(nums)
	i,j:=0,n-1
	index:=n-1
	ans=make([]int,n)
	for i<=j{
		a,b:=nums[i]*nums[i],nums[j]*nums[j]
		if a>b{
			ans[index]=a
			i++
		}else{
			ans[index]=b
			j--
		}
		index--
	}
	return ans
}

三、可直接执行代码块

package main

import "fmt"

func main()  {
	nums:=[]int{-7,-3,2,3,11}
	res:=sortedSquares(nums)
	fmt.Println(res)
}

func sortedSquares(nums []int)(ans []int){
	n:=len(nums)
	i,j:=0,n-1
	index:=n-1
	ans=make([]int,n)
	for i<=j{
		a,b:=nums[i]*nums[i],nums[j]*nums[j]
		if a>b{
			ans[index]=a
			i++
		}else{
			ans[index]=b
			j--
		}
		index--
	}
	return ans
}

---

 

LeetCode1996. 游戏中弱角色的个数

一、题目

你正在参加一个多角色游戏，每个角色都有两个主要属性：攻击 和 防御 。给你一个二维整数数组 properties ，其中 properties[i] = [attacki, defensei] 表示游戏中第 i 个角色的属性。

如果存在一个其他角色的攻击和防御等级 都严格高于 该角色的攻击和防御等级，则认为该角色为 弱角色 。更正式地，如果认为角色 i 弱于 存在的另一个角色 j ，那么 attackj > attacki 且 defensej > defensei 。

返回 弱角色 的数量。

示例 1：

输入：properties = [[5,5],[6,3],[3,6]]

输出：0

解释：不存在攻击和防御都严格高于其他角色的角色。

示例 2：

输入：properties = [[2,2],[3,3]]

输出：1

解释：第一个角色是弱角色，因为第二个角色的攻击和防御严格大于该角色。

示例 3：

输入：properties = [[1,5],[10,4],[4,3]]

输出：1

解释：第三个角色是弱角色，因为第二个角色的攻击和防御严格大于该角色。

二、实现方法 

方法一：排序

根据第一个值排序，再对比第二个值

左右两个值排序规则向反，左边从大到小，右边从小到大，这样只记住最大值就可以了，最大值出现之后 后面的都是需要的数

注意去记小于的

时间复杂度O(nlogn),空间复杂度O(logn)，其中n为数组的长度。排序时使用的栈空间为 O(logn)。

 注意：使用时间复杂度为o(n^2)的排序会超时

func numberOfWeakCharacters(properties [][]int) (ans int) {
	sort.Slice(properties, func(i, j int) bool {
		p, q := properties[i], properties[j]
		return p[0] > q[0] || p[0] == q[0] && p[1] < q[1]
	})
	//sort2(properties)
	maxDef := 0
	for _, p := range properties {
		if p[1] < maxDef {
			ans++
		} else {
			maxDef = p[1]
		}
	}
	return
}

三、可直接执行代码块 

package main

import (
	"fmt"
	"sort"
)

func main()  {
	properties:=[][]int{}
	properties=append(properties, []int{9,4})
	properties=append(properties, []int{8,5})
	properties=append(properties, []int{10,1})
	fmt.Println(properties)
	fmt.Println("---------------")
	//sort2(properties)
	ans:=numberOfWeakCharacters(properties)
	fmt.Println("---------------")
	fmt.Println(ans)
}

func numberOfWeakCharacters(properties [][]int) (ans int) {
	sort.Slice(properties, func(i, j int) bool {
		p, q := properties[i], properties[j]
		return p[0] > q[0] || p[0] == q[0] && p[1] < q[1]
	})
	//sort2(properties)
	maxDef := 0
	for _, p := range properties {
		if p[1] < maxDef {
			ans++
		} else {
			maxDef = p[1]
		}
	}
	return
}
func PrintProperties(properties [][]int){
	for i:=0;i<len(properties);i++{
		fmt.Println(properties[i])
	}
}
func sort2(p [][]int){
	for i:=0;i<=len(p);i++{
		for j:=len(p)-1;j>=1;j--{
			if p[j][0]>p[j-1][0]||p[j][0]==p[j-1][0]&&p[j][1]<p[j-1][1]{
				p[j],p[j-1]=p[j-1],p[j]
			}
		}
	}
	fmt.Println(p)
}

 

---

持续更新...