Golang每日一练(leetDay0028)
Posted Hann Yang
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Golang每日一练(leetDay0028)相关的知识，希望对你有一定的参考价值。
目录
82. 删除排序链表中的重复元素 II Remove-duplicates-from-sorted-list-II 🌟🌟
83. 删除排序链表中的重复元素 Remove-duplicates-from-sorted-list 🌟
84. 柱状图中最大的矩形 Largest-rectangle-in-histogram 🌟🌟🌟
82. 删除排序链表中的重复元素 II Remove-duplicates-from-sorted-list-II
给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。
示例 1：
输入：head = [1,2,3,3,4,4,5] 输出：[1,2,5]
示例 2：
输入：head = [1,1,1,2,3] 输出：[2,3]
提示：
- 链表中节点数目在范围
[0, 300]内 -100 <= Node.val <= 100- 题目数据保证链表已经按升序 排列
代码1：双指针
package main
import (
"fmt"
)
type ListNode struct
Val int
Next *ListNode
func removeDuplicates(head *ListNode) *ListNode
if head == nil || head.Next == nil
return head
dummy := &ListNodeVal: 0, Next: head
pre := dummy
cur := head
for cur != nil
if cur.Next != nil && cur.Val == cur.Next.Val
// 相同节点一直跳过
for cur.Next != nil && cur.Val == cur.Next.Val
cur = cur.Next
pre.Next = cur.Next
else
pre = pre.Next
cur = cur.Next
return dummy.Next
func build(list []int) *ListNode
head := &ListNodeVal: 0
for i := len(list) - 1; i >= 0; i--
p := &ListNodeVal: list[i]
p.Next = head.Next
head.Next = p
return head
func (head *ListNode) travel()
for p := head.Next; p != nil; p = p.Next
fmt.Print(p.Val)
if p.Next != nil
fmt.Print("->")
fmt.Println("<nil>")
func main()
head := build([]int1, 2, 3, 3, 4, 4, 5)
removeDuplicates(head).travel()
head = build([]int1, 1, 1, 2, 3)
removeDuplicates(head).travel()
输出：
1->2->5<nil>
2->3<nil>
代码2：递归法
package main
import (
"fmt"
)
type ListNode struct
Val int
Next *ListNode
func removeDuplicates(head *ListNode) *ListNode
if head == nil || head.Next == nil
return head
if head.Val == head.Next.Val
for head.Next != nil && head.Val == head.Next.Val
head = head.Next
return removeDuplicates(head.Next)
else
head.Next = removeDuplicates(head.Next)
return head
func build(list []int) *ListNode
head := &ListNodeVal: 0
for i := len(list) - 1; i >= 0; i--
p := &ListNodeVal: list[i]
p.Next = head.Next
head.Next = p
return head
func (head *ListNode) travel()
for p := head.Next; p != nil; p = p.Next
fmt.Print(p.Val)
if p.Next != nil
fmt.Print("->")
fmt.Println("<nil>")
func main()
head := build([]int1, 2, 3, 3, 4, 4, 5)
removeDuplicates(head).travel()
head = build([]int1, 1, 1, 2, 3)
removeDuplicates(head).travel()
83. 删除排序链表中的重复元素 Remove-duplicates-from-sorted-list
给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。
示例 1：
输入：head = [1,1,2] 输出：[1,2]
示例 2：
输入：head = [1,1,2,3,3] 输出：[1,2,3]
提示：
- 链表中节点数目在范围
[0, 300]内 -100 <= Node.val <= 100- 题目数据保证链表已经按升序 排列
代码1：双指针
package main
import (
"fmt"
)
type ListNode struct
Val int
Next *ListNode
func deleteDuplicates(head *ListNode) *ListNode
if head == nil || head.Next == nil
return head
pre := head
cur := head.Next
for cur != nil
if pre.Val == cur.Val
pre.Next = cur.Next
else
pre = cur
cur = cur.Next
return head
func build(list []int) *ListNode
head := &ListNodeVal: 0
for i := len(list) - 1; i >= 0; i--
p := &ListNodeVal: list[i]
p.Next = head.Next
head.Next = p
return head
func (head *ListNode) travel()
for p := head.Next; p != nil; p = p.Next
fmt.Print(p.Val)
if p.Next != nil
fmt.Print("->")
fmt.Println("<nil>")
func main()
head := build([]int1, 1, 2)
deleteDuplicates(head).travel()
head = build([]int1, 1, 2, 3, 3)
deleteDuplicates(head).travel()
双指针另一种写法：
func deleteDuplicates(head *ListNode) *ListNode
if head == nil
return nil
cur := head
for cur.Next != nil
if cur.Val == cur.Next.Val
cur.Next = cur.Next.Next
else
cur = cur.Next
return head
输出：
1->2<nil>
1->2->3<nil>
代码2：递归法
递归处理子链表，如果子链表的头节点和下一个节点的值相等，则将头节点的 next 指针指向下一个节点的下一个节点，这样就可以删除重复节点。
package main
import (
"fmt"
)
type ListNode struct
Val int
Next *ListNode
func deleteDuplicates(head *ListNode) *ListNode
if head == nil || head.Next == nil
return head
head.Next = deleteDuplicates(head.Next)
if head.Val == head.Next.Val
return head.Next
return head
func build(list []int) *ListNode
head := &ListNodeVal: 0
for i := len(list) - 1; i >= 0; i--
p := &ListNodeVal: list[i]
p.Next = head.Next
head.Next = p
return head
func (head *ListNode) travel()
for p := head.Next; p != nil; p = p.Next
fmt.Print(p.Val)
if p.Next != nil
fmt.Print("->")
fmt.Println("<nil>")
func main()
head := build([]int1, 1, 2)
deleteDuplicates(head).travel()
head = build([]int1, 1, 2, 3, 3)
deleteDuplicates(head).travel()
84. 柱状图中最大的矩形 Largest-rectangle-in-histogram
给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。
示例 1:
输入：heights = [2,1,5,6,2,3] 输出：10 解释：最大的矩形为图中红色区域，面积为 10
示例 2：
输入： heights = [2,4] 输出： 4
提示：
1 <= heights.length <=10^50 <= heights[i] <= 10^4
代码1： 暴力枚举
package main
import "fmt"
func largestRectangleArea(heights []int) int
n := len(heights)
maxArea := 0
for i := 0; i < n; i++
left, right := i, i
for left >= 0 && heights[left] >= heights[i]
left--
for right < n && heights[right] >= heights[i]
right++
area := heights[i] * (right - left - 1)
if area > maxArea
maxArea = area
return maxArea
func main()
heights := []int2, 1, 5, 6, 2, 3
fmt.Println(largestRectangleArea(heights))
heights = []int2, 4
fmt.Println(largestRectangleArea(heights))
输出：
10
4
代码2： 单调栈
package main
import "fmt"
func largestRectangleArea(heights []int) int
n := len(heights)
stack := make([]int, 0)
maxArea := 0
for i := 0; i <= n; i++
var curHeight int
if i == n
curHeight = 0
else
curHeight = heights[i]
for len(stack) > 0 && curHeight < heights[stack[len(stack)-1]]
h := heights[stack[len(stack)-1]]
stack = stack[:len(stack)-1]
var w int
if len(stack) == 0
w = i
else
w = i - stack[len(stack)-1] - 1
area := h * w
if area > maxArea
maxArea = area
stack = append(stack, i)
return maxArea
func main()
heights := []int2, 1, 5, 6, 2, 3
fmt.Println(largestRectangleArea(heights))
heights = []int2, 4
fmt.Println(largestRectangleArea(heights))
代码3： 分治法
package main
import "fmt"
func largestRectangleArea(heights []int) int
return helper(heights, 0, len(heights)-1)
func helper(heights []int, left, right int) int
if left > right
return 0
minIndex := left
for i := left; i <= right; i++
if heights[i] < heights[minIndex]
minIndex = i
area1 := heights[minIndex] * (right - left + 1)
area2 := helper(heights, left, minIndex-1)
area3 := helper(heights, minIndex+1, right)
return max(area1, max(area2, area3))
func max(a, b int) int
if a > b
return a
return b
func main()
heights := []int2, 1, 5, 6, 2, 3
fmt.Println(largestRectangleArea(heights))
heights = []int2, 4
fmt.Println(largestRectangleArea(heights))
🌟 每日一练刷题专栏 🌟
✨ 持续，努力奋斗做强刷题搬运工！
👍 点赞，你的认可是我坚持的动力！
🌟 收藏，你的青睐是我努力的方向！
✎ 评论，你的意见是我进步的财富！
☸ 主页：https://hannyang.blog.csdn.net/
 | Golang每日一练 专栏 |
 | Python每日一练 专栏 |
 | C/C++每日一练 专栏 |
 | Java每日一练 专栏 |
golang每日一练 第三天
golang 的fmt 包实现了格式化I/O函数，类似于C的 printf 和 scanf。
# 定义示例类型和变量
type Human struct {
Name string
}
var people = Human{Name:"zhangsan"}
普通占位符
占位符 说明 举例 输出
%v 相应值的默认格式。 Printf("%v", people) {zhangsan}，
%+v 打印结构体时，会添加字段名 Printf("%+v", people) {Name:zhangsan}
%#v 相应值的Go语法表示 Printf("#v", people) main.Human{Name:"zhangsan"}
%T 相应值的类型的Go语法表示 Printf("%T", people) main.Human
%% 字面上的百分号，并非值的占位符 Printf("%%") %
布尔占位符
占位符 说明 举例 输出
%t true 或 false。 Printf("%t", true) true
整数占位符
占位符 说明 举例 输出
%b 二进制表示 Printf("%b", 5) 101
%c 相应Unicode码点所表示的字符 Printf("%c", 0x4E2D) 中
%d 十进制表示 Printf("%d", 0x12) 18
%o 八进制表示 Printf("%d", 10) 12
%q 单引号围绕的字符字面值，由Go语法安全地转义 Printf("%q", 0x4E2D) ‘中‘
%x 十六进制表示，字母形式为小写 a-f Printf("%x", 13) d
%X 十六进制表示，字母形式为大写 A-F Printf("%x", 13) D
%U Unicode格式：U+1234，等同于 "U+%04X" Printf("%U", 0x4E2D) U+4E2D
浮点数和复数的组成部分（实部和虚部）
占位符 说明 举例 输出
%b 无小数部分的，指数为二的幂的科学计数法，
与 strconv.FormatFloat 的 ‘b‘ 转换格式一致。例如 -123456p-78
%e 科学计数法，例如 -1234.456e+78 Printf("%e", 10.2) 1.020000e+01
%E 科学计数法，例如 -1234.456E+78 Printf("%e", 10.2) 1.020000E+01
%f 有小数点而无指数，例如 123.456 Printf("%f", 10.2) 10.200000
%g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%g", 10.20) 10.2
%G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%G", 10.20+2i) (10.2+2i)
字符串与字节切片
占位符 说明 举例 输出
%s 输出字符串表示（string类型或[]byte) Printf("%s", []byte("Go语言")) Go语言
%q 双引号围绕的字符串，由Go语法安全地转义 Printf("%q", "Go语言") "Go语言"
%x 十六进制，小写字母，每字节两个字符 Printf("%x", "golang") 676f6c616e67
%X 十六进制，大写字母，每字节两个字符 Printf("%X", "golang") 676F6C616E67
指针
占位符 说明 举例 输出
%p 十六进制表示，前缀 0x Printf("%p", &people) 0x4f57f0
其它标记
占位符 说明 举例 输出
+ 总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。
Printf("%+q", "中文") "\u4e2d\u6587"
- 在右侧而非左侧填充空格（左对齐该区域）
# 备用格式：为八进制添加前导 0（%#o） Printf("%#U", ‘中‘) U+4E2D
为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；
如果可能的话，%q（%#q）会打印原始 （即反引号围绕的）字符串；
如果是可打印字符，%U（%#U）会写出该字符的
Unicode 编码形式（如字符 x 会被打印成 U+0078 ‘x‘）。
‘ ‘ (空格)为数值中省略的正负号留出空白（% d）；
以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开
0 填充前导的0而非空格；对于数字，这会将填充移到正负号之后
golang没有 ‘%u‘ 点位符，若整数为无符号类型，默认就会被打印成无符号的。
宽度与精度的控制格式以Unicode码点为单位。宽度为该数值占用区域的最小宽度；精度为小数点之后的位数。
操作数的类型为int时，宽度与精度都可用字符 ‘*‘ 表示。
对于 %g/%G 而言，精度为所有数字的总数，例如：123.45，%.4g 会打印123.5，（而 %6.2f 会打印123.45）。
%e 和 %f 的默认精度为6
对大多数的数值类型而言，宽度为输出的最小字符数，如果必要的话会为已格式化的形式填充空格。
而以字符串类型，精度为输出的最大字符数，如果必要的话会直接截断。
以上是关于Golang每日一练(leetDay0028)的主要内容，如果未能解决你的问题，请参考以下文章