Jul 3, 2022 · May 24, 2022 · May 24, 2022 · May 24, 2022 · May 24, 2022 · May 24, 2022
diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
diff --git a/problems/0052.N皇后II.md b/problems/0052.N皇后II.md
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md
diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
diff --git a/problems/0344.反转字符串.md b/problems/0344.反转字符串.md
diff --git a/problems/0404.左叶子之和.md b/problems/0404.左叶子之和.md
diff --git a/problems/0513.找树左下角的值.md b/problems/0513.找树左下角的值.md
Original file line number	Diff line number	Diff line change
Expand Up		@@ -289,6 +289,30 @@ func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
		return dummyHead.next
		}
		```


	PHP:
	```php
	function removeNthFromEnd($head, $n) {
	// 设置虚拟头节点
	$dummyHead = new ListNode();
	$dummyHead->next = $head;

	$slow = $fast = $dummyHead;
	while($n-- && $fast != null){
	$fast = $fast->next;
	}
	// fast 再走一步,让 slow 指向删除节点的上一个节点
	$fast = $fast->next;
	while ($fast != NULL) {
	$fast = $fast->next;
	$slow = $slow->next;
	}
	$slow->next = $slow->next->next;
	return $dummyHead->next;
	}
	```

		Scala:
		```scala
		object Solution {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -44,7 +44,7 @@ n 皇后问题研究的是如何将 n 个皇后放置在 n×ばつn 的棋盘上,并
		# 思路


	想看:[51.N皇后](https://mp.weixin.qq.com/s/lU_QwCMj6g60nh8m98GAWg) ,基本没有区别
	详看:[51.N皇后](https://mp.weixin.qq.com/s/lU_QwCMj6g60nh8m98GAWg) ,基本没有区别

		# C++代码

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1006,6 +1006,126 @@ func traversal(_ cur: TreeNode?, count: Int) {
		}
		```

	## C
	> 0112.路径总和
	递归法:
	```c
	bool hasPathSum(struct TreeNode* root, int targetSum){
	// 递归结束条件:若当前节点不存在,返回false
	if(!root)
	return false;
	// 若当前节点为叶子节点,且targetSum-root的值为0。(当前路径上的节点值的和满足条件)返回true
	if(!root->right && !root->left && targetSum == root->val)
	return true;

	// 查看左子树和右子树的所有节点是否满足条件
	return hasPathSum(root->right, targetSum - root->val) \|\| hasPathSum(root->left, targetSum - root->val);
	}
	```

	迭代法:
	```c
	// 存储一个节点以及当前的和
	struct Pair {
	struct TreeNode* node;
	int sum;
	};

	bool hasPathSum(struct TreeNode* root, int targetSum){
	struct Pair stack[1000];
	int stackTop = 0;

	// 若root存在,则将节点和值封装成一个pair入栈
	if(root) {
	struct Pair newPair = {root, root->val};
	stack[stackTop++] = newPair;
	}

	// 当栈不为空时
	while(stackTop) {
	// 出栈栈顶元素
	struct Pair topPair = stack[--stackTop];
	// 若栈顶元素为叶子节点,且和为targetSum时,返回true
	if(!topPair.node->left && !topPair.node->right && topPair.sum == targetSum)
	return true;

	// 若当前栈顶节点有左右孩子,计算和并入栈
	if(topPair.node->left) {
	struct Pair newPair = {topPair.node->left, topPair.sum + topPair.node->left->val};
	stack[stackTop++] = newPair;
	}
	if(topPair.node->right) {
	struct Pair newPair = {topPair.node->right, topPair.sum + topPair.node->right->val};
	stack[stackTop++] = newPair;
	}
	}
	return false;
	}
	```
	> 0113.路径总和 II
	```c
	int** ret;
	int* path;
	int* colSize;
	int retTop;
	int pathTop;

	void traversal(const struct TreeNode* const node, int count) {
	// 若当前节点为叶子节点
	if(!node->right && !node->left) {
	// 若当前path上的节点值总和等于targetSum。
	if(count == 0) {
	// 复制当前path
	int curPath = (int)malloc(sizeof(int) * pathTop);
	memcpy(curPath, path, sizeof(int) * pathTop);
	// 记录当前path的长度为pathTop
	colSize[retTop] = pathTop;
	// 将当前path加入到ret数组中
	ret[retTop++] = curPath;
	}
	return;
	}

	// 若节点有左/右孩子
	if(node->left) {
	// 将左孩子的值加入path中
	path[pathTop++] = node->left->val;
	traversal(node->left, count - node->left->val);
	// 回溯
	pathTop--;
	}
	if(node->right) {
	// 将右孩子的值加入path中
	path[pathTop++] = node->right->val;
	traversal(node->right, count - node->right->val);
	// 回溯
	--pathTop;
	}
	}

	int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes){
	// 初始化数组
	ret = (int*)malloc(sizeof(int) * 1000);
	path = (int)malloc(sizeof(int) * 1000);
	colSize = (int)malloc(sizeof(int) 1000);
	retTop = pathTop = 0;
	*returnSize = 0;

	// 若根节点不存在,返回空的ret
	if(!root)
	return ret;
	// 将根节点加入到path中
	path[pathTop++] = root->val;
	traversal(root, targetSum - root->val);

	// 设置返回ret数组大小,以及其中每个一维数组元素的长度
	*returnSize = retTop;
	*returnColumnSizes = colSize;

	return ret;
	}
	```

		## Scala

		### 0112.路径总和
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -817,6 +817,53 @@ object Solution {
		```


	PHP:
	```php
	function reverseWords($s) {
	$this->removeExtraSpaces($s);
	$this->reverseString($s, 0, strlen($s)-1);
	// 将每个单词反转
	$start = 0;
	for ($i = 0; $i <= strlen($s); $i++) {
	// 到达空格或者串尾,说明一个单词结束。进行翻转。
	if ($i == strlen($s) \|\| $s[$i] == ' ') {
	// 翻转,注意是左闭右闭 []的翻转。
	$this->reverseString($s, $start, $i-1);
	// +1: 单词与单词直接有个空格
	$start = $i + 1;
	}
	}
	return $s;
	}

	// 移除多余空格
	function removeExtraSpaces(&$s){
	$slow = 0;
	for ($i = 0; $i < strlen($s); $i++) {
	if ($s[$i] != ' ') {
	if ($slow != 0){
	$s[$slow++] = ' ';
	}
	while ($i < strlen($s) && $s[$i] != ' ') {
	$s[$slow++] = $s[$i++];
	}
	}
	}
	// 移动覆盖处理,丢弃多余的脏数据。
	$s = substr($s,0,$slow);
	return ;
	}

	// 翻转字符串
	function reverseString(&$s, $start, $end) {
	for ($i = $start, $j = $end; $i < $j; $i++, $j--) {
	$tmp = $s[$i];
	$s[$i] = $s[$j];
	$s[$j] = $tmp;
	}
	return ;
	}
	```


		-----------------------
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -496,8 +496,26 @@ struct ListNode* reverseList(struct ListNode* head){
		return reverse(NULL, head);
		}
		```
	Scala:



	PHP:
	```php
	// 双指针法:
	function reverseList($head) {
	$cur = $head;
	$pre = NULL;
	while($cur){
	$temp = $cur->next;
	$cur->next = $pre;
	$pre = $cur;
	$cur = $temp;
	}
	return $pre;
	}
	```

	Scala:
		双指针法:
		```scala
		object Solution {
Expand Down Expand Up		@@ -529,6 +547,7 @@ object Solution {
		cur.next = pre
		reverse(cur, tmp) // 此时cur成为前一个节点,tmp是当前节点
		}

		}
		```
		-----------------------
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -266,6 +266,38 @@ public class Solution
		}
		}
		```


	PHP:
	```php
	// 双指针
	// 一:
	function reverseString(&$s) {
	$left = 0;
	$right = count($s)-1;
	while($left<$right){
	$temp = $s[$left];
	$s[$left] = $s[$right];
	$s[$right] = $temp;
	$left++;
	$right--;
	}
	}

	// 二:
	function reverseString(&$s) {
	$this->reverse($s,0,count($s)-1);
	}
	// 按指定位置交换元素
	function reverse(&$s, $start, $end) {
	for ($i = $start, $j = $end; $i < $j; $i++, $j--) {
	$tmp = $s[$i];
	$s[$i] = $s[$j];
	$s[$j] = $tmp;
	}
	}
	```

		Scala:
		```scala
		object Solution {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -516,6 +516,44 @@ int sumOfLeftLeaves(struct TreeNode* root){
		}
		```

	## Scala

	递归:
	```scala
	object Solution {
	def sumOfLeftLeaves(root: TreeNode): Int = {
	if(root == null) return 0
	var midValue = 0
	if(root.left != null && root.left.left == null && root.left.right == null){
	midValue = root.left.value
	}
	// return关键字可以省略
	midValue + sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right)
	}
	}
	```

	迭代:
	```scala
	object Solution {
	import scala.collection.mutable
	def sumOfLeftLeaves(root: TreeNode): Int = {
	val stack = mutable.Stack[TreeNode]()
	if (root == null) return 0
	stack.push(root)
	var sum = 0
	while (!stack.isEmpty) {
	val curNode = stack.pop()
	if (curNode.left != null && curNode.left.left == null && curNode.left.right == null) {
	sum += curNode.left.value // 如果满足条件就累加
	}
	if (curNode.right != null) stack.push(curNode.right)
	if (curNode.left != null) stack.push(curNode.left)
	}
	sum
	}
	}
	```

		-----------------------
		<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
Original file line number	Diff line number	Diff line change
Expand Up		@@ -546,7 +546,50 @@ func findBottomLeftValue(_ root: TreeNode?) -> Int {
		}
		```

	## Scala

	递归版本:
	```scala
	object Solution {
	def findBottomLeftValue(root: TreeNode): Int = {
	var maxLeftValue = 0
	var maxLen = Int.MinValue
	// 递归方法
	def traversal(node: TreeNode, leftLen: Int): Unit = {
	// 如果左右都为空并且当前深度大于最大深度,记录最左节点的值
	if (node.left == null && node.right == null && leftLen > maxLen) {
	maxLen = leftLen
	maxLeftValue = node.value
	}
	if (node.left != null) traversal(node.left, leftLen + 1)
	if (node.right != null) traversal(node.right, leftLen + 1)
	}
	traversal(root, 0) // 调用方法
	maxLeftValue // return关键字可以省略
	}
	}
	```

	层序遍历:
	```scala
	import scala.collection.mutable

	def findBottomLeftValue(root: TreeNode): Int = {
	val queue = mutable.Queue[TreeNode]()
	queue.enqueue(root)
	var res = 0 // 记录每层最左侧结果
	while (!queue.isEmpty) {
	val len = queue.size
	for (i <- 0 until len) {
	val curNode = queue.dequeue()
	if (i == 0) res = curNode.value // 记录最最左侧的节点
	if (curNode.left != null) queue.enqueue(curNode.left)
	if (curNode.right != null) queue.enqueue(curNode.right)
	}
	}
	res // 最终返回结果,return关键字可以省略
	}
	```

		-----------------------
		<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>