前言：题图无关，现在开始来学习学习树相关的知识

前序文章：

数据结构与算法(1)——数组与链表（https://www.jianshu.com/p/7b93b3570875）
数据结构与算法(2)——栈和队列(https://www.jianshu.com/p/5087c751cb42)

树

什么是树

树是一种类似于链表的数据结构，不过链表的结点是以线性方式简单地指向其后继结点，而树的一个结点可以指向许多个结点；数是一种典型的非线性结构；树结构是以表达具有层次特性的图结构的一种方法；

二叉树

如果一棵树中的每个结点有0，1或者2个孩子结点，那么这棵树就称为二叉树；空树也是一颗有效的二叉树，一颗二叉树可以看做是由根节点和两棵不相交的子树（分别称为左子树和右子树）组成，如下图所示。

二叉树的类型

严格二叉树：二叉树中的每个节点要么有两个孩子结点，要么没有孩子结点

满二叉树：二叉树中的每个结点恰好有两个孩子结点且所有叶子结点都在同一层

完全二叉树：在定义完全二叉树之前，假定二叉树的高度为h；对于完全二叉树，如果将所有结点从根节点开始从左至右，从上至下，依次编号（假定根节点的编号为1），那么僵得到从1~n（n为结点总数）的完整序列，在遍历过程中对于空指针也赋予编号，如果所有伽椰子结点的深度为h或h-1，且在结点编号序列中没有漏掉任何数字，那么这样的二叉树叫作完全二叉树。

二叉树的应用

编译器中的表达式树；
用于数据压缩算法中的赫夫曼编码树；
支持在集合中查找、插入和删除，其平均时间复杂度为O(lognn)的二叉搜索树（BST）；
优先队列（PQ），它支持以对数时间（最坏情况下）对集合中的最小（或最大）数据元素进行搜索和删除；

二叉树的遍历

访问树中所有结点的过程叫作树的遍历，在遍历过程中，每个结点只能被处理一次，尽管其有可能被访问多次；根据结点处理顺序的不同，。可以定义不同的遍历方法，遍历分类可以根据当前节点被处理的顺序来划分：

前序遍历

在前序遍历中，每个结点都是在它的子树遍历之前进行处理，这是最容易理解的便利方法，然而，尽管每个结点在其子树之前进行了处理，但在向下移动的过程仍然需要保留一些信息，以上图为例，首先访问结点1，随后遍历其左子树，最后遍历其右子树，因此当左子树遍历完后，必须要返回到其右子树来继续遍历；为了能够在左子树遍历完成后移动到右子树，必须保留根节点的信息，能够实现该信息存储的抽象数据类型显而易见是栈，由于它是LIFO的结构，所以它可以以逆序来汇过去该信息并返回到右子树；

前序遍历可以如下定义：

访问根节点；
按前序遍历方式遍历左子树；
按前序遍历方式遍历右子树；

利用前序遍历方法上图所示的树的输出序列为：1 2 4 5 3 6 7

void preOrder(BinaryTreeNode root) {if (null != root) {System.out.println(root.getData());preOrder(root.getLeft());preOrder(root.getRight());}
}

中序遍历

在中序遍历中，根节点的访问在两棵子树的遍历中间完成，中序遍历如下定义：

按中序遍历方式遍历左子树；
访问根节点；
按中序遍历方式遍历右子树；

基于中序遍历，上图所示树的中序遍历输出顺序为：4 2 5 1 6 3 7

void inOrder(BinaryTreeNode root) {if (null != root) {inOrder(root.getLeft());System.out.println(root.getData());inOrder(root.getRight());}
}

后序遍历

在后续遍历中，根节点的访问是在其两棵子树都遍历完成后进行的，后续遍历如下定义：

按后序遍历左子树；
按后序遍历右子树；
访问根节点；

对上图所示的二叉树，后续遍历产生的输出序列为：4 5 2 6 7 3 1

void postOrder(BinaryTreeNode root) {if (null != root) {postOrder(root.getLeft());postOrder(root.getRight());System.out.println(root.getData());}
}

层次遍历

层次遍历的定义如下：

访问根节点；
在访问第l层时，将l+1层的节点按顺序保存在队列中；
进入下一层并访问该层的所有结点；
重复上述操作直至所有层都访问完；

对于上图所示的二叉树，层次遍历产生的输出序列为：1 2 3 4 5 6 7

void levelOrder(BinaryTreeNode root) {BinaryTreeNode temp;LoopQueue Q = new LoopQueue();if (null == root) {return;}Q.enqueue(root);while (!Q.isEmpty()) {temp = Q.dequeue();// 处理当前节点System.out.println(temp.getData());if (temp.getLeft()) {Q.enqueue(temp.getLeft());}if (temp.getRight()) {Q.enqueue(temp.getRight());}}// 删除队列中的所有数据Q.deletequeue();
}

二叉搜索树

在二叉搜索树中，所有左子树结点的元素小于根节点的数据，所有右子树结点的元素大于根节点数据，注意，树中的每个结点都应满足这个性质；

实现自己的二叉搜索树

其中包含了常用的一些方法，包括几种遍历方法还有查询、删除等，仅供参考：

public class BST<E extends Comparable<E>> {private class Node{public E e;public Node left, right;public Node(E e){this.e = e;left = null;right = null;}}private Node root;private int size;public BST(){root = null;size = 0;}public int size(){return size;}public boolean isEmpty(){return size == 0;}// 向二分搜索树中添加新的元素epublic void add(E e){root = add(root, e);}// 向以node为根的二分搜索树中插入元素e，递归算法// 返回插入新节点后二分搜索树的根private Node add(Node node, E e){if(node == null){size ++;return new Node(e);}if(e.compareTo(node.e) < 0)node.left = add(node.left, e);else if(e.compareTo(node.e) > 0)node.right = add(node.right, e);return node;}// 看二分搜索树中是否包含元素epublic boolean contains(E e){return contains(root, e);}// 看以node为根的二分搜索树中是否包含元素e, 递归算法private boolean contains(Node node, E e){if(node == null)return false;if(e.compareTo(node.e) == 0)return true;else if(e.compareTo(node.e) < 0)return contains(node.left, e);else // e.compareTo(node.e) > 0return contains(node.right, e);}// 二分搜索树的前序遍历public void preOrder(){preOrder(root);}// 前序遍历以node为根的二分搜索树, 递归算法private void preOrder(Node node){if(node == null)return;System.out.println(node.e);preOrder(node.left);preOrder(node.right);}// 二分搜索树的非递归前序遍历public void preOrderNR(){Stack<Node> stack = new Stack<>();stack.push(root);while(!stack.isEmpty()){Node cur = stack.pop();System.out.println(cur.e);if(cur.right != null)stack.push(cur.right);if(cur.left != null)stack.push(cur.left);}}// 二分搜索树的中序遍历public void inOrder(){inOrder(root);}// 中序遍历以node为根的二分搜索树, 递归算法private void inOrder(Node node){if(node == null)return;inOrder(node.left);System.out.println(node.e);inOrder(node.right);}// 二分搜索树的后序遍历public void postOrder(){postOrder(root);}// 后序遍历以node为根的二分搜索树, 递归算法private void postOrder(Node node){if(node == null)return;postOrder(node.left);postOrder(node.right);System.out.println(node.e);}// 二分搜索树的层序遍历public void levelOrder(){Queue<Node> q = new LinkedList<>();q.add(root);while(!q.isEmpty()){Node cur = q.remove();System.out.println(cur.e);if(cur.left != null)q.add(cur.left);if(cur.right != null)q.add(cur.right);}}// 寻找二分搜索树的最小元素public E minimum(){if(size == 0)throw new IllegalArgumentException("BST is empty!");return minimum(root).e;}// 返回以node为根的二分搜索树的最小值所在的节点private Node minimum(Node node){if(node.left == null)return node;return minimum(node.left);}// 寻找二分搜索树的最大元素public E maximum(){if(size == 0)throw new IllegalArgumentException("BST is empty");return maximum(root).e;}// 返回以node为根的二分搜索树的最大值所在的节点private Node maximum(Node node){if(node.right == null)return node;return maximum(node.right);}// 从二分搜索树中删除最小值所在节点, 返回最小值public E removeMin(){E ret = minimum();root = removeMin(root);return ret;}// 删除掉以node为根的二分搜索树中的最小节点// 返回删除节点后新的二分搜索树的根private Node removeMin(Node node){if(node.left == null){Node rightNode = node.right;node.right = null;size --;return rightNode;}node.left = removeMin(node.left);return node;}// 从二分搜索树中删除最大值所在节点public E removeMax(){E ret = maximum();root = removeMax(root);return ret;}// 删除掉以node为根的二分搜索树中的最大节点// 返回删除节点后新的二分搜索树的根private Node removeMax(Node node){if(node.right == null){Node leftNode = node.left;node.left = null;size --;return leftNode;}node.right = removeMax(node.right);return node;}// 从二分搜索树中删除元素为e的节点public void remove(E e){root = remove(root, e);}// 删除掉以node为根的二分搜索树中值为e的节点, 递归算法// 返回删除节点后新的二分搜索树的根private Node remove(Node node, E e){if( node == null )return null;if( e.compareTo(node.e) < 0 ){node.left = remove(node.left , e);return node;}else if(e.compareTo(node.e) > 0 ){node.right = remove(node.right, e);return node;}else{   // e.compareTo(node.e) == 0// 待删除节点左子树为空的情况if(node.left == null){Node rightNode = node.right;node.right = null;size --;return rightNode;}// 待删除节点右子树为空的情况if(node.right == null){Node leftNode = node.left;node.left = null;size --;return leftNode;}// 待删除节点左右子树均不为空的情况// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点// 用这个节点顶替待删除节点的位置Node successor = minimum(node.right);successor.right = removeMin(node.right);successor.left = node.left;node.left = node.right = null;return successor;}}@Overridepublic String toString(){StringBuilder res = new StringBuilder();generateBSTString(root, 0, res);return res.toString();}// 生成以node为根节点，深度为depth的描述二叉树的字符串private void generateBSTString(Node node, int depth, StringBuilder res){if(node == null){res.append(generateDepthString(depth) + "null\n");return;}res.append(generateDepthString(depth) + node.e +"\n");generateBSTString(node.left, depth + 1, res);generateBSTString(node.right, depth + 1, res);}private String generateDepthString(int depth){StringBuilder res = new StringBuilder();for(int i = 0 ; i < depth ; i ++)res.append("--");return res.toString();}
}

LeetCode相关题目整理

94.二叉树的中序遍历

我的答案：（1ms）

public List<Integer> inorderTraversal(TreeNode root) {List result = new ArrayList();if (null != root) {result.addAll(inorderTraversal(root.left));result.add(root.val);result.addAll(inorderTraversal(root.right));}return result;
}

参考答案：（0ms）

public List<Integer> inorderTraversal(TreeNode root) {List<Integer> list=new ArrayList<>();traversal(root, list);return list;
}public void traversal(TreeNode root,List<Integer> list) {if(root!=null){traversal(root.left, list);list.add(root.val);traversal(root.right, list);}
}

98. 验证二叉搜索树

我的答案：（53ms）

private static int INT_MIN = Integer.MIN_VALUE;
private static int INT_MAX = Integer.MAX_VALUE;public boolean isValidBST(TreeNode root) {// 如果节点为空则满足二叉搜索树条件if (null == root) {return true;}// 如果左孩子结点大于了根节点则返回falseif (null != root.left && findMax(root.left) > root.val) {return false;}// 如果右孩子结点小于了根节点则返回falseif (null != root.right && findMin(root.right) < root.val) {return false;}// 递归判断左子树和右子树，若其中有一颗不是BST树，则返回falseif (!isValidBST(root.left) || !isValidBST(root.right)) {return false;}// 通过所有判断则是一颗BST树return true;
}/*** 找到一颗非空树中的最大值** @param root* @return*/
private int findMax(TreeNode root) {int maxVal = INT_MIN;int leftMaxVal = INT_MIN;int rightMaxVal = INT_MIN;if (null != root) {// 最大值默认等于当前节点值maxVal = root.val;leftMaxVal = findMax(root.left);rightMaxVal = findMax(root.right);// maxVal等于当前maxVal与leftMaxVal中较大的一个maxVal = maxVal > leftMaxVal ? maxVal : leftMaxVal;// maxVal等于当前maxVal与rightMaxVal中较大的一个maxVal = maxVal > rightMaxVal ? maxVal : rightMaxVal;}return maxVal;
}/*** 找到一颗非空树的最小值** @param root* @return*/
private int findMin(TreeNode root) {int minVal = INT_MAX;int leftMinVal = INT_MAX;int rightMinVal = INT_MAX;if (null != root) {// 最小值默认为当前节点值minVal = root.val;leftMinVal = findMin(root.left);rightMinVal = findMin(root.right);// minVal等于当前minVal与leftMinVal中较小的一个minVal = minVal < leftMinVal ? minVal : leftMinVal;// minVal等于当前minVal与rightMinVal中较小的一个minVal = minVal < rightMinVal ? minVal : rightMinVal;}return minVal;
}

自己写的时候提交错了很多次..没有掌握到二分搜索树的精髓..

参考答案：（2ms）

public boolean isValidBST(TreeNode root) {if (root == null) return true;return valid(root, Long.MIN_VALUE, Long.MAX_VALUE);
}
public boolean valid(TreeNode root, long low, long high) {if (root == null) return true;if (root.val <= low || root.val >= high) return false;return valid(root.left, low, root.val) && valid(root.right, root.val, high);
}

这答案写得我服了..真服..

101. 对称二叉树（剑指Offer面试题28）

参考答案：（12ms）

public boolean isSymmetric(TreeNode root) {return isSymmetric(root, root);
}public boolean isSymmetric(TreeNode root1, TreeNode root2) {if (null == root1 && null == root2) {return true;}if (null == root1 || null == root2) {return false;}if (root1.val != root2.val) {return false;}return isSymmetric(root1.left, root2.right) && isSymmetric(root1.right, root2.left);
}

自己做的思路是使用中序遍历来判断（转成数组之后是对称的），但是出了很多问题，就是需要考虑null值，中序遍历中并不能很好地把一棵树保存为一个完整二叉树的样子..所以看了下参考答案..写得服..

104. 二叉树的最大深度（剑指Offer面试题55）

我的答案：（3ms）

public int maxDepth(TreeNode root) {int leftHeight, rightHeight;if (null == root) {return 0;} else { // 计算每个子树的高度leftHeight = maxDepth(root.left);rightHeight = maxDepth(root.right);return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;}
}

参考答案：（0ms）

public int maxDepth(TreeNode root) {if(root==null)return 0;return Math.max(maxDepth(root.left)+1,maxDepth(root.right)+1);
}

105. 从前序与中序遍历序列构造二叉树（剑指Offer面试题7）

参考答案：（2ms）

public TreeNode buildTree(int[] preorder, int[] inorder) {if (preorder == null || preorder.length == 0) {return null;}return buildTree(preorder, inorder, 0, 0, inorder.length - 1);
}private TreeNode buildTree(int[] preorder, int[] inorder, int ps, int is, int ie) {int val = preorder[ps];TreeNode node = new TreeNode(val);int iRoot = ie;while (iRoot > is) {if (val == inorder[iRoot]) {break;}iRoot--;}if (iRoot > is) {node.left = buildTree(preorder, inorder, ps + 1, is, iRoot - 1);}if (iRoot < ie) {node.right = buildTree(preorder, inorder, ps + 1 + (iRoot - is), iRoot + 1, ie);}return node;
}

思路是这样的：在二叉树的前序遍历序列中，第一个数字总是树的根节点的值，但在中序遍历序列中，根节点的值保存在序列的中间，左子树的节点的值位于根节点的值的左边，而右子树则相反，然后既然找到了左右子树我们又可以使用同样的方法在前序和中序中分别构建左右子树，这样我们就能够使用递归的方法完成；（上面算法中的ps、is、ie分别表示前序的开始位置，中序的开始位置和中序的结束位置；）

113. 路径总和 II（剑指Offer面试题34）

参考答案：（3ms）

public List<List<Integer>> pathSum(TreeNode root, int sum) {List<Integer> nodeList = new ArrayList<Integer>();List<List<Integer>> sumList = new ArrayList<List<Integer>>();if (root == null) {return sumList;}pathSum2(root, sum, sumList, nodeList);return sumList;
}public void pathSum2(TreeNode root, int target,List<List<Integer>> sumList, List<Integer> nodeList) {if (root.left == null && root.right == null) {nodeList.add(root.val);int sum = 0;for (Integer integer : nodeList) {sum += integer;}if (sum == target) {sumList.add(new ArrayList<Integer>(nodeList));}return;}nodeList.add(root.val);if (root.left != null) {pathSum2(root.left, target, sumList, nodeList);nodeList.remove(nodeList.size() - 1);}if (root.right != null) {pathSum2(root.right, target, sumList, nodeList);nodeList.remove(nodeList.size() - 1);}
}

230. 二叉搜索树中第K小的元素（类似剑指Offer面试题54）

我的答案：（23ms）

public int kthSmallest(TreeNode root, int k) {// 正确性判断if (null == root || k < 1) {return -1;}List<Integer> result = preOrder(root);// 从小到大排序Collections.sort(result);return result.get(k - 1);
}/*** 遍历整棵树并返回一个List** @param root* @return*/
private List<Integer> preOrder(TreeNode root) {List result = new ArrayList();if (null != root) {result.add(root.val);result.addAll(preOrder(root.left));result.addAll(preOrder(root.right));}return result;
}

贼蠢，完全没有用到二叉搜索树的特性

参考答案：（1ms）

public int kthSmallest(TreeNode root, int k) {int count = countNodes(root.left);if (k <= count) {return kthSmallest(root.left, k);} else if (k > count + 1) {return kthSmallest(root.right, k - 1 - count);}return root.val;
}public int countNodes(TreeNode n) {if (n == null) return 0;return 1 + countNodes(n.left) + countNodes(n.right);
}

449. 序列化二叉搜索树（类似剑指Offer面试题37）

参考答案：（12ms）

// Encodes a tree to a single string.
public String serialize(TreeNode root) {StringBuffer sb = new StringBuffer();preOrder(root,sb);return sb.toString();
}
private static void preOrder(TreeNode root, StringBuffer sb){if(root==null)return;sb.append(root.val).append('#');preOrder(root.left,sb);preOrder(root.right,sb);
}// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {if(data==null)return null;int val =0;TreeNode root = null;for(int i=0;i<data.length();i++){if(data.charAt(i)!='#'){val = val*10+(data.charAt(i)-'0');}else{root = insert(root,val);val=0;}}return root;
}
private static TreeNode insert(TreeNode root,int val){if(root==null)return new TreeNode(val);if(root.val<val)root.right = insert(root.right,val);elseroot.left = insert(root.left,val);return root;
}

572. 另一个树的子树（类似剑指Offer面试题26）

参考答案：（15ms）

public boolean isSubtree(TreeNode s, TreeNode t) {// Write your code hereif (s == null) {return t == null;}if (s.val == t.val && isSametree(s, t)) {return true;}return isSubtree(s.left, t) | isSubtree(s.right, t);
}private boolean isSametree(TreeNode s, TreeNode t) {if (s == null) {return t == null;}if (t == null) {return false;}if (s.val != t.val) {return false;}return isSametree(s.left, t.left) & isSametree(s.right, t.right);
}

我的第一个反应还是去把两棵树的前序遍历的数组弄出来然后判断是否为子集，但是树这样的天然递归结构这样写很自然...

简单总结

还是只是简单复习了一下树的相关知识吧，通过刷LeetCode题目还有参照着剑指Offer对二叉树、二叉搜索树仅仅这两种结构有了一个较深的认识，因为后续还会继续用到，所以这里简单复习一下也无所谓，不过看着题目倒是感觉这样的结构很容易考面试题啊，因为这些结构既重要考点又多...

欢迎转载，转载请注明出处！
简书ID：@我没有三颗心脏
github：wmyskxz

数据结构与算法(3)——树（二叉、二叉搜索树）相关推荐

数据结构---判断一棵树是否是二叉搜索树
数据结构-判断一棵树是否是二叉搜索树代码: #pragma once #define N 100 #define elemType BTree* #include<stdlib.h> t ...
CAUC数据结构与算法期末复习归纳（二）
CAUC数据结构与算法期末复习归纳(二) 二叉树二叉树的周游二叉树的抽象数据类型深度优先周游二叉树或其子树广度优先周游二叉树二叉树的存储结构二叉树的链式存储结构二叉搜索树二叉搜索树的性 ...
数据结构与算法——AVL树类的C++实现
关于AVL树的简单介绍能够參考: 数据结构与算法--AVL树简单介绍关于二叉搜索树(也称为二叉查找树)能够參考:数据结构与算法--二叉查找树类的C++实现 AVL-tree是一个"加上了额 ...
数据结构与算法--B树原理及实现
B树前几篇文中讨论的数据结构我们都是假设所有的数据都存储在计算机的主存中.可说总要那么海量的数据需要通过个中数据结构去存储,我们不可能有这么多内存区存放这些数据.那么意味着我们需要将他们放磁盘.所以 ...
《数据结构与算法》——树与二叉树之遍历总结
<数据结构与算法>--树与二叉树之遍历总结树与二叉树部分计划分为三次进行复习总结,第一次为基本概念和二叉树的遍历,第二次内容为线索二叉树以及树和森林,第三次为树与二叉树的应用. 目录 & ...
高级数据结构与算法 | AVL树（高度平衡树）
文章目录 AVL树实现思路数据结构查找平衡因子旋转右旋左旋右左双旋左右双旋插入删除 AVL树的验证中序遍历平衡判断 AVL树的性能完整代码实现 AVL树 AVL树是最先发明 ...
数据结构和算法——kd树
一.K-近邻算法 K-近邻算法是一种典型的无参监督学习算法,对于一个监督学习任务来说,其 m m个训练样本为: {(X(1),y(1)),(X(2),y(2)),⋯,(X(m),y(m))} \lef ...
数据结构与算法：树与二叉树python实现
最近复习一遍数据结构与算法,做一些笔记,大家可以一起复习. 一.树的一些容易混淆的定义: 结点层:根结点的层定义为1:根的孩子为第二层结点,依此类推: 树的深度(或高度):树中最大的结点层: 满二叉树 ...
数据结构与算法图解——树
文章目录 7. 树 7.1 树的逻辑结构 7.1.1 例题 7.2 树的基本术语 7.2.1 例题 7.3 二叉树的性质 7.3.1 性质1 7.3.2 性质2 7.3.3 性质3 7.3.4 性质4 ...

数据结构与算法(3)——树（二叉、二叉搜索树）

树