Merge branch 'youngyangyang04:master' into master

This commit is contained in:
Yukun J
2022-08-26 15:07:28 -04:00
committed by GitHub
6 changed files with 319 additions and 124 deletions

View File

@ -363,6 +363,34 @@ class Solution:
Go
```go
func longestPalindrome(s string) string {
maxLen := 0
left := 0
length := 0
dp := make([][]bool, len(s))
for i := 0; i < len(s); i++ {
dp[i] = make([]bool,len(s))
}
for i := len(s)-1; i >= 0; i-- {
for j := i; j < len(s); j++ {
if s[i] == s[j]{
if j-i <= 1{ // 情况一和情况二
length = j-i
dp[i][j]=true
}else if dp[i+1][j-1]{ // 情况三
length = j-i
dp[i][j] = true
}
}
}
if length > maxLen {
maxLen = length
left = i
}
}
return s[left: left+maxLen+1]
}
```

View File

@ -133,5 +133,73 @@ public:
## 其他语言版本
### Java
```java
class Solution {
public List<Integer> spiralOrder(int[][] matrix) {
//存放数组的数
List<Integer> ans = new ArrayList<>();
//列数
int columns = matrix[0].length;
//行数
int rows = matrix.length;
//遍历起点
int start = 0;
//循环的次数 行数和列数中的最小值除以二
int loop = Math.min(rows,columns) / 2;
//未遍历的中间列(行)的列(行)下标
int mid = loop;
//终止条件
int offSet = 1;
int i,j;
while(loop-- > 0) {
//初始化起点
i = j = start;
//从左往右
for(; j < columns - offSet; j++)
ans.add(matrix[i][j]);
//从上往下
for(; i < rows - offSet; i++)
ans.add(matrix[i][j]);
//从右往左
for(; j > start; j--)
ans.add(matrix[i][j]);
//从下往上
for(; i > start; i--)
ans.add(matrix[i][j]);
//每循环一次 改变起点位置
start++;
//终止条件改变
offSet++;
}
//如果行和列中的最小值是奇数 则会产生中间行或者中间列没有遍历
if(Math.min(rows,columns) % 2 != 0) {
//行大于列则产生中间列
if(rows > columns) {
//中间列的行的最大下标的下一位的下标为mid + rows - columns + 1
for(int k = mid; k < mid + rows - columns + 1; k++) {
ans.add(matrix[k][mid]);
}
}else {//列大于等于行则产生中间行
//中间行的列的最大下标的下一位的下标为mid + columns - rows + 1
for(int k = mid; k < mid + columns - rows + 1; k++) {
ans.add(matrix[mid][k]);
}
}
}
return ans;
}
}
```
-----------------------
<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

View File

@ -237,6 +237,26 @@ class Solution:
return True
```
Go
> 递归法
```go
func isSameTree(p *TreeNode, q *TreeNode) bool {
if p != nil && q == nil {
return false
}
if p == nil && q != nil {
return false
}
if p == nil && q == nil {
return true
}
if p.Val != q.Val {
return false
}
Left := isSameTree(p.Left, q.Left)
Right := isSameTree(p.Right, q.Right)
return Left && Right
}
```
JavaScript
@ -253,6 +273,28 @@ var isSameTree = function (p, q) {
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
};
```
> 迭代法
```javascript
var isSameTree = (p, q) => {
const queue = [{ p, q }];
// 这是用{ } 解决了null的问题
while (queue.length) {
const cur = queue.shift();
if (cur.p == null && cur.q == null) continue;
if (cur.p == null || cur.q == null) return false;
if (cur.p.val != cur.q.val) return false;
queue.push({
p: cur.p.left,
q: cur.q.left
}, {
p: cur.p.right,
q: cur.q.right
});
}
return true;
};
```
TypeScript:

View File

@ -810,16 +810,15 @@ go:
199. 二叉树的右视图
*/
func rightSideView(root *TreeNode) []int {
queue:=list.New()
res:=[][]int{}
var finaRes []int
if root == nil {
return finaRes
return nil
}
res := make([]int, 0)
queue := list.New()
queue.PushBack(root)
for queue.Len() > 0 {
length := queue.Len()
tmp:=[]int{}
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*TreeNode)
if node.Left != nil {
@ -828,15 +827,13 @@ func rightSideView(root *TreeNode) []int {
if node.Right != nil {
queue.PushBack(node.Right)
}
tmp=append(tmp,node.Val)
// 取每层的最后一个元素,添加到结果集中
if i == length-1 {
res = append(res, node.Val)
}
res=append(res,tmp)
}
//取每一层的最后一个元素
for i:=0;i<len(res);i++{
finaRes=append(finaRes,res[i][len(res[i])-1])
}
return finaRes
return res
}
```
@ -1054,40 +1051,34 @@ go:
637. 二叉树的层平均值
*/
func averageOfLevels(root *TreeNode) []float64 {
res:=[][]int{}
var finRes []float64
if root==nil{//防止为空
return finRes
if root == nil {
// 防止为空
return nil
}
res := make([]float64, 0)
queue := list.New()
queue.PushBack(root)
var tmpArr []int
var sum int
for queue.Len() > 0 {
length:=queue.Len()//保存当前层的长度,然后处理当前层(十分重要,防止添加下层元素影响判断层中元素的个数)
//保存当前层的长度,然后处理当前层(十分重要,防止添加下层元素影响判断层中元素的个数)
length := queue.Len()
for i := 0; i < length; i++ {
node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
node := queue.Remove(queue.Front()).(*TreeNode)
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right != nil {
queue.PushBack(node.Right)
}
tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
// 当前层元素求和
sum += node.Val
}
res=append(res,tmpArr)//放入结果集
tmpArr=[]int{}//清空层的数据
// 计算每层的平均值,将结果添加到响应结果中
res = append(res, float64(sum)/float64(length))
sum = 0 // 清空该层的数据
}
//计算每层的平均值
length:=len(res)
for i:=0;i<length;i++{
var sum int
for j:=0;j<len(res[i]);j++{
sum+=res[i][j]
}
tmp:=float64(sum)/float64(len(res[i]))
finRes=append(finRes,tmp)//将平均值放入结果集合
}
return finRes
return res
}
```
@ -1552,44 +1543,40 @@ go:
515. 在每个树行中找最大值
*/
func largestValues(root *TreeNode) []int {
res:=[][]int{}
var finRes []int
if root==nil{//防止为空
return finRes
if root == nil {
//防止为空
return nil
}
queue := list.New()
queue.PushBack(root)
var tmpArr []int
//层次遍历
ans := make([]int, 0)
temp := math.MinInt64
// 层序遍历
for queue.Len() > 0 {
length:=queue.Len()//保存当前层的长度,然后处理当前层(十分重要,防止添加下层元素影响判断层中元素的个数)
//保存当前层的长度,然后处理当前层(十分重要,防止添加下层元素影响判断层中元素的个数)
length := queue.Len()
for i := 0; i < length; i++ {
node := queue.Remove(queue.Front()).(*TreeNode)//出队列
// 比较当前层中的最大值和新遍历的元素大小,取两者中大值
temp = max(temp, node.Val)
if node.Left != nil {
queue.PushBack(node.Left)
}
if node.Right != nil {
queue.PushBack(node.Right)
}
tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
}
res=append(res,tmpArr)//放入结果集
tmpArr=[]int{}//清空层的数据
ans = append(ans, temp)
temp = math.MinInt64
}
//找到每层的最大值
for i:=0;i<len(res);i++{
finRes=append(finRes,max(res[i]...))
return ans
}
return finRes
func max(x, y int) int {
if x > y {
return x
}
func max(vals...int) int {
max:=int(math.Inf(-1))//负无穷
for _, val := range vals {
if val > max {
max = val
}
}
return max
return y
}
```
@ -1891,13 +1878,12 @@ go:
*/
func connect(root *Node) *Node {
res:=[][]*Node{}
if root == nil { //防止为空
return root
}
queue := list.New()
queue.PushBack(root)
var tmpArr []*Node
tmpArr := make([]*Node, 0)
for queue.Len() > 0 {
length := queue.Len() //保存当前层的长度,然后处理当前层(十分重要,防止添加下层元素影响判断层中元素的个数)
for i := 0; i < length; i++ {
@ -1910,17 +1896,17 @@ func connect(root *Node) *Node {
}
tmpArr = append(tmpArr, node) //将值加入本层切片中
}
res=append(res,tmpArr)//放入结果集
tmpArr=[]*Node{}//清空层的数据
}
if len(tmpArr) > 1 {
// 遍历每层元素,指定next
for i:=0;i<len(res);i++{
for j:=0;j<len(res[i])-1;j++{
res[i][j].Next=res[i][j+1]
for i := 0; i < len(tmpArr)-1; i++ {
tmpArr[i].Next = tmpArr[i+1]
}
}
tmpArr = []*Node{} //清空层的数据
}
return root
}
```
Swift
@ -2172,13 +2158,12 @@ go:
*/
func connect(root *Node) *Node {
res:=[][]*Node{}
if root == nil { //防止为空
return root
}
queue := list.New()
queue.PushBack(root)
var tmpArr []*Node
tmpArr := make([]*Node, 0)
for queue.Len() > 0 {
length := queue.Len() //保存当前层的长度,然后处理当前层(十分重要,防止添加下层元素影响判断层中元素的个数)
for i := 0; i < length; i++ {
@ -2191,15 +2176,14 @@ func connect(root *Node) *Node {
}
tmpArr = append(tmpArr, node) //将值加入本层切片中
}
res=append(res,tmpArr)//放入结果集
tmpArr=[]*Node{}//清空层的数据
}
if len(tmpArr) > 1 {
// 遍历每层元素,指定next
for i:=0;i<len(res);i++{
for j:=0;j<len(res[i])-1;j++{
res[i][j].Next=res[i][j+1]
for i := 0; i < len(tmpArr)-1; i++ {
tmpArr[i].Next = tmpArr[i+1]
}
}
tmpArr = []*Node{} //清空层的数据
}
return root
}
```

View File

@ -250,20 +250,20 @@ Go
```go
func sumNumbers(root *TreeNode) int {
sum = 0
travel(root, root.Val)
sum := 0
dfs(root, root.Val, &sum)
return sum
}
func travel(root *TreeNode, tmpSum int) {
func dfs(root *TreeNode, tmpSum int, sum *int) {
if root.Left == nil && root.Right == nil {
sum += tmpSum
*sum += tmpSum
} else {
if root.Left != nil {
travel(root.Left, tmpSum*10+root.Left.Val)
dfs(root.Left, tmpSum*10 + root.Left.Val, sum)
}
if root.Right != nil {
travel(root.Right, tmpSum*10+root.Right.Val)
dfs(root.Right, tmpSum*10 + root.Right.Val, sum)
}
}
}

View File

@ -157,7 +157,7 @@ public:
## 其他语言版本
### Java
### Java
```java
// 普通方法(使用栈的思路)
@ -214,7 +214,80 @@ public static boolean backspaceCompare(String s, String t) {
}
```
```java
class Solution {
public static boolean backspaceCompare(String s, String t) {
return getStr(s).equals(getStr(t));
}
public static String getStr(String s) { //使用快慢双指针去除字符串中的#
int slowIndex;
int fastIndex = 0;
StringBuilder builder = new StringBuilder(s); //StringBuilder用于修改字符串
for(slowIndex = 0; fastIndex < s.length(); fastIndex++) {
if(builder.charAt(fastIndex) != '#') {
builder.setCharAt(slowIndex++,builder.charAt(fastIndex));
} else {
if(slowIndex > 0) {
slowIndex--;
}
}
}
return builder.toString().substring(0,slowIndex); //截取有效字符串
}
}
```
从后往前双指针:
```java
class Solution {
public static boolean backspaceCompare(String s, String t) {
int sSkipNum = 0; //记录s的#的个数
int tSkipNum = 0; //记录t的#的个数
int sIndex = s.length() - 1;
int tIndex = t.length() - 1;
while(true) {
while(sIndex >= 0) { //每次记录连续的#并跳过被删除的字符
if(s.charAt(sIndex) == '#') {
sSkipNum++;
} else {
if(sSkipNum > 0) {
sSkipNum--;
} else {
break;
}
}
sIndex--;
}
while(tIndex >= 0) { //每次记录连续的#并跳过被删除的字符
if(t.charAt(tIndex) == '#') {
tSkipNum++;
} else {
if(tSkipNum > 0) {
tSkipNum--;
} else {
break;
}
}
tIndex--;
}
if(sIndex < 0 || tIndex < 0) { //s 或者 t遍历完了
break;
}
if(s.charAt(sIndex) != t.charAt(tIndex)) { //当前下标的字符不相等
return false;
}
sIndex--;
tIndex--;
}
if(sIndex == -1 && tIndex == -1) { //同时遍历完 则相等
return true;
}
return false;
}
}
```
### python