本文详细介绍了二叉树的概念，包括其基本形态、特殊类型的二叉树如满二叉树和完全二叉树的定义。讨论了二叉树的性质，如节点数量与层数的关系，以及二叉树的链式存储结构。同时，文章涵盖了二叉树的各种遍历方法，包括前序、中序、后序和层序遍历，并提供了非递归实现的代码示例。此外，还介绍了如何通过栈进行非递归遍历。
什么是二叉树？
一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树的特点：
- 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
- 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。
二叉树的基本形态
上图给出的二叉树是不同的二叉树
几种特殊的二叉树：空树、只有根节点的二叉树、节点只有左子树、节点只有右子树、节点的左右子树均存在，一般二叉树都是由上述基本形态结合而形成的。
特殊的二叉树
- 满二叉树:一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 2 k − 1 2^k-1 2k−1 ，则它就是满二叉树。
- 完全二叉树:完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点 一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
二叉树性质
- 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2 i − 1 2^{i-1} 2i−1(i>0)个结点
- 若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 2 k − 1 2^k-1 2k−1(k>=0)
- 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
- 具有n个结点的完全二叉树的深度k为 l o g 2 ( n + 1 ) log_2(n+1) log2(n+1)上取整
- 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有：
若i>0，双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
若2i+1<n，左孩子序号：2i+1，否则无左孩子
若2i+2<n，右孩子序号：2i+2，否则无右孩子
二叉树的表示
二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式，具体如下：
// 孩子表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}
// 孩子双亲表示法
class Node {
int val; // 数据域
Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
Node parent; // 当前节点的根节点
}
二叉树基本操作
- 先序遍历：先访问根节点，然后递归遍历左子树，最后递归遍历右子树。ABDEGCF
- 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。DBGEAFC
- 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。DGEBFCA
- 层序遍历：按照从上到下，从左到右的顺序依次遍历.ABCDEFG
二叉树遍历
如果是链表或者顺序表，就直接 for 循环就可以达到遍历的方法，由于二叉树是非线性的结构，所以仅用循环搞不定。
二叉树基本操作
class Node {
String val;
Node left;
Node right;
public Node(String val) {
this.val = val;
}
}
public class BinaryTree {
// 先序遍历
public static void preOrder(Node root) {
// 空树
if (root == null) {
return;
}
// 利用递归
System.out.print(root.val);
// 左子树
preOrder(root.left);
// 右子树
preOrder(root.right);
}
// 中序遍历
public static void inOrder(Node root) {
// 空树
if (root == null){
return;
}
inOrder(root.left);
System.out.print(root.val);
inOrder(root.right);
}
// 后序遍历
public static void lastOrder(Node root) {
// 空树
if (root == null) {
return;
}
// 左子树
lastOrder(root.left);
// 右子树
lastOrder(root.right);
System.out.print(root.val);
}
// 求节点个数
// 利用 count 记录元素个数
public static int count = 0;
public static void length(Node root) {
if (root == null) {
return;
}
// 根节点
count++;
// 左子树
length(root.left);
// 右子树
length(root.right);
}
// 返回值记录元素个数
public static int length2(Node root) {
if (root == null) {
return 0;
}
return 1 + length2(root.left) + length2(root.right);
}
// 求叶子结点个数
public static int leafSize = 0;
public static void getLeafSize(Node root) {
if (root == null) {
return;
}
if (root.left == null && root.right == null) {
leafSize++;
}
getLeafSize(root.left);
getLeafSize(root.right);
}
// 返回叶子结点个数
public static int getLeafSize2(Node root) {
if (root == null) {
return 0;
}
if (root.left == null && root.right == null) {
// 满足叶子结点
return 1;
}
return getLeafSize2(root.left) + getLeafSize2(root.right);
}
// 第 k 层结点个数
public static int getKLevelSize(Node root, int k) {
// 特殊情况
if (root == null || k < 1) {
return 0;
}
if (k == 1) {
// 树非空，且 k = 1
return 1;
}
// 递归
return getKLevelSize(root.left, k - 1) + getKLevelSize(root.right, k -1);
}
// 树的深度
public static int getHeight(Node root) {
// 空树返回 0
if (root == null) {
return 0;
}
// 递归
int leftHeight = getHeight(root.left);
int rightHeight = getHeight(root.right);
return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}
// 查找结点
public static Node find(Node root, String toFind) {
if (root == null) {
return null;
}
if (root.val.equals(toFind)) {
return root;
}
Node result = find(root.left,toFind);
if (result != null) {
return result;
}
return find(root.right,toFind);
}
}
二叉树层序遍历
设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节
点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问
树的结点的过程就是层序遍历。
ABCEDFG
构建思路：
- 取队首元素，并打印。
- 将该元素的左子树入队列（非空），右子树入队列（非空）。
- 重复1操作。
public static void levelOrder(TreeNode root) {
// 层序遍历，借用队列
if (root == null) {
return;
}
Queue<TreeNode> queue = new LinkedList<>();
// root 不为空入队列
queue.offer(root);
while (true) {
TreeNode first = queue.poll();
if (first == null) {
// 当前节点为空，跳出循环
break;
}
// 访问元素，并打印
System.out.print(first.val);
if (first.left != null) {
queue.offer(first.left);
}
if (first.right != null) {
queue.offer(first.right);
}
}
}
二叉树非递归实现遍历
前序遍历
实现思路：
- 先创建一个栈，把根节点入栈。
- 循环取栈顶元素，访问该元素，打印并出栈。
- 把该元素的右子树入栈，再把该元素左子树入栈。
- 重复1操作。
public static void preOrderNoR(TreeNode root) {
if (root == null) {
return;
}
// 创建栈，
Stack<TreeNode> stack = new Stack<>();
// 根节点入栈
stack.push(root);
// 循环入栈顶元素，右子树入栈，左子树入栈
while (! stack.isEmpty()) {
// 弹出并打印
TreeNode cur = stack.pop();
System.out.print(cur.val);
// 右子树入栈
if (cur.right != null) {
stack.push(cur.right);
}
// 左子树入栈
if (cur.left != null) {
stack.push(cur.left);
}
}
}
中序遍历
实现思路：
- 先创建一个栈（模拟递归过程）
- 创建一个引用 cur 从 root 出发，一次往左走，将所有节点都入栈，直到 cur == null，循环结束。
- 去除栈顶元素（此时栈顶元素是左子树最后一个节点），访问这个元素。
- 将 cur 指向当前栈顶元素的右子树，重复2操作。
public static void inOrderNoR(TreeNode root) {
// 利用栈
if (root == null) {
// 空树
return;
}
Stack<TreeNode> stack = new Stack<>();
// 寻找左子树最后一个元素
TreeNode cur = root;
while (true) {
while (cur != null) {
stack.push(cur);
cur = cur.left;
// 次循环结束栈顶元素是左子树最后一个节点
}
if (stack.isEmpty()) {
break;
}
// 取栈顶元素，并打印
TreeNode top = stack.pop();
System.out.print(top.val);
// 更新指向
cur = top.right;
}
}
后序遍历
实现思路：
- 创建一个栈。
- 创建一个引用 cur 从 root 出发，一直往左走，将遇到非空节点入栈。
- 取栈顶元素（此时栈顶元素就是右子树最后一个元素），此节点是否直接访问需要判断。
如果该元素的右子树为 null ，就可以访问这个节点
如果该元素的右子树 ！null ，并且并且右子树已经访问过了，就可以访问该元素。
如果该元素右子树 ！null，并且这个右子树之前没有被访问过，就让 cur 指向当前元素的右子树，重复2操作。
public static void postOrderNoR(TreeNode root) {
if (root == null) {
return;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
// 记录当前节点前一个节点
TreeNode prev = null;
while (true) {
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
if (stack.isEmpty()) {
break;
}
// 访问栈顶元素
TreeNode top = stack.peek();
if (top.right == null || prev == top.right) {
System.out.print(top.val);
stack.pop();
prev = top;
} else {
// 指向节点右子树，重复循环
cur = top.right;
}
}
}
扫一扫
262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
