JZ33 二叉搜索树的后序遍历序列 【递归】
题目：
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回 true ,否则返回 false 。假设输入的数组的任意两个数字都互不相同。
数据范围： 节点数量 0 \le n \le 10000≤n≤1000 ，节点上的值满足 1 \le val \le 10^{5}1≤val≤10
5
，保证节点上的值各不相同
要求：空间复杂度 O(n)O(n) ，时间时间复杂度 O(n^2)O(n
2
)
提示：
1.二叉搜索树是指父亲节点大于左子树中的全部节点，但是小于右子树中的全部节点的树。
2.该题我们约定空树不是二叉搜索树
3.后序遍历是指按照 “左子树-右子树-根节点” 的顺序遍历
4.参考下面的二叉搜索树，示例 1
解题思路：
主要分为两个思路解决，分而治之 和 利用栈的压入，弹出序列问题解决。
1.分而治之思路：由于后续遍历序列中，最后一个节点肯定是根节点，是最大的节点，所以解决思路是：
1）将序列中元素 从右向左 和根节点比较，找到左子树的根节点
2）这里需要注意的是，若左子树压根不存在，则只检查树的右子树即可，也就是check(sequence, l, r-1)
3）检查左子树中的节点是否都满足 小于根节点
4）若满足则分辨检查 左子树序列 和 右子树序列
代码：
- 分而治之
class Solution {
public:
// 解决思路用两个：1. 分而治之 2. 栈序列的压如和弹出
// 思路1： 分而治之，利用递归
bool check(vector<int> sequence, int l, int r){
if(l >= r) return true;
// 设置j为左子树的终点
int j = r;
for(int i = r-1; i >= 0; i--){
if(sequence[i] < sequence[r]){
j = i;
break;
}
}
// **** 此处需要注意：若该树没有左子树，检查树的右子树
if(j == r) return check(sequence, l, j-1);
cout << "left end " << j << endl;
// 检查该树的左子树是否完全符合小于根节点
for(int i = l; i < j; i++){
if(sequence[i] > sequence[r]){
return false;
}
}
// 分别检查左子树和右子树
return check(sequence, l, j) && check(sequence, j+1, r-1);
}
bool VerifySquenceOfBST(vector<int> sequence) {
if(sequence.size() == 0) return false;
int n = sequence.size()-1;
return check(sequence, 0, n);
}
};
- 栈的压入，弹出序列
class Solution {
public:
// 思路2：利用栈的压入和弹出，先将后序序列 排序就得到了二叉树的中序序列
// 若 中序序列 能通过压栈弹栈得到 后序序列，说明该序列可以组成二叉树
// 中序序列作为压栈序列，后序序列是目标序列，利用双指针
bool check(vector<int> sequence, vector<int> inOrder){
// 利用双指针，指针i指向 后序序列
// 指针j指向 中序序列，将中序序列进行压栈
int i = 0;
int j = 0;
int n = inOrder.size();
stack<int> s;
// 将中序序列的元素都压栈
while(j < n){
s.push(inOrder[j]);
// 若栈非空且栈顶元素 等于后序序列的元素，则出栈
while(!s.empty() && s.top() == sequence[i]){ // !s.empty()判断要放在前，不然访问s.top()会出错
i += 1;
s.pop();
}
j += 1;
}
// 检查栈是否都出栈了 以及 指向后序序列的指针是否到达尾部
if(i == n && s.empty()) {
return true;
} else {
return false;
}
}
bool VerifySquenceOfBST(vector<int> sequence) {
if(sequence.size() == 0) return false;
vector<int> inOrder(sequence);
sort(inOrder.begin(), inOrder.end()); // 得到二叉树的中序序列inOrder
return check(sequence, inOrder);
}
};
JZ82 二叉树中和为某一值的路径
题目：
给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n
例如给出如下二叉树，sum为22
解题思路：
递归
代码：
/**
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
class Solution {
public:
/**
*
* @param root TreeNode类
* @param sum int整型
* @return bool布尔型
*/
//
bool hasPathSum(TreeNode* root, int sum) {
// write code here
if(root == NULL) return false;
if(root->val == sum && root->left == NULL && root->right == NULL) return true;
if(root->left) {
if(hasPathSum(root->left, sum - root->val)) return true;
}
if(root->right) {
if(hasPathSum(root->right, sum-root->val)) return true;
}
return false;
}
};
JZ34 二叉树中和为某一值的路径(二) 【递归】
题目：
输入一颗二叉树的根节点root和一个整数expectNumber，找出二叉树中结点值的和为expectNumber的所有路径。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n
如二叉树root为{10,5,12,4,7},expectNumber为22
思路：
这道题跟树相关，需要检查所有的叶子节点，肯定想到递归。需要注意的是返回的路径可能有多条，因此如何将多条路径（二维数组）返回是一开始我想不明白的。后来看题解解决办法是 将一维数组（path）和二维数组（结果）都作为应用参数传入到递归的函数当中。需要特别注意的一点是，递归函数中最后要将当前节点pop掉，因为函数执行到那个位置时，那个节点已经没用了，它的左子树和右子树都已经被检查过。
代码：
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
// 思路：肯定用的是深度优先搜索，应该用栈 或者 递归
// 递归就是先找左子树，再找右子树，找 num - root.val
class Solution {
public:
vector<vector<int>> FindPath(TreeNode* root,int expectNumber) {
vector<vector<int>> result;
vector<int> path;
if(root == NULL) return result;
searchTree(root, expectNumber, path, result);
return result;
}
void searchTree(TreeNode* root,int expectNumber, vector<int> &path, vector<vector<int>> &result){
if(root!=NULL) {
path.push_back(root->val);
}
//若该叶节点对应的路径满足条件，则将该路径存于result当中
if(root->left == NULL && root->right == NULL && root->val == expectNumber){
result.push_back(path);
}
//递归检查树的左子树和右子树
if(root->left) searchTree(root->left, expectNumber-root->val, path, result);
if(root->right) searchTree(root->right, expectNumber-root->val, path, result);
//**** 这行代码很关键！！
// 递归循环运行到这里时，左路径和右路径都已经检查完毕，也就是当前节点可以从path中pop掉
path.pop_back();
return;
}
};
JZ8 二叉树的下一个结点 【中序遍历】
题目：
给定一个二叉树其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的next指针。下图为一棵有9个节点的二叉树。树中从父节点指向子节点的指针用实线表示，从子节点指向父节点的用虚线表示
示例:
输入:{8,6,10,5,7,9,11},8
返回:9
解析:这个组装传入的子树根节点，其实就是整颗树，中序遍历{5,6,7,8,9,10,11}，根节点8的下一个节点就是9，应该返回{9,10,11}，后台只打印子树的下一个节点，所以只会打印9，如下图，其实都有指向左右孩子的指针，还有指向父节点的指针，下图没有画出来
解题思路：
思路：中序遍历，找到这个节点的下一个节点， 首先要找到这个节点
中序遍历得用递归或者栈实现, 用递归实现后发现那个条件无法判断
** 重点不是要实现中序遍历，而是要根据中序遍历的思想设计判断条件
可以从中序遍历的思想入手 设计判断条件
- 若该节点有右节点, 则输出右子树的最左孩子
- 若该节点无右节点，则看 该节点是否是 其父节点的左孩子， 若是，输出其父节点
- 若该节点无右节点, 则顺着该结点回溯，知道找到一个节点 是其父节点的左孩子， 输出其父节点
代码：
/*
public class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null;
TreeLinkNode(int val) {
this.val = val;
}
}
*/
// 思路：中序遍历，找到这个节点的下一个节点， 首先要找到这个节点
// 中序遍历得用递归或者栈实现, 用递归实现后发现那个条件无法判断
// ** 重点不是要实现中序遍历，而是要根据中序遍历的思想设计判断条件
// 可以从中序遍历的思想入手 设计判断条件
// 1. 若该节点有右节点, 则输出右子树的最左孩子
// 2. 若该节点无右节点，则看 该节点是否是 其父节点的左孩子， 若是，输出其父节点
// 3. 若该节点无右节点, 则顺着该结点回溯，知道找到一个节点 是其父节点的左孩子， 输出其父节点
public class Solution {
int inputNum;
TreeLinkNode result;
public TreeLinkNode GetNext(TreeLinkNode pNode) {
if(pNode.right != null) { // 1. 若该节点有右节点, 则输出右子树的最左孩子
pNode = pNode.right;
while(pNode.left != null) { // 找到右子树的最左孩子
pNode = pNode.left;
}
return pNode;
} else{
if(pNode.next != null){ // 若该节点有父节点，则进入 2 和 3 的判断
while(pNode.next != null){ // 沿着该节点的父节点回溯
if(pNode.next.left == pNode) { // 只要找到一个节点是其 父节点 的左节点就返回
return pNode.next;
} else {
pNode = pNode.next;
}
}
return null;
} else {
return null;
}
}
}
}
JZ52 两个链表的第一个公共结点 【双指针】
题目：
输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
数据范围： n \le 1000n≤1000
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)
例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：
思路：
比起直接用 n 2 n^2 n2的暴力解法，可以注意到 链1 的长度是 a + c, 链2的长度是 b + c, 二者都走了 a + b + c 的长度时就到达了相同的节点了。
代码：
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
ListNode p1 = pHead1;
ListNode p2 = pHead2;
// 若有一个链表为空，则二者不可能用公共节点
if(p1 == null || p2 == null) return null;
// 若p1和p2不等，一直向后循环
while(p1 != p2){
p1 = p1.next;
p2 = p2.next;
// 当p1和p2相等时，直接返回
if(p1 == p2) return p1;
// p1 和 p2 走完第一遍遍历时，互相指向对方的头指针
// 假设链表1 的长度是：a + c
// 链表2 的长度是：b + c
// 则两个指针遍历走完后的长度都是 a + b + c
if(p1 == null) p1 = pHead2;
if(p2 == null) p2 = pHead1;
}
return p1;
}
}
JZ31 栈的压入、弹出序列
题目：
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。
- 0<=pushV.length == popV.length <=1000
- -1000<=pushV[i]<=1000
- pushV 的所有数字均不相同
思路：
利用栈和指针，把压入队列中的数字都按序压入栈中，维持着弹出队列的指针，将栈顶和弹出队列 指针指向节点做比较，若相等，则栈弹出，且弹出队列指针后移。 直至最后判断 栈是否为空，以及 弹出队列指针是否到头。
代码：
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
if(pushA.length == 0) return false;
int p1 = 0, p2 = 0;
Stack<Integer> s = new Stack<Integer>();
while(p1 < pushA.length){
s.push(pushA[p1]);
p1++;
while(!s.empty() && s.peek() == popA[p2]){
s.pop();
p2++;
}
}
if(s.empty() && p2 == popA.length){
return true;
} else {
return false;
}
}
}
JZ 84 二叉树中和为某一值的路径(三)
题目：
给定一个二叉树root和一个整数值 sum ，求该树有多少路径的的节点值之和等于 sum 。
1.该题路径定义不需要从根节点开始，也不需要在叶子节点结束，但是一定是从父亲节点往下到孩子节点
2.总节点数目为n
3.保证最后返回的路径个数在整形范围内(即路径个数小于231-1)
假如二叉树root为{1,2,3,4,5,4,3,#,#,-1}，sum=6，那么总共如下所示，有3条路径符合要求
思路：
利用双重递归
代码：
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @param sum int整型
* @return int整型
*/
// 思路：用两个迭代
public int CalSum(TreeNode root, int sum){
if(root == null) return 0;
int result = 0;
if(root.val == sum) result += 1;
return result + CalSum(root.left, sum-root.val) + CalSum(root.right, sum-root.val);
}
public int FindPath (TreeNode root, int sum) {
// write code here
if(root == null) return 0;
return CalSum(root, sum) + FindPath(root.left, sum) + FindPath(root.right, sum);
}
}
加油，坚持本身是最重要的，和自己比有进步就是胜利！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
