目录
● 请你说一下BST的特点，并手写代码判断一棵树是不是BST
● 请你说一下BST的特点，并手写代码判断一棵树是不是BST
参考回答：
BST（二叉排序树）：
1、每个结点都有一个作为搜索依据的关键码，所有结点的关键码不同
2、左子树上所有结点的关键码小于根节点的关键码
3、右子树所有结点的关键码大于根节点的关键码
4、左子树和右子树也是BST
判断一棵树是不是BST
class Node {
int data;
Node left;
Node right;
}
public class BSTChecker {
private static int lastVisit = Integer.MIN_VALUE;
public static boolean isBST(Node root) {
if(root == null) return true;
boolean judgeLeft = isBST(root.left); // 先判断左子树
if(root.data >= lastVisit && judgeLeft) { // 当前节点比上次访问的数值要大
lastVisit = root.data;
} else {
return false;
}
boolean judgeRight = isBST(root.right); // 后判断右子树
return judgeRight;
}
}
● 手写代码：给一个二叉树，怎么得到这棵树的镜像
参考回答：
public class Solution {
public void Mirror(TreeNode root) {
if(root==null){
return;
}
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
Mirror(root.left);
Mirror(root.right);
}
}
● 手写代码：通过前序和中序还原二叉树
参考回答：
//算法1
#include <iostream>
#include <fstream>
#include <string>
struct TreeNode
{
struct TreeNode* left;
struct TreeNode* right;
char elem;
};
TreeNode* BinaryTreeFromOrderings(char* inorder, char* preorder, int length)
{
if(length == 0)
{
return NULL;
}
TreeNode* node = new TreeNode;
node->elem = *preorder;
int rootIndex = 0;
for(;rootIndex < length; rootIndex++)
{
if(inorder[rootIndex] == *preorder)
break;
}
node->left = BinaryTreeFromOrderings(inorder, preorder +1, rootIndex);
node->right = BinaryTreeFromOrderings(inorder + rootIndex + 1, preorder + rootIndex + 1, length - (rootIndex + 1));
std::cout<<node->elem<<std::endl;
free(node);
return NULL;
}
int main(int argc, char** argv){
char* pr="GDAFEMHZ";
char* in="ADEFGHMZ"; BinaryTreeFromOrderings(in, pr, 8); printf("\n"); return 0;}
● 手写代码：求二叉树每层最大值
参考回答：
思路：遍历树，给树的每一个节点赋予层数的信息，定义一个数组maxNum数组，存储每层中最大值，其下标i对应于树中的第i层，其中根节点为第0层。在遍历某个树节点时，先判断该节点的层数与当前数组中已存储的数是否相等，若相等，则将该节点值与当前数组最后一位值进行比较，数组取其中的最大值。若不相等，则该节点为该层第一个节点，直接将该节点值赋值给数组对应的位。深度遍历该二叉树，最后输出这个数组即可。
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
if(root == NULL) {
return maxNum;
}
travel(root,level);
return maxNum;
}
TreeNode* travel(TreeNode* root, int level) {
if(!root) return NULL;
if(maxNum.size() < level + 1) {
maxNum.push_back(root->val);
} else {
maxNum[level] = max(root->val,maxNum[level]);
}
travel(root->left,level+1);
travel(root->right,level+1);
return root;
}
private:
int level = 0;
vector<int> maxNum;
};
● 手写代码：两个平衡二叉树合并是怎么做的
参考回答：
首先，将两棵树分别展开为有序链表
public TreeNode prev = null;
public void BSTtoLinkedList(TreeNode root) {
if (root == null) return;
BSTtoLinkedList(root.left);
if (prev != null) {
prev.right = root;
prev.left = null;
}
prev = root;
BSTtoLinkedList(root.right);
}
然后将两个有序链表合并
public TreeNode MergeTwoLinkedList(TreeNode n1, TreeNode n2) {
TreeNode head = new TreeNode();
while (n1 != null && n2 != null) {
if (n1.val < n2.val) {
head.right = n1;
n1 = n1.right;
} else {
head.right = n2;
n2= n2.right;
}
head = head.right;
}
if (n1 != null) {
head.right = n1;
head = head.right;
}
if (n2 != null) {
head.right = n2;
head = head.right;
}
return head.right;
}
● 手写代码：求全体二叉树节点最大值
参考回答：
public int maxTreeNode(TreeNode root) {
if (root.left == null && root.right == null) {
return root.val;
} else {
if (root.left != null && root.right != null) {
return root.val > maxTreeNode(root.left) ? (root.val > maxTreeNode(root.right) ? root.val
: maxTreeNode(root.right))
: (maxTreeNode(root.left) > maxTreeNode(root.right) ? maxTreeNode(root.left)
: maxTreeNode(root.right));
} else if (root.left == null && root.right != null) {
return root.val > maxTreeNode(root.right) ? root.val
: maxTreeNode(root.right);
} else {
return root.val > maxTreeNode(root.left) ? root.val
: maxTreeNode(root.left);
}
}
}
● 手写代码：二叉树深度优先遍历
参考回答：
//深度优先搜索
//利用栈，现将右子树压栈再将左子树压栈
void DepthFirstSearch(BitNode *root)
{
stack<BitNode*> nodeStack;
nodeStack.push(root);
while (!nodeStack.empty())
{
BitNode *node = nodeStack.top();
cout << node->data << ' ';
nodeStack.pop();
if (node->right)
{
nodeStack.push(node->right);
}
if (node->left)
{
nodeStack.push(node->left);
}
}
}