Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 06997eb

Browse files
Merge branch 'master' of github.com:youngyangyang04/leetcode-master
2 parents 2d9604b + 8b0d5b2 commit 06997eb

18 files changed

+1709
-106
lines changed

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

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -794,6 +794,60 @@ func rebuild(inorder []int, postorder []int, rootIdx int, l, r int) *TreeNode {
794794
}
795795
```
796796

797+
```go
798+
/**
799+
* Definition for a binary tree node.
800+
* type TreeNode struct {
801+
* Val int
802+
* Left *TreeNode
803+
* Right *TreeNode
804+
* }
805+
*/
806+
func buildTree(inorder []int, postorder []int) *TreeNode {
807+
if len(postorder) == 0 {
808+
return nil
809+
}
810+
811+
// 后序遍历数组最后一个元素,就是当前的中间节点
812+
rootValue := postorder[len(postorder)-1]
813+
root := &TreeNode{Val:rootValue}
814+
815+
// 叶子结点
816+
if len(postorder) == 1 {
817+
return root
818+
}
819+
820+
// 找到中序遍历的切割点
821+
var delimiterIndex int
822+
for delimiterIndex = 0; delimiterIndex < len(inorder); delimiterIndex++ {
823+
if inorder[delimiterIndex] == rootValue {
824+
break;
825+
}
826+
}
827+
828+
// 切割中序数组
829+
// 左闭右开区间:[0, delimiterIndex)
830+
leftInorder := inorder[:delimiterIndex]
831+
// [delimiterIndex + 1, end)
832+
rightInorder := inorder[delimiterIndex+1:]
833+
834+
// postorder 舍弃末尾元素
835+
postorder = postorder[:len(postorder)-1]
836+
837+
// 切割后序数组
838+
// 依然左闭右开,注意这里使用了左中序数组大小作为切割点
839+
// [0, len(leftInorder))
840+
leftPostorder := postorder[:len(leftInorder)]
841+
// [len(leftInorder), end)
842+
rightPostorder := postorder[len(leftInorder):]
843+
844+
root.Left = buildTree(leftInorder, leftPostorder)
845+
root.Right = buildTree(rightInorder, rightPostorder)
846+
847+
return root
848+
}
849+
```
850+
797851
105 从前序与中序遍历序列构造二叉树
798852

799853
```go
@@ -829,6 +883,60 @@ func build(pre []int, in []int, root int, l, r int) *TreeNode {
829883
}
830884
```
831885

886+
```go
887+
/**
888+
* Definition for a binary tree node.
889+
* type TreeNode struct {
890+
* Val int
891+
* Left *TreeNode
892+
* Right *TreeNode
893+
* }
894+
*/
895+
func buildTree(preorder []int, inorder []int) *TreeNode {
896+
if len(preorder) == 0 {
897+
return nil
898+
}
899+
900+
// 前序遍历数组第一个元素,就是当前的中间节点
901+
rootValue := preorder[0]
902+
root := &TreeNode{Val:rootValue}
903+
904+
// 叶子结点
905+
if len(preorder) == 1 {
906+
return root
907+
}
908+
909+
// 找到中序遍历的切割点
910+
var delimiterIndex int
911+
for delimiterIndex = 0; delimiterIndex < len(inorder); delimiterIndex++ {
912+
if inorder[delimiterIndex] == rootValue {
913+
break
914+
}
915+
}
916+
917+
// 切割中序数组
918+
// 左闭右开区间:[0, delimiterIndex)
919+
leftInorder := inorder[:delimiterIndex]
920+
// [delimiterIndex + 1, end)
921+
rightInorder := inorder[delimiterIndex+1:]
922+
923+
// preorder 舍弃首位元素
924+
preorder = preorder[1:]
925+
926+
// 切割前序数组
927+
// 依然左闭右开,注意这里使用了左中序数组大小作为切割点
928+
// [0, len(leftInorder))
929+
leftPreorder := preorder[:len(leftInorder)]
930+
// [len(leftInorder), end)
931+
rightPreorder := preorder[len(leftInorder):]
932+
933+
root.Left = buildTree(leftPreorder, leftInorder)
934+
root.Right = buildTree(rightPreorder, rightInorder)
935+
936+
return root
937+
}
938+
```
939+
832940

833941
### JavaScript
834942

‎problems/0121.买卖股票的最佳时机.md

Lines changed: 21 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -466,7 +466,7 @@ function maxProfit(prices: number[]): number {
466466
};
467467
```
468468

469-
> 动态规划
469+
> 动态规划:版本一
470470
471471
```typescript
472472
function maxProfit(prices: number[]): number {
@@ -487,6 +487,26 @@ function maxProfit(prices: number[]): number {
487487
};
488488
```
489489

490+
> 动态规划:版本二
491+
492+
```typescript
493+
// dp[i][0] 表示第i天持有股票所得最多现金
494+
// dp[i][1] 表示第i天不持有股票所得最多现金
495+
function maxProfit(prices: number[]): number {
496+
const dp:number[][] = Array(2).fill(0).map(item => Array(2));
497+
dp[0][0] = -prices[0];
498+
dp[0][1] = 0;
499+
500+
for (let i = 1; i < prices.length; i++) {
501+
dp[i % 2][0] = Math.max(dp[(i - 1) % 2][0], -prices[i]);
502+
dp[i % 2][1] = Math.max(dp[(i - 1) % 2][1], dp[(i - 1) % 2][0] + prices[i]);
503+
}
504+
505+
// 返回不持有股票的最大现金
506+
return dp[(prices.length-1) % 2][1];
507+
};
508+
```
509+
490510
### C#:
491511

492512
> 贪心法

‎problems/0131.分割回文串.md

Lines changed: 22 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -310,39 +310,35 @@ public:
310310
### Java
311311
```Java
312312
class Solution {
313-
List<List<String>> lists =newArrayList<>();
314-
Deque<String> deque = new LinkedList<>();
315-
313+
//保持前几题一贯的格式, initialization
314+
List<List<String>> res = new ArrayList<>();
315+
List<String> cur =newArrayList<>();
316316
public List<List<String>> partition(String s) {
317-
backTracking(s, 0);
318-
return lists;
317+
backtracking(s, 0, newStringBuilder());
318+
return res;
319319
}
320-
321-
privatevoidbackTracking(Strings, intstartIndex) {
322-
//如果起始位置大于s的大小,说明找到了一组分割方案
323-
if (startIndex >= s.length()) {
324-
lists.add(new ArrayList(deque));
320+
privatevoidbacktracking(Strings, intstart, StringBuildersb){
321+
//因为是起始位置一个一个加的,所以结束时start一定等于s.length,因为进入backtracking时一定末尾也是回文,所以cur是满足条件的
322+
if (start == s.length()){
323+
//注意创建一个新的copy
324+
res.add(new ArrayList<>(cur));
325325
return;
326326
}
327-
for (int i = startIndex; i < s.length(); i++) {
328-
//如果是回文子串,则记录
329-
if (isPalindrome(s, startIndex, i)) {
330-
String str = s.substring(startIndex, i +1);
331-
deque.addLast(str);
332-
} else {
333-
continue;
327+
//像前两题一样从前往后搜索,如果发现回文,进入backtracking,起始位置后移一位,循环结束照例移除cur的末位
328+
for (int i = start; i < s.length(); i++){
329+
sb.append(s.charAt(i));
330+
if (check(sb)){
331+
cur.add(sb.toString());
332+
backtracking(s, i +1, newStringBuilder());
333+
cur.remove(cur.size() -1 );
334334
}
335-
//起始位置后移,保证不重复
336-
backTracking(s, i + 1);
337-
deque.removeLast();
338335
}
339336
}
340-
//判断是否是回文串
341-
private boolean isPalindrome(String s, int startIndex, int end) {
342-
for (int i = startIndex, j = end; i < j; i++, j--) {
343-
if (s.charAt(i) != s.charAt(j)) {
344-
return false;
345-
}
337+
338+
//helper method, 检查是否是回文
339+
private boolean check(StringBuilder sb){
340+
for (int i = 0; i < sb.length()/ 2; i++){
341+
if (sb.charAt(i) != sb.charAt(sb.length() - 1 - i)){return false;}
346342
}
347343
return true;
348344
}

‎problems/0309.最佳买卖股票时机含冷冻期.md

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -359,6 +359,26 @@ func max(a, b int) int {
359359

360360
### Javascript:
361361

362+
> 不同的状态定义 感觉更容易理解些
363+
```javascript
364+
function maxProfit(prices) {
365+
// 第i天状态 持股 卖出 非冷冻期(不持股) 处于冷冻期
366+
const dp = new Array(prices.length).fill(0).map(() => [0, 0, 0, 0]);
367+
dp[0][0] = -prices[0];
368+
for (let i = 1; i < prices.length; i++) {
369+
// 持股
370+
dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][2] - prices[i]);
371+
// 卖出
372+
dp[i][1] = dp[i - 1][0] + prices[i];
373+
// 非冷冻期(不持股)
374+
dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1]);
375+
// 冷冻期(上一天卖出)
376+
dp[i][3] = dp[i - 1][1];
377+
}
378+
return Math.max(...dp.pop());
379+
};
380+
```
381+
362382
```javascript
363383
const maxProfit = (prices) => {
364384
if(prices.length < 2) {

‎problems/0349.两个数组的交集.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -511,7 +511,7 @@ object Solution {
511511

512512
```
513513

514-
###Ruby
514+
###Ruby:
515515
```ruby
516516
def intersection(nums1, nums2)
517517
hash = {}

‎problems/0406.根据身高重建队列.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -87,7 +87,7 @@
8787
回归本题,整个插入过程如下:
8888

8989
排序完的people:
90-
[[7,0], [7,1], [6,1], [5,0], [5,2],[4,4]]
90+
[[7,0], [7,1], [6,1], [5,0], [5,2], [4,4]]
9191

9292
插入的过程:
9393
* 插入[7,0]:[[7,0]]

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /