Merge branch 'master' into master

This commit is contained in:
YDLIN
2022-01-27 11:31:57 +08:00
committed by GitHub
12 changed files with 493 additions and 214 deletions

View File

@ -545,5 +545,64 @@ int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes
}
```
C#:
```csharp
public class Solution
{
public IList<IList<int>> ThreeSum(int[] nums)
{
var result = new List<IList<int>>();
Array.Sort(nums);
for (int i = 0; i < nums.Length - 2; i++)
{
int n1 = nums[i];
if (n1 > 0)
break;
if (i > 0 && n1 == nums[i - 1])
continue;
int left = i + 1;
int right = nums.Length - 1;
while (left < right)
{
int n2 = nums[left];
int n3 = nums[right];
int sum = n1 + n2 + n3;
if (sum > 0)
{
right--;
}
else if (sum < 0)
{
left++;
}
else
{
result.Add(new List<int> { n1, n2, n3 });
while (left < right && nums[left] == n2)
{
left++;
}
while (left < right && nums[right] == n3)
{
right--;
}
}
}
}
return result;
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -445,5 +445,67 @@ func fourSum(_ nums: [Int], _ target: Int) -> [[Int]] {
}
```
C#:
```csharp
public class Solution
{
public IList<IList<int>> FourSum(int[] nums, int target)
{
var result = new List<IList<int>>();
Array.Sort(nums);
for (int i = 0; i < nums.Length - 3; i++)
{
int n1 = nums[i];
if (i > 0 && n1 == nums[i - 1])
continue;
for (int j = i + 1; j < nums.Length - 2; j++)
{
int n2 = nums[j];
if (j > i + 1 && n2 == nums[j - 1])
continue;
int left = j + 1;
int right = nums.Length - 1;
while (left < right)
{
int n3 = nums[left];
int n4 = nums[right];
int sum = n1 + n2 + n3 + n4;
if (sum > target)
{
right--;
}
else if (sum < target)
{
left++;
}
else
{
result.Add(new List<int> { n1, n2, n3, n4 });
while (left < right && nums[left] == n3)
{
left++;
}
while (left < right && nums[right] == n4)
{
right--;
}
}
}
}
}
return result;
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -346,69 +346,56 @@ class Solution {
### Go
```Go
import "strings"
var res [][]string
func isValid(board [][]string, row, col int) (res bool){
n := len(board)
for i:=0; i < row; i++ {
if board[i][col] == "Q" {
return false
}
}
for i := 0; i < n; i++{
if board[row][i] == "Q" {
return false
}
}
for i ,j := row, col; i >= 0 && j >=0 ; i, j = i - 1, j- 1{
if board[i][j] == "Q"{
return false
}
}
for i, j := row, col; i >=0 && j < n; i,j = i-1, j+1 {
if board[i][j] == "Q" {
return false
}
}
return true
}
func backtrack(board [][]string, row int) {
size := len(board)
if row == size{
temp := make([]string, size)
for i := 0; i<size;i++{
temp[i] = strings.Join(board[i],"")
}
res =append(res,temp)
return
}
for col := 0; col < size; col++ {
if !isValid(board, row, col){
continue
}
board[row][col] = "Q"
backtrack(board, row+1)
board[row][col] = "."
}
}
func solveNQueens(n int) [][]string {
res = [][]string{}
board := make([][]string, n)
for i := 0; i < n; i++{
board[i] = make([]string, n)
}
for i := 0; i < n; i++{
for j := 0; j<n;j++{
board[i][j] = "."
}
}
backtrack(board, 0)
var res [][]string
chessboard := make([][]string, n)
for i := 0; i < n; i++ {
chessboard[i] = make([]string, n)
}
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
chessboard[i][j] = "."
}
}
var backtrack func(int)
backtrack = func(row int) {
if row == n {
temp := make([]string, n)
for i, rowStr := range chessboard {
temp[i] = strings.Join(rowStr, "")
}
res = append(res, temp)
return
}
for i := 0; i < n; i++ {
if isValid(n, row, i, chessboard) {
chessboard[row][i] = "Q"
backtrack(row + 1)
chessboard[row][i] = "."
}
}
}
backtrack(0)
return res
}
return res
func isValid(n, row, col int, chessboard [][]string) bool {
for i := 0; i < row; i++ {
if chessboard[i][col] == "Q" {
return false
}
}
for i, j := row-1, col-1; i >= 0 && j >= 0; i, j = i-1, j-1 {
if chessboard[i][j] == "Q" {
return false
}
}
for i, j := row-1, col+1; i >= 0 && j < n; i, j = i-1, j+1 {
if chessboard[i][j] == "Q" {
return false
}
}
return true
}
```
### Javascript

View File

@ -266,46 +266,33 @@ Go
```go
func uniquePathsWithObstacles(obstacleGrid [][]int) int {
m,n:= len(obstacleGrid),len(obstacleGrid[0])
m, n := len(obstacleGrid), len(obstacleGrid[0])
// 定义一个dp数组
dp := make([][]int,m)
for i,_ := range dp {
dp[i] = make([]int,n)
dp := make([][]int, m)
for i, _ := range dp {
dp[i] = make([]int, n)
}
// 初始化
for i:=0;i<m;i++ {
// 如果是障碍物, 后面的就都是0, 不用循环了
if obstacleGrid[i][0] == 1 {
break
}
dp[i][0]=1
// 初始化, 如果是障碍物, 后面的就都是0, 不用循环了
for i := 0; i < m && obstacleGrid[i][0] == 0; i++ {
dp[i][0] = 1
}
for i:=0;i<n;i++ {
if obstacleGrid[0][i] == 1 {
break
}
dp[0][i]=1
for i := 0; i < n && obstacleGrid[0][i] == 0; i++ {
dp[0][i] = 1
}
// dp数组推导过程
for i:=1;i<m;i++ {
for j:=1;j<n;j++ {
// 如果obstacleGrid[i][j]这个点是障碍物, 那么我们的dp[i][j]保持为0
if obstacleGrid[i][j] != 1 {
for i := 1; i < m; i++ {
for j := 1; j < n; j++ {
// 如果obstacleGrid[i][j]这个点是障碍物, 那么dp[i][j]保持为0
if obstacleGrid[i][j] != 1 {
// 否则我们需要计算当前点可以到达的路径数
dp[i][j] = dp[i-1][j]+dp[i][j-1]
dp[i][j] = dp[i-1][j] + dp[i][j-1]
}
}
}
// debug遍历dp
//for i,_ := range dp {
// for j,_ := range dp[i] {
// fmt.Printf("%.2v,",dp[i][j])
// }
// fmt.Println()
//}
return dp[m-1][n-1]
}
```
Javascript

View File

@ -730,5 +730,33 @@ bool isBalanced(struct TreeNode* root){
}
```
## Swift:
>递归
```swift
func isBalanced(_ root: TreeNode?) -> Bool {
// -1 已经不是平衡二叉树
return getHeight(root) == -1 ? false : true
}
func getHeight(_ root: TreeNode?) -> Int {
guard let root = root else {
return 0
}
let leftHeight = getHeight(root.left)
if leftHeight == -1 {
return -1
}
let rightHeight = getHeight(root.right)
if rightHeight == -1 {
return -1
}
if abs(leftHeight - rightHeight) > 1 {
return -1
} else {
return 1 + max(leftHeight, rightHeight)
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -553,6 +553,65 @@ function reverse(strArr, start, end) {
}
```
TypeScript
```typescript
function reverseWords(s: string): string {
/** Utils **/
// 删除多余空格, 如' hello world ' => 'hello world'
function delExtraSpace(arr: string[]): void {
let left: number = 0,
right: number = 0,
length: number = arr.length;
while (right < length && arr[right] === ' ') {
right++;
}
while (right < length) {
if (arr[right] === ' ' && arr[right - 1] === ' ') {
right++;
continue;
}
arr[left++] = arr[right++];
}
if (arr[left - 1] === ' ') {
arr.length = left - 1;
} else {
arr.length = left;
}
}
// 翻转字符串,如:'hello' => 'olleh'
function reverseWords(strArr: string[], start: number, end: number) {
let temp: string;
while (start < end) {
temp = strArr[start];
strArr[start] = strArr[end];
strArr[end] = temp;
start++;
end--;
}
}
/** Main code **/
let strArr: string[] = s.split('');
delExtraSpace(strArr);
let length: number = strArr.length;
// 翻转整个字符串
reverseWords(strArr, 0, length - 1);
let start: number = 0,
end: number = 0;
while (start < length) {
end = start;
while (strArr[end] !== ' ' && end < length) {
end++;
}
// 翻转单个单词
reverseWords(strArr, start, end - 1);
start = end + 1;
}
return strArr.join('');
};
```
Swift:
```swift

View File

@ -582,97 +582,70 @@ var binaryTreePaths = function(root) {
```
Swift:
递归法:
> 递归/回溯
```swift
func binaryTreePaths(_ root: TreeNode?) -> [String] {
var result = Array<String>()
var path = Array<Int>()
guard let root = root else {
return result
}
traversal(root, &path, &result)
return result
var res = [String]()
guard let root = root else {
return res
}
var path = [Int]()
_binaryTreePaths(root, path: &path, res: &res)
return res
}
func _binaryTreePaths(_ root: TreeNode, path: inout [Int], res: inout [String]) {
path.append(root.val)
if root.left == nil && root.right == nil {
var str = ""
for i in 0 ..< path.count - 1 {
str.append("\(path[i])->")
}
str.append("\(path.last!)")
res.append(str)
return
}
if let left = root.left {
_binaryTreePaths(left, path: &path, res: &res)
path.removeLast()
}
if let right = root.right {
_binaryTreePaths(right, path: &path, res: &res)
path.removeLast()
}
}
```
> 迭代
```swift
func binaryTreePaths(_ root: TreeNode?) -> [String] {
var res = [String]()
guard let root = root else {
return res
}
var stackNode = [TreeNode]()
stackNode.append(root)
func traversal(_ cur: TreeNode, _ path: inout Array<Int>, _ result: inout Array<String>) {
path.append(cur.val)
// 递归终止条件:到达叶子节点
if cur.left == nil && cur.right == nil {
var pathString = ""
// 处理 path 前面的元素
for i in 0..<path.count - 1 {
let value = path[i]
pathString += String(value)
pathString += "->"
}
// 处理 path 最后一个元素
if let lastValue = path.last {
pathString += String(lastValue)
}
// 将路径存到数组中
result.append(pathString)
return
var stackStr = [String]()
stackStr.append("\(root.val)")
while !stackNode.isEmpty {
let node = stackNode.popLast()!
let str = stackStr.popLast()!
if node.left == nil && node.right == nil {
res.append(str)
}
// 空节点不进入递归
if let leftNode = cur.left {
traversal(leftNode, &path, &result)
// 回溯
path.removeLast()
if let left = node.left {
stackNode.append(left)
stackStr.append("\(str)->\(left.val)")
}
// 空节点不进入递归
if let rightNode = cur.right {
traversal(rightNode, &path, &result)
// 回溯
path.removeLast()
if let right = node.right {
stackNode.append(right)
stackStr.append("\(str)->\(right.val)")
}
}
return res
}
```
迭代法:
```swift
func binaryTreePaths(_ root: TreeNode?) -> [String] {
// 保存树的遍历节点
var treeStack = [TreeNode]()
// 保存遍历路径的节点
var pathStack = [String]()
// 保存最终路径集合
var result = [String]()
guard let root = root else {
return result
}
treeStack.append(root)
pathStack.append(String(root.val))
while !treeStack.isEmpty {
let node = treeStack.removeLast()
let path = pathStack.removeLast()
// 遇到叶子节点
if node.left == nil && node.right == nil {
result.append(path)
}
if let rightNode = node.right {
treeStack.append(rightNode)
let tmp = path + "->" + String(rightNode.val)
pathStack.append(tmp)
}
if let leftNode = node.left {
treeStack.append(leftNode)
let tmp = path + "->" + String(leftNode.val)
pathStack.append(tmp)
}
}
return result
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -253,6 +253,19 @@ void reverseString(char* s, int sSize){
}
```
C#
```csharp
public class Solution
{
public void ReverseString(char[] s)
{
for (int i = 0, j = s.Length - 1; i < j; i++, j--)
{
(s[i], s[j]) = (s[j], s[i]);
}
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -289,7 +289,7 @@ func findTargetSumWays(nums []int, target int) int {
for _, v := range nums {
sum += v
}
if target > sum {
if abs(target) > sum {
return 0
}
if (sum+target)%2 == 1 {
@ -311,49 +311,12 @@ func findTargetSumWays(nums []int, target int) int {
}
return dp[bag]
}
```
> 更新版上一个跑不通了因为会存在bag 小于0的情况
```go
func findTargetSumWays(nums []int, target int) int {
//先转化为数学问题
//a-b=target
//a+b=sum
//a=(target+sum)/2
//求出sum
var sum int
for _,value:=range nums{
sum+=value
}
//如果sum<target或者 sum+target不是偶数因为a是int 或者两者之和小于0了
if sum<target||(sum+target)%2==1||(sum+target)<0{
return 0
}
//开始dp初始化
dp:=make([][]int,len(nums)+1)
for i:=0;i<=len(nums);i++{
tmp:=make([]int,(target+sum)/2+1)//背包容量
dp[i]=tmp
}
dp[0][0]=1//当背包容量为0且物品为0时填满背包就1种方法
for i:=0;i<len(nums)+1;i++{
if i==0{
continue
}
for j:=0;j<(target+sum)/2+1;j++{
if nums[i-1]<=j{//如果背包装的下
dp[i][j]=dp[i-1][j]+dp[i-1][j-nums[i-1]]
}else{
dp[i][j]=dp[i-1][j]
}
}
}
return dp[len(nums)][(target+sum)/2]
func abs(x int) int {
return int(math.Abs(float64(x)))
}
```
Javascript
```javascript
const findTargetSumWays = (nums, target) => {

View File

@ -294,9 +294,21 @@ func reverseStr(_ s: String, _ k: Int) -> String {
}
```
C#
```csharp
public class Solution
{
public string ReverseStr(string s, int k)
{
Span<char> span = s.ToCharArray().AsSpan();
for (int i = 0; i < span.Length; i += 2 * k)
{
span[i + k < span.Length ? i..(i + k) : i..].Reverse();
}
return span.ToString();
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -205,6 +205,42 @@ class Solution:
return self.get_string(s) == self.get_string(t)
pass
```
双指针
```python
class Solution:
def backspaceCompare(self, s: str, t: str) -> bool:
s_index, t_index = len(s) - 1, len(t) - 1
s_backspace, t_backspace = 0, 0 # 记录s,t的#数量
while s_index >= 0 or t_index >= 0: # 使用or以防长度不一致
while s_index >= 0: # 从后向前消除s的#
if s[s_index] == '#':
s_index -= 1
s_backspace += 1
else:
if s_backspace > 0:
s_index -= 1
s_backspace -= 1
else:
break
while t_index >= 0: # 从后向前消除t的#
if t[t_index] == '#':
t_index -= 1
t_backspace += 1
else:
if t_backspace > 0:
t_index -= 1
t_backspace -= 1
else:
break
if s_index >= 0 and t_index >= 0: # 后半部分#消除完了,接下来比较当前位的值
if s[s_index] != t[t_index]:
return False
elif s_index >= 0 or t_index >= 0: # 一个字符串找到了待比较的字符另一个没有返回False
return False
s_index -= 1
t_index -= 1
return True
```
### Go
@ -226,6 +262,51 @@ func backspaceCompare(s string, t string) bool {
return getString(s) == getString(t)
}
```
双指针
```go
func backspaceCompare(s string, t string) bool {
s_index, t_index := len(s) - 1, len(t) - 1
s_backspace, t_backspace := 0, 0 // 记录s,t的#数量
for s_index >= 0 || t_index >= 0 { // 使用or以防长度不一致
for s_index >= 0 { // 从后向前消除s的#
if s[s_index] == '#' {
s_index--
s_backspace++
} else {
if s_backspace > 0 {
s_index--
s_backspace--
} else {
break
}
}
}
for t_index >= 0 { // 从后向前消除t的#
if t[t_index] == '#' {
t_index--
t_backspace++
} else {
if t_backspace > 0 {
t_index--
t_backspace--
} else {
break
}
}
}
if s_index >= 0 && t_index >= 0 { // 后半部分#消除完了,接下来比较当前位的值
if s[s_index] != t[t_index] {
return false
}
} else if s_index >= 0 || t_index >= 0 { // 一个字符串找到了待比较的字符另一个没有返回false
return false
}
s_index--
t_index--
}
return true
}
```
### JavaScript

View File

@ -209,6 +209,61 @@ var reverseLeftWords = function(s, n) {
};
```
版本二(在原字符串上操作):
```js
/**
* @param {string} s
* @param {number} n
* @return {string}
*/
var reverseLeftWords = function (s, n) {
/** Utils */
function reverseWords(strArr, start, end) {
let temp;
while (start < end) {
temp = strArr[start];
strArr[start] = strArr[end];
strArr[end] = temp;
start++;
end--;
}
}
/** Main code */
let strArr = s.split('');
let length = strArr.length;
reverseWords(strArr, 0, length - 1);
reverseWords(strArr, 0, length - n - 1);
reverseWords(strArr, length - n, length - 1);
return strArr.join('');
};
```
TypeScript
```typescript
function reverseLeftWords(s: string, n: number): string {
/** Utils */
function reverseWords(strArr: string[], start: number, end: number): void {
let temp: string;
while (start < end) {
temp = strArr[start];
strArr[start] = strArr[end];
strArr[end] = temp;
start++;
end--;
}
}
/** Main code */
let strArr: string[] = s.split('');
let length: number = strArr.length;
reverseWords(strArr, 0, length - 1);
reverseWords(strArr, 0, length - n - 1);
reverseWords(strArr, length - n, length - 1);
return strArr.join('');
};
```
Swift:
```swift