文章目录
六、二叉树
- 二叉树是一种树形结构，树种的每一个位置称为节点，每个节点储存它的值以及它左孩子的引用和右孩子的引用
- 方便起见，二叉树的结构就不用泛型进行实现，直接用整型实现
package tree;
public class TreeNode {
public int value;
public TreeNode left;
public TreeNode right;
public TreeNode(int value){
this.value = value;
}
}
1、二叉树的遍历递归实现(先序，中序，后续)
package tree;
public class RecursiveTravesalTree {
/**
* 二叉树先序遍历 根 - 左 - 右
* @param root
*/
public static void pres(TreeNode root){
if (root == null){
return;
}
System.out.print(root.value + " -> ");
pres(root.left);
pres(root.right);
}
/**
* 二叉树中序遍历 左 - 根 - 右
* @param root
*/
public static void in(TreeNode root){
if (root == null){
return;
}
in(root.left);
System.out.print(root.value + " -> ");
in(root.right);
}
/**
* 二叉树后序遍历 左 - 右 - 根
* @param root
*/
public static void pos(TreeNode root){
if (root == null){
return;
}
pos(root.left);
pos(root.right);
System.out.print(root.value + " -> ");
}
public static void main(String[] args) {
TreeNode node1 = new TreeNode(1);
TreeNode node2 = new TreeNode(2);
TreeNode node3 = new TreeNode(3);
TreeNode node4 = new TreeNode(4);
TreeNode node5 = new TreeNode(5);
TreeNode node6 = new TreeNode(6);
node1.left = node2;
node1.left.left = node4;
node1.right = node3;
node1.right.left = node5;
node1.right.right = node6;
pres(node1);
System.out.println();
in(node1);
System.out.println();
pos(node1);
}
}
2、二叉树的遍历非递归实现(先序，中序，后续)
2.1 先序
- 准备一个栈，先将根节点入栈。然后每次从栈中弹出一个节点，打印，如果有右孩子，右孩子先入栈，如果有左孩子，左孩子入栈，直到栈为空。因为先序是左孩子在右孩子前面，而栈是逆序，所有先放右孩子。因为从根节点开始它的每个孩子都入栈了，所有不会丢失节点。而每次弹出就先打印就是先序。
/**
* 先序遍历非递归
* @param root
*/
public static void pres(TreeNode root){
if (root == null){
return;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
TreeNode cur = null;
while (!stack.isEmpty()){
cur = stack.pop();
System.out.println(cur.value + " -> ");
if (cur.right != null){
stack.push(cur.right);
}
if(cur.left != null){
stack.push(cur.left);
}
}
System.out.println();
}
2.2 后序
- 前面已经有了先序遍历，如果在先序遍历中先放入左孩子，那么会变为 根 - 右 - 左，这刚好是后序遍历的逆序。所以我们在准备一个栈，每次弹出的时候不打印而是放入另外一个栈中，最后弹出就是根 - 右 - 左的逆序 左 - 右 - 根，也就是二叉树的后序遍历。
/**
* 非递归的后序遍历
* @param root
*/
public static void pos(TreeNode root) {
if (root == null) {
return;
}
Stack<TreeNode> stack = new Stack<>();
Stack<TreeNode> help = new Stack<>();
TreeNode cur = root;
stack.push(cur);
while (!stack.isEmpty()) {
cur = stack.pop();
help.push(cur);
if (cur.left != null) {
stack.push(cur.left);
}
if (cur.right != null) {
stack.push(cur.right);
}
}
while (!help.isEmpty()) {
System.out.print(help.pop().value + " -- ");
}
System.out.println();
}
2.3 中序
- 将一个二叉树用左树进行划分，即所有的数都是由某一个节点的左树构成
- 沿着一棵树最左边搜索下去，如果它没有孩子则就先输出它，下一次输出的是它父亲的右子树的最左节点
- 用cur记录下一个该去的节点，如果没有就遍历结束
/**
* 非递归的中序遍历
* @param root
*/
public static void in(TreeNode root){
if (root == null) {
return;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (!stack.isEmpty() || cur != null){
//有左孩子，一直搜寻到尽头
if (cur != null){
stack.push(cur);
cur = cur.left;
}else {
//没有左孩子了，弹出父亲节点，去右子树搜索
cur = stack.pop();
System.out.print(cur.value + " -> ");
cur = cur.right;
}
}
System.out.println();
}
3、二叉树的层序遍历
- 层序遍历思路很简单，用一个队列，先放根节点入队列。每次从队列中弹出一个值，打印，然后有左孩子放左孩子，有右孩子放右孩子。因为从上层开始，都是将本层的左右孩子依次放入队列，所有上层打印完才会轮到下层，这样就完成了层序遍历
package tree;
import java.util.LinkedList;
import java.util.Queue;
public class Code03_LevelTravesalTree {
public static void level(TreeNode root){
if (root == null){
return;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
TreeNode cur = null;
while (!queue.isEmpty()){
cur = queue.poll();
System.out.print(cur.value + " -> ");
if (cur.left != null){
queue.add(cur.left);
}
if(cur.right != null){
queue.add(cur.right);
}
}
System.out.println();
}
}
4 、二叉树的序列化与反序列化
- 二叉树可以进行先序，后序，层序的序列化，但是不能进行中序，因为中序有歧义，多个不同结构可能序列化相同
- 遇到null不可忽略，可以选择加入特殊字符，这样才能保证二叉树的结构可以辨识
4.1 先序的序列化与反序列化
-
这里的每个节点值用queue，list什么结果存储都可以
-
序列化和先序遍历一样，只不过将打印变为序列化值
-
反序列化也采用先序遍历的方式，先建立根节点，再挂左树，再挂右树
/**
* 二叉树的先序序列化
* @param root
* @return
*/
public static Queue<String> presSerial(TreeNode root){
Queue<String> queue = new LinkedList<>();
pres(root,queue);
return queue;
}
public static void pres(TreeNode node,Queue<String> queue){
if (node == null){
queue.add(null);
return;
}
queue.add(String.valueOf(node.value));
pres(node.left,queue);
pres(node.right,queue);
}
/**
* 二叉树的先序反序列化
* @param queue
* @return
*/
public static TreeNode buildByPres(Queue<String> queue){
if (queue == null || queue.size() < 1){
return null;
}
return preBuild(queue);
}
public static TreeNode preBuild(Queue<String> queue){
String value = queue.poll();
if (value == null){
return null;
}
TreeNode root = new TreeNode( Integer.parseInt(value));
root.left = preBuild(queue);
root.right = preBuild(queue);
return root;
}
4.2 层序的序列化与反序列化
- 这里和前面其实一样，用层序遍历进行改进，不打印而是直接放入队列
/**
* 二叉树的层序列化
* @param root
* @return
*/
public static Queue<String> levelSerial(TreeNode root) {
Queue<String> serial = new LinkedList<>();
if (root == null) {
serial.add(null);
} else {
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
serial.add(String.valueOf(root.value));
TreeNode cur = null;
while (!queue.isEmpty()) {
cur = queue.poll();
if (cur.left != null) {
queue.add(cur.left);
serial.add(String.valueOf(cur.left.value));
}else {
serial.add(null);
}
if (cur.right != null) {
queue.add(cur.right);
serial.add(String.valueOf(cur.right.value));
}else {
serial.add(null);
}
}
}
return serial;
}
/**
* 二叉树的层级反序列化
* @param levelList
* @return
*/
public static TreeNode buildByLevelTree(Queue<String> levelList){
if (levelList == null || levelList.size() < 1){
return null;
}
TreeNode root = generateNode(levelList.poll());
Queue<TreeNode> queue = new LinkedList<>();
if (root != null){
queue.add(root);
}
TreeNode node = null;
while (!queue.isEmpty()){
node = queue.poll();
node.left = generateNode(levelList.poll());
node.right = generateNode(levelList.poll());
if (node.left != null){
queue.add(node.left);
}
if (node.right != null){
queue.add(node.right);
}
}
return root;
}
public static TreeNode generateNode(String value){
if(value == null){
return null;
}
return new TreeNode(Integer.parseInt(value));
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
