Golang每日一练(leetDay0050)

news2024/11/28 6:40:29

目录

147. 对链表进行插入排序 Insertion Sort List  🌟🌟

148. 排序链表 Sort List  🌟🌟

149. 直线上最多的点数 Max Points On A Line  🌟🌟🌟

150. 逆波兰表达式求值 Evaluate Reverse Polish Notation  🌟🌟

🌟 每日一练刷题专栏 🌟

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

147. 对链表进行插入排序 Insertion Sort List

给定单个链表的头 head ，使用 插入排序 对链表进行排序，并返回 排序后链表的头 。

插入排序 算法的步骤:

  1. 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
  2. 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
  3. 重复直到所有输入数据插入完为止。

下面是插入排序算法的一个图形示例。部分排序的列表(黑色)最初只包含列表中的第一个元素。每次迭代时，从输入数据中删除一个元素(红色)，并就地插入已排序的列表中。

对链表进行插入排序。

示例 1：

输入: head = [4,2,1,3]
输出: [1,2,3,4]

示例 2：

输入: head = [-1,5,3,4,0]
输出: [-1,0,3,4,5]

提示：

  • 列表中的节点数在 [1, 5000]范围内
  • -5000 <= Node.val <= 5000

代码： 插入排序

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func build(list []int) *ListNode {
	head := &ListNode{Val: -1 << 31} //-5000 <= Node.val <= 5000
	for i := len(list) - 1; i >= 0; i-- {
		p := &ListNode{Val: 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 insertionSortList(head *ListNode) *ListNode {
	if head == nil || head.Next == nil {
		return head
	}
	dummy := &ListNode{}
	dummy.Next = head
	cur := head.Next
	lastSorted := head
	for cur != nil {
		if cur.Val >= lastSorted.Val {
			lastSorted = lastSorted.Next
		} else {
			prev := dummy
			for prev.Next.Val < cur.Val {
				prev = prev.Next
			}
			lastSorted.Next = cur.Next
			cur.Next = prev.Next
			prev.Next = cur
		}
		cur = lastSorted.Next
	}
	return dummy.Next
}

func main() {
	nums := []int{4, 2, 1, 3}
	head := build(nums)
	head.travel()
	head = insertionSortList(head)
	head.travel()
	nums2 := []int{-1, 5, 3, 4, 0}
	head2 := build(nums2)
	head2.travel()
	head2 = insertionSortList(head2)
	head2.travel()
}

输出：

4->2->1->3<nil>
1->2->3->4<nil>
-1->5->3->4->0<nil>
-1->0->3->4->5<nil>

148. 排序链表 Sort List

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

示例 1：

输入：head = [4,2,1,3]
输出：[1,2,3,4]

示例 2：

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]

示例 3：

输入：head = []
输出：[] 

提示：

  • 链表中节点的数目在范围 [0, 5 * 10^4] 内
  • -10^5 <= Node.val <= 10^5

进阶：你可以在 O(nlogn) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

代码： 归并排序，与147题对比多了对时间和空间复杂度的要求

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func build(list []int) *ListNode {
	head := &ListNode{Val: -1 << 31} //-5000 <= Node.val <= 5000
	for i := len(list) - 1; i >= 0; i-- {
		p := &ListNode{Val: 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 sortList(head *ListNode) *ListNode {
	if head == nil || head.Next == nil {
		return head
	}
	slow, fast := head, head.Next
	for fast != nil && fast.Next != nil {
		slow = slow.Next
		fast = fast.Next.Next
	}
	mid := slow.Next
	slow.Next = nil
	left := sortList(head)
	right := sortList(mid)
	return merge(left, right)
}

func merge(a, b *ListNode) *ListNode {
	dummy := &ListNode{}
	cur := dummy
	for a != nil && b != nil {
		if a.Val < b.Val {
			cur.Next = a
			a = a.Next
		} else {
			cur.Next = b
			b = b.Next
		}
		cur = cur.Next
	}
	if a != nil {
		cur.Next = a
	} else {
		cur.Next = b
	}
	return dummy.Next
}

func main() {
	nums := []int{4, 2, 1, 3}
	head := build(nums)
	head.travel()
	head = sortList(head)
	head.travel()
	nums2 := []int{-1, 5, 3, 4, 0}
	head2 := build(nums2)
	head2.travel()
	head2 = sortList(head2)
	head2.travel()
}

输出：

4->2->1->3<nil>
1->2->3->4<nil>
-1->5->3->4->0<nil>
-1->0->3->4->5<nil>

149. 直线上最多的点数 Max Points On A Line

给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。

示例 1：

输入：points = [[1,1],[2,2],[3,3]]
输出：3

示例 2：

输入：points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出：4

提示：

  • 1 <= points.length <= 300
  • points[i].length == 2
  • -10^4 <= xi, yi <= 10^4
  • points 中的所有点 互不相同

代码1： 暴力枚举

package main

import (
	"fmt"
)

func maxPoints(points [][]int) int {
	if len(points) < 3 {
		return len(points)
	}
	ans := 0
	for i := 0; i < len(points); i++ {
		kMap := make(map[Fraction]int)
		same := 1
		for j := i + 1; j < len(points); j++ {
			dx, dy := points[i][0]-points[j][0], points[i][1]-points[j][1]
			if dx == 0 && dy == 0 {
				same++
				continue
			}
			gcd := GCD(dx, dy)
			f := Fraction{
				Numerator:   dy / gcd,
				Denominator: dx / gcd,
			}
			kMap[f]++
		}
		maxCnt := 0
		for _, cnt := range kMap {
			if cnt > maxCnt {
				maxCnt = cnt
			}
		}
		ans = max(ans, maxCnt+same)
	}
	return ans
}

type Fraction struct {
	Numerator   int
	Denominator int
}

func GCD(a, b int) int {
	if b == 0 {
		return a
	}
	return GCD(b, a%b)
}

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

func main() {
	points := [][]int{{1, 1}, {2, 2}, {3, 3}}
	fmt.Println(maxPoints(points))
	points = [][]int{{1, 1}, {3, 2}, {5, 3}, {4, 1}, {2, 3}, {1, 4}}
	fmt.Println(maxPoints(points))
}

 代码2： 哈希表

package main

import (
	"fmt"
)

func maxPoints(points [][]int) int {
	if len(points) < 2 {
		return len(points)
	}
	ans := 1
	for i, p := range points {
		if ans >= len(points)-i {
			break
		}
		cnt := map[fraction]int{}
		for _, q := range points[i+1:] {
			k := newFraction(p, q)
			cnt[*k]++
		}
		for _, c := range cnt {
			ans = max(ans, c+1)
		}
	}
	return ans
}

type fraction struct {
	dx, dy int
}

func newFraction(p, q []int) *fraction {
	dx, dy := p[1]-q[1], p[0]-q[0]
	if dx == 0 {
		dy = 1
	} else if dy == 0 {
		dx = 1
	} else if dy < 0 {
		dx, dy = -dx, -dy
	}
	g := gcd(abs(dx), abs(dy))
	return &fraction{dx / g, dy / g}
}

func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

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

func main() {
	points := [][]int{{1, 1}, {2, 2}, {3, 3}}
	fmt.Println(maxPoints(points))
	points = [][]int{{1, 1}, {3, 2}, {5, 3}, {4, 1}, {2, 3}, {1, 4}}
	fmt.Println(maxPoints(points))
}

输出：

3
4

150. 逆波兰表达式求值 Evaluate Reverse Polish Notation

根据 逆波兰表示法，求表达式的值。 ​

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

  • 1 <= tokens.length <= 10^4
  • tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

  • 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
  • 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

  • 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
  • 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

代码1： 栈 stack

package main

import (
	"fmt"
	"strconv"
)

func evalRPN(tokens []string) int {
	stack := make([]int, 0)
	for _, t := range tokens {
		if t == "+" {
			a, b := stack[len(stack)-2], stack[len(stack)-1]
			stack = stack[:len(stack)-2]
			stack = append(stack, a+b)
		} else if t == "-" {
			a, b := stack[len(stack)-2], stack[len(stack)-1]
			stack = stack[:len(stack)-2]
			stack = append(stack, a-b)
		} else if t == "*" {
			a, b := stack[len(stack)-2], stack[len(stack)-1]
			stack = stack[:len(stack)-2]
			stack = append(stack, a*b)
		} else if t == "/" {
			a, b := stack[len(stack)-2], stack[len(stack)-1]
			stack = stack[:len(stack)-2]
			stack = append(stack, a/b)
		} else {
			num, _ := strconv.Atoi(t)
			stack = append(stack, num)
		}
	}
	return stack[0]
}

func main() {
	tokens := []string{"2", "1", "+", "3", "*"}
	fmt.Println(evalRPN(tokens))
	tokens = []string{"4", "13", "5", "/", "+"}
	fmt.Println(evalRPN(tokens))
	tokens = []string{"10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"}
	fmt.Println(evalRPN(tokens))
}

代码2： DFS 递归

package main

import (
	"fmt"
	"strconv"
)

func evalRPN(tokens []string) int {
	var dfs func() int
	dfs = func() int {
		if len(tokens) == 0 {
			return 0
		}
		op := tokens[len(tokens)-1]
		tokens = tokens[:len(tokens)-1]
		if op == "+" {
			return dfs() + dfs()
		} else if op == "-" {
			a, b := dfs(), dfs()
			return b - a
		} else if op == "*" {
			return dfs() * dfs()
		} else if op == "/" {
			a, b := dfs(), dfs()
			return b / a
		} else {
			num, _ := strconv.Atoi(op)
			return num
		}
	}
	return dfs()
}

func main() {
	tokens := []string{"2", "1", "+", "3", "*"}
	fmt.Println(evalRPN(tokens))
	tokens = []string{"4", "13", "5", "/", "+"}
	fmt.Println(evalRPN(tokens))
	tokens = []string{"10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"}
	fmt.Println(evalRPN(tokens))
}

输出：

9
6
22 

🌟 每日一练刷题专栏 🌟

✨ 持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！ 

🌟 收藏，你的青睐是我努力的方向！ 

✎ 评论，你的意见是我进步的财富！  

☸ 主页：https://hannyang.blog.csdn.net/ 

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/474554.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

DDS基本原理与FPGA实现

DDS基本原理与FPGA实现

DDS基本原理与FPGA实现 定义&#xff1a;DDS是指DDS信号发生器&#xff0c;采用直接数字频率合成技术。是一种新型的频率合成技术&#xff0c;具有相对带宽大&#xff0c;频率转换时间短、分辨率高和相位连续性好等优点。较容易实现频率、相位以及幅度的数控调制&#xff0c;广…
阅读更多...
服务运营｜ Healthcare Management Science 近期文章精选

服务运营｜ Healthcare Management Science 近期文章精选

作者&#xff1a;李舒湉 王畅 &#xff08;一&#xff09; Screening for preclinical Alzheimer’s disease: Deriving optimal policies using a partially observable Markov model nen Dumlu Z, Sayın S, Grvit İ H. Screening for preclinical Alzheimer’s disease: …
阅读更多...
UG NX二次开发(C#)-显示-更改对象颜色

UG NX二次开发(C#)-显示-更改对象颜色

文章目录 1、前言2、UG NX中的更换对象颜色的功能3、采用UG NX二次开发实现颜色修改3.1 采用直接赋值对象颜色不能直接更改对象颜色3.2 采用NewDisplayModification的方法如下：1、前言 当一个三维模型展现在我们面前时，总会有颜色赋予三维模型的对象上，比如红色、蓝色、银灰…
阅读更多...
工具链与其他-移动端网络优化的指标和策略

工具链与其他-移动端网络优化的指标和策略

目录 网络指标 一个请求的时间消耗 页面加载 常见性能指标 网络优化策略 缓存 压缩 请求合并 离线包 预加载&#xff08;前端大流量数据&#xff09; 网络指标 一个请求的时间消耗 一个请求的发生到返回回来&#xff1b;有3部分时间 1.Scheduling&#xff08;排队&…
阅读更多...
初识C++之异常

初识C++之异常

目录 一、C中的常用处理错误方式 二、C异常的概念 1. throw 2. catch 3. try 三、异常的使用 1. 异常的抛出和捕获 1.1 异常的抛出和匹配原则 1.2 在函数调用链中异常栈展开匹配原则 四、异常体系 1. 自定义异常体系 2. C中的异常体系 五、 异常安全 六、异常规范…
阅读更多...
Unity 热更新基础HybridCLR：Windows平台使用（HybridCLR手记二）

Unity 热更新基础HybridCLR：Windows平台使用（HybridCLR手记二）

项目是根据官网的示例工程进行修改的,版本参数如下&#xff1a; unity&#xff1a;2021.2.20 wolong&#xff1a;v2.1.0 il2cpp_plus:v2021_2.1.0 ------------------------------------------------------------- 1、安装&#xff1a;参考&#xff1a;第一篇文章Unity 热…
阅读更多...
pytest - Getting Start

pytest - Getting Start

前言 项目开发中有很多的功能&#xff0c;通常开发人员需要对自己编写的代码进行自测&#xff0c;除了借助postman等工具进行测试外&#xff0c;还需要编写单元测试对开发的代码进行测试&#xff0c;通过单元测试来判断代码是否能够实现需求&#xff0c;本文介绍的pytest模块是…
阅读更多...
虚幻图文笔记：Substance Painter通过USD格式导入UE5的工作流

虚幻图文笔记：Substance Painter通过USD格式导入UE5的工作流

什么是USD格式 USD即Universal Scene Description&#xff0c;是著名的Pixar公司研发的一种开源的3D 场景说明和文件格式&#xff0c;如其名所示&#xff0c;相较于传统的FBX、Obj等3D格式&#xff0c;USD的具有更好的通用性和扩展性&#xff0c;现在已被非常多的厂商和平台所…
阅读更多...
使用树莓派（zero2w + Camera Module 3 支持自动对焦 1200 万像素）拍照

使用树莓派（zero2w + Camera Module 3 支持自动对焦 1200 万像素）拍照

拍照硬件 Raspberry Pi Camera Module 3Raspberry Pi Zero 2 W 1. 注意排线连接方向 2. 烧录系统 3. 进行系统更新需要联网&#xff0c;注意只支持最新的bullseye系统。每条指令大概需要10 分钟。 sudo apt-get update -y sudo apt-get upgrade -y4. 拍摄一张全像素的JPEG图像…
阅读更多...
自己做小程序开个社区团购可行吗？

自己做小程序开个社区团购可行吗？

在如今的社交化时代&#xff0c;随着社区经济的发展&#xff0c;越来越多的人开始探索社区团购的商业模式。而随着小程序的普及&#xff0c;自己开发一个社区团购小程序也成为了一种可能。但是&#xff0c;自己做小程序开个社区团购真的可行吗&#xff1f;我们来一起分析一下。…
阅读更多...
Spring整合MybatisJunit单元测试

Spring整合MybatisJunit单元测试

Spring整合Mybatis&Junit单元测试 1. Spring整合Mybatis【重点】1.1 思路分析问题导入1.1.1 MyBatis程序核心对象分析1.1.2 整合MyBatis 1.2 代码实现【前置工作】【第一步】导入Spring整合Mybatis依赖【第二步】创建JdbcConfig配置DataSource数据源【第三步】创建MybatisC…
阅读更多...
【ARMv8 编程】A64 内存访问指令——内存加载指令

【ARMv8 编程】A64 内存访问指令——内存加载指令

与所有先前的 ARM 处理器一样&#xff0c;ARMv8 架构是一种加载/存储架构。这意味着没有数据处理指令直接对内存中的数据进行操作。数据必须首先被加载到寄存器中&#xff0c;修改&#xff0c;然后存储到内存中。该程序必须指定地址、要传输的数据大小以及源或目标寄存器。有额…
阅读更多...
《使用深度神经网络对光电容积脉搏图进行归一化，以进行个体和群体比较》阅读笔记

《使用深度神经网络对光电容积脉搏图进行归一化，以进行个体和群体比较》阅读笔记

目录 一、论文摘要 二、论文十问 Q1&#xff1a;论文试图解决什么问题&#xff1f; Q2&#xff1a;这是否是一个新的问题&#xff1f; Q3&#xff1a;这篇文章要验证一个什么科学假设&#xff1f; Q4&#xff1a;有哪些相关研究&#xff1f;如何归类&#xff1f;谁是这一…
阅读更多...
symfonos 1（smtp注入webshell，配合文件文件包含）

symfonos 1（smtp注入webshell，配合文件文件包含）

目录 扫描 SMB 提权 扫描 SMB 让我们使用SMBMAP检查这些目录的权限。 smbmap -d workgroup -H www.example.com 可能/匿名帐户可访问。 使用smb尝试连接共享网络以访问/anonymous目录。[smb：//192.168.59。129/]
阅读更多...
ETL工具 - Kettle 介绍及基本使用

ETL工具 - Kettle 介绍及基本使用

一、Kettle 介绍 在介绍 Kettle 前先了解下什么是 ETL&#xff0c;ETL是 Extract-Transform-Load 的缩写&#xff0c;即数据 抽取、转换、装载 的过程&#xff0c;对于企业或行业应用来说&#xff0c;经常会遇到各种异构数据的处理、转换、迁移等操作&#xff0c;这些操作有可…
阅读更多...
java+mysql医院住院挂号缴费病房信息管理系统

java+mysql医院住院挂号缴费病房信息管理系统

手续办理&#xff1a;办理病人入院登记&#xff1b;提供病案首页建立与打印&#xff1b;交纳预交金及日结管理&#xff0c;并打印收据凭证&#xff1b;空床查询与统计&#xff1b;查询患者的住院信息&#xff1b;打印清单&#xff1b;出入院统计。 护士工作站&#xff1a;提供病…
阅读更多...
Java每日一练(20230429)

Java每日一练(20230429)

目录 1. 二叉树的后序遍历 &#x1f31f;&#x1f31f; 2. 删除无效的括号 &#x1f31f;&#x1f31f;&#x1f31f; 3. 合并两个有序链表 &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每…
阅读更多...
【Java笔试强训 1】

【Java笔试强训 1】

&#x1f389;&#x1f389;&#x1f389;点进来你就是我的人了博主主页&#xff1a;&#x1f648;&#x1f648;&#x1f648;戳一戳,欢迎大佬指点! 欢迎志同道合的朋友一起加油喔&#x1f9be;&#x1f9be;&#x1f9be; 目录 一、选择题 二、编程题 &#x1f525;组队竞…
阅读更多...
基于虚拟同步发电机的光伏混合储能并网系统MATLAB仿真

基于虚拟同步发电机的光伏混合储能并网系统MATLAB仿真

资源地址&#xff1a; 主要模块&#xff1a; 光伏电池模型&#xff08;按照数学模型搭建&#xff09;、蓄电池储能模块、超级电容储能模块、双向DC/DC模块、LC滤波器、逆变器VSG控制模块电压电流双环控制模块、光伏MPPT控制模块、储能系统充放电控制模块。 使用MATLAB2021b及…
阅读更多...
2023/04/24 ~ 25 刷题记录

2023/04/24 ~ 25 刷题记录

A - Sort the Subarray 大致题义&#xff1a;Monocarp有一个包含n个整数的数组a。他决定选择两个整数l和r&#xff0c;使1< 2rn&#xff0c;然后对子数组进行排序。子数组a[1 ..]R]是数组a中包含元素a1, al1, al2&#xff0c;…的部分。&#xff0c; ar-1, ar)按非降序排列。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023