algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-11 04:54:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'youngyangyang04:master' into master

Browse Source
This commit is contained in:
yqq
2021-06-15 17:31:39 +08:00
parent 06406b97a7 7ba51f0323
commit e96e924464
12 changed files with 498 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
problems/0106.从中序与后序遍历序列构造二叉树.md
View File

@ -693,6 +693,70 @@ class Solution:
return root
```
Go：
> 106 从中序与后序遍历序列构造二叉树
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func buildTree(inorder []int, postorder []int) *TreeNode {
if len(inorder)<1||len(postorder)<1{return nil}
//先找到根节点（后续遍历的最后一个就是根节点）
nodeValue:=postorder[len(postorder)-1]
//从中序遍历中找到一分为二的点，左边为左子树，右边为右子树
left:=findRootIndex(inorder,nodeValue)
//构造root
root:=&TreeNode{Val: nodeValue,
Left: buildTree(inorder[:left],postorder[:left]),//将后续遍历一分为二，左边为左子树，右边为右子树
Right: buildTree(inorder[left+1:],postorder[left:len(postorder)-1])}
return root
}
func findRootIndex(inorder []int,target int) (index int){
for i:=0;i<len(inorder);i++{
if target==inorder[i]{
return i
}
}
return -1
}
```
> 105 从前序与中序遍历序列构造二叉树
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func buildTree(preorder []int, inorder []int) *TreeNode {
if len(preorder)<1||len(inorder)<1{return nil}
left:=findRootIndex(preorder[0],inorder)
root:=&TreeNode{
Val: preorder[0],
Left: buildTree(preorder[1:left+1],inorder[:left]),
Right: buildTree(preorder[left+1:],inorder[left+1:])}
return root
}
func findRootIndex(target int,inorder []int) int{
for i:=0;i<len(inorder);i++{
if target==inorder[i]{
return i
}
}
return -1
}
```
JavaScript

21
problems/0115.不同的子序列.md
View File

@ -145,7 +145,28 @@ public:
Java：
```java
class Solution {
public int numDistinct(String s, String t) {
int[][] dp = new int[s.length() + 1][t.length() + 1];
for (int i = 0; i < s.length() + 1; i++) {
dp[i][0] = 1;
}
for (int i = 1; i < s.length() + 1; i++) {
for (int j = 1; j < t.length() + 1; j++) {
if (s.charAt(i - 1) == t.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
}else{
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[s.length()][t.length()];
}
}
```
Python：
```python

20
problems/0242.有效的字母异位词.md
View File

@ -130,7 +130,27 @@ class Solution:
return True
```
Python写法二（没有使用数组作为哈希表，只是介绍defaultdict这样一种解题思路）：
```python
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
from collections import defaultdict
s_dict = defaultdict(int)
t_dict = defaultdict(int)
for x in s:
s_dict[x] += 1
for x in t:
t_dict[x] += 1
return s_dict == t_dict
```
Go：
```go
func isAnagram(s string, t string) bool {
if len(s)!=len(t){

31
problems/0530.二叉搜索树的最小绝对差.md
View File

@ -224,8 +224,37 @@ class Solution:
return r
```
Go：
> 中序遍历，然后计算最小差值
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func getMinimumDifference(root *TreeNode) int {
var res []int
findMIn(root,&res)
min:=1000000//一个比较大的值
for i:=1;i<len(res);i++{
tempValue:=res[i]-res[i-1]
if tempValue<min{
min=tempValue
}
}
return min
}
//中序遍历
func findMIn(root *TreeNode,res *[]int){
if root==nil{return}
findMIn(root.Left,res)
*res=append(*res,root.Val)
findMIn(root.Right,res)
}
```
-----------------------

22
problems/0583.两个字符串的删除操作.md
View File

@ -104,6 +104,28 @@ public:
Java：
```java
class Solution {
public int minDistance(String word1, String word2) {
int[][] dp = new int[word1.length() + 1][word2.length() + 1];
for (int i = 0; i < word1.length() + 1; i++) dp[i][0] = i;
for (int j = 0; j < word2.length() + 1; j++) dp[0][j] = j;
for (int i = 1; i < word1.length() + 1; i++) {
for (int j = 1; j < word2.length() + 1; j++) {
if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1];
}else{
dp[i][j] = Math.min(dp[i - 1][j - 1] + 2,
Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
}
}
}
return dp[word1.length()][word2.length()];
}
}
```
Python：

37
problems/0617.合并二叉树.md
View File

@ -332,6 +332,43 @@ class Solution:
Go：
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
//前序遍历（递归遍历，跟105 106差不多的思路）
func mergeTrees(t1 *TreeNode, t2 *TreeNode) *TreeNode {
var value int
var nullNode *TreeNode//空node，便于遍历
nullNode=&TreeNode{
Val:0,
Left:nil,
Right:nil}
switch {
case t1==nil&&t2==nil: return nil//终止条件
default : //如果其中一个节点为空，则将该节点置为nullNode，方便下次遍历
if t1==nil{
value=t2.Val
t1=nullNode
}else if t2==nil{
value=t1.Val
t2=nullNode
}else {
value=t1.Val+t2.Val
}
}
root:=&TreeNode{//构造新的二叉树
Val: value,
Left: mergeTrees(t1.Left,t2.Left),
Right: mergeTrees(t1.Right,t2.Right)}
return root
}
```

33
problems/0654.最大二叉树.md
View File

@ -278,6 +278,39 @@ class Solution:
Go：
> 654. 最大二叉树
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func constructMaximumBinaryTree(nums []int) *TreeNode {
if len(nums)<1{return nil}
//首选找到最大值
index:=findMax(nums)
//其次构造二叉树
root:=&TreeNode{
Val: nums[index],
Left:constructMaximumBinaryTree(nums[:index]),//左半边
Right:constructMaximumBinaryTree(nums[index+1:]),//右半边
}
return root
}
func findMax(nums []int) (index int){
for i:=0;i<len(nums);i++{
if nums[i]>nums[index]{
index=i
}
}
return
}
```

50
problems/0700.二叉搜索树中的搜索.md
View File

@ -241,6 +241,56 @@ class Solution:
Go：
> 递归法
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
//递归法
func searchBST(root *TreeNode, val int) *TreeNode {
if root==nil||root.Val==val{
return root
}
if root.Val>val{
return searchBST(root.Left,val)
}
return searchBST(root.Right,val)
}
```
> 迭代法
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
//迭代法
func searchBST(root *TreeNode, val int) *TreeNode {
for root!=nil{
if root.Val>val{
root=root.Left
}else if root.Val<val{
root=root.Right
}else{
break
}
}
return root
}
```

101
problems/0707.设计链表.md
View File

@ -158,6 +158,7 @@ private:
Java：
```Java
//单链表
class ListNode {
int val;
ListNode next;
@ -236,6 +237,106 @@ class MyLinkedList {
pred.next = pred.next.next;
}
}
//双链表
class MyLinkedList {
class ListNode {
int val;
ListNode next,prev;
ListNode(int x) {val = x;}
}
int size;
ListNode head,tail;//Sentinel node
/** Initialize your data structure here. */
public MyLinkedList() {
size = 0;
head = new ListNode(0);
tail = new ListNode(0);
head.next = tail;
tail.prev = head;
}
/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
public int get(int index) {
if(index < 0 || index >= size){return -1;}
ListNode cur = head;
// 通过判断 index < (size - 1) / 2 来决定是从头结点还是尾节点遍历，提高效率
if(index < (size - 1) / 2){
for(int i = 0; i <= index; i++){
cur = cur.next;
}
}else{
cur = tail;
for(int i = 0; i <= size - index - 1; i++){
cur = cur.prev;
}
}
return cur.val;
}
/** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
public void addAtHead(int val) {
ListNode cur = head;
ListNode newNode = new ListNode(val);
newNode.next = cur.next;
cur.next.prev = newNode;
cur.next = newNode;
newNode.prev = cur;
size++;
}
/** Append a node of value val to the last element of the linked list. */
public void addAtTail(int val) {
ListNode cur = tail;
ListNode newNode = new ListNode(val);
newNode.next = tail;
newNode.prev = cur.prev;
cur.prev.next = newNode;
cur.prev = newNode;
size++;
}
/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
public void addAtIndex(int index, int val) {
if(index > size){return;}
if(index < 0){index = 0;}
ListNode cur = head;
for(int i = 0; i < index; i++){
cur = cur.next;
}
ListNode newNode = new ListNode(val);
newNode.next = cur.next;
cur.next.prev = newNode;
newNode.prev = cur;
cur.next = newNode;
size++;
}
/** Delete the index-th node in the linked list, if the index is valid. */
public void deleteAtIndex(int index) {
if(index >= size || index < 0){return;}
ListNode cur = head;
for(int i = 0; i < index; i++){
cur = cur.next;
}
cur.next.next.prev = cur;
cur.next = cur.next.next;
size--;
}
}
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList obj = new MyLinkedList();
* int param_1 = obj.get(index);
* obj.addAtHead(val);
* obj.addAtTail(val);
* obj.addAtIndex(index,val);
* obj.deleteAtIndex(index);
*/
```
Python：

46
problems/0739.每日温度.md
View File

@ -214,6 +214,52 @@ Python：
Go：
> 暴力法
```go
func dailyTemperatures(temperatures []int) []int {
length:=len(temperatures)
res:=make([]int,length)
for i:=0;i<length;i++{
j:=i+1
if i==length-1{
res[i]=0
}
for j<length&&temperatures[i]>=temperatures[j]{//大于等于
j++
}
if j<length&&temperatures[i]<temperatures[j]{
res[i]=j-i
}
if j==length{
res[i]=0
}
}
return res
}
```
> 单调栈法
```go
func dailyTemperatures(temperatures []int) []int {
length:=len(temperatures)
res:=make([]int,length)
stack:=[]int{}
for i:=0;i<length;i++{
//如果当前栈中存在元素，新来的元素大于栈顶的元素，则计算差值并弹出栈顶元素
for len(stack)>0&&temperatures[i]>temperatures[stack[len(stack)-1]]{
res[stack[len(stack)-1]]=i-stack[len(stack)-1]//存放结果集
stack=stack[:len(stack)-1]//删除stack[len(stack)-1]的元素
}
//如果栈顶元素大于等于新来的元素，则加入到栈中。当栈内元素个数为0时，直接入栈
if len(stack)==0||temperatures[i]<=temperatures[stack[len(stack)-1]]{
stack = append(stack, i)
}
}
return res
}
```

25
problems/0977.有序数组的平方.md
View File

@ -198,6 +198,31 @@ impl Solution {
}
}
```
Javascript：
```Javascript
/**
* @desc two pointers solution
* @link https://leetcode-cn.com/problems/squares-of-a-sorted-array/
* @param nums Array e.g. [-4,-1,0,3,10]
* @return {array} e.g. [0,1,9,16,100]
*/
const sortedSquares = function (nums) {
let res = []
for (let i = 0, j = nums.length - 1; i <= j;) {
const left = Math.abs(nums[i])
const right = Math.abs(nums[j])
if (right > left) {
// push element to the front of the array
res.unshift(right * right)
j--
} else {
res.unshift(left * left)
i++
}
}
return res
}
```
-----------------------
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)

49
problems/背包问题理论基础多重背包.md
View File

@ -147,9 +147,56 @@ int main() {
Java：
Python：
```python
def test_multi_pack1():
'''版本一：改变物品数量为01背包格式'''
weight = [1, 3, 4]
value = [15, 20, 30]
nums = [2, 3, 2]
bag_weight = 10
for i in range(len(nums)):
# 将物品展开数量为1
while nums[i] > 1:
weight.append(weight[i])
value.append(value[i])
nums[i] -= 1
dp = [0]*(bag_weight + 1)
# 遍历物品
for i in range(len(weight)):
# 遍历背包
for j in range(bag_weight, weight[i] - 1, -1):
dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
print(" ".join(map(str, dp)))
def test_multi_pack2():
'''版本：改变遍历个数'''
weight = [1, 3, 4]
value = [15, 20, 30]
nums = [2, 3, 2]
bag_weight = 10
dp = [0]*(bag_weight + 1)
for i in range(len(weight)):
for j in range(bag_weight, weight[i] - 1, -1):
# 以上是01背包，加上遍历个数
for k in range(1, nums[i] + 1):
if j - k*weight[i] >= 0:
dp[j] = max(dp[j], dp[j - k*weight[i]] + k*value[i])
print(" ".join(map(str, dp)))
if __name__ == '__main__':
test_multi_pack1()
test_multi_pack2()
```
Go：