本文章记录一些二叉树的基本操作:
先来准备一个简单的树的节点:
//节点类
class Node{
int value;//节点值
Node left;//左子树
Node right;//右子树
public Node(int v){ this.value = v; }
}
递归遍历
前序遍历
//递归前序遍历
static void preOrderShow(Node node){
if (node==null) return;
System.out.print(node.value+" ");
preOrderShow(node.left);
preOrderShow(node.right);
}
中序遍历
//递归中序遍历
static void inOrderShow(Node node){
if (node==null) return;
preOrderShow(node.left);
System.out.print(node.value+" ");
preOrderShow(node.right);
}
后序遍历
//递归后序遍历
static void tailOrderShow(Node node){
if (node==null) return;
preOrderShow(node.left);
preOrderShow(node.right);
System.out.print(node.value+" ");
}
非递归遍历
前序遍历
//非递归前序遍历
static void preOrderShow1(Node node){
Stack<Node> stack = new Stack<>();
Node p = node;//用一个p指针指向当前的节点
while(p!=null||stack.size()>0){
if (p!=null){
System.out.print(p.value+" ");//输出p节点的值
stack.push(p);
p = p.left;
}else{
p = stack.pop();
p = p.right;
}
}
}
中序遍历
//非递归中序遍历
static void inOrderShow1(Node node){
Stack<Node> stack = new Stack<>();
Node p = node;//用一个p指针指向当前的节点
while(p!=null||stack.size()>0){
if (p!=null){
stack.push(p);
p = p.left;
}else{
p = stack.pop();
System.out.print(p.value+" ");//输出p节点的值
p = p.right;
}
}
}
后序遍历
//非递归后序遍历
static List<Integer> tailOrderShow1(Node node){
Stack<Node> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
queue.push(node);
while(stack.size()>0){
Node node1 = stack.pop();
list.add(node1.value);
if (node1.left!=null) stack.push(node1.left);
if (node1.right!=null) stack.push(node1.right);
}
Collections.reverse(list);
return list;
}
层次遍历
//层次遍历
static void levelShow(Node node){
//模拟队列
LinkedList<Node> queue = new LinkedList<>();
//把头节点加入队列
queue.addLast(node);
//当前节点指针
Node p;
while(queue.size()>0){
//出队列
p = queue.removeFirst();
System.out.print(p.value+" ");
//左节点进队列
if (p.left!=null) queue.addLast(p.left);
//右节点进队列
if (p.right!=null) queue.addLast(p.right);
}
}
分层输出的层次遍历
//层次遍历分层输出
static void levelShow1(Node node){
//模拟队列
LinkedList<Node> queue = new LinkedList<>();
//把头节点加入队列
queue.addLast(node);
//当前节点指针
Node p;
//记录的当前行最后一个节点
Node currentlastNode = node;
//记录下一行的最后一个节点
Node nextlastNode = null;
while(queue.size()>0){
p = queue.removeFirst();
System.out.print(p.value+" ");
//左节点进队列
if (p.left!=null){
queue.addLast(p.left);
nextlastNode = p.left;
}
//右节点进队列
if (p.right!=null) {
queue.addLast(p.right);
nextlastNode = p.right;
}
//如当前遍历的节点是记录行的最后一个节点,证明当前行已经遍历结束了,输出换行符
//把下一行的最后一个节点赋给当前行最后一个节点
if (currentlastNode==p) {
System.out.println();
currentlastNode = nextlastNode;
}
}
}
删除子树
//删除子树,返回新的树根结点
static Node deleteChild(Node node,int val){
//树为null直接返回null
if (node==null) return null;
//要删除的是根节点,返回新的树根节点就是null
if (val==node.value) return null;
//发现左子树的值是需要删除的节点,把左子树设为null;
if (node.left!=null&&val==node.left.value){
node.left=null;
return node;
}
//发现右子树的值是需要删除的节点,把右子树设为null;
else if (node.right!=null&&val==node.right.value) {
node.right = null;
return node;
}
//左右子树都不是,在左右子树上递归寻找
else {
deleteChild(node.left,val);
deleteChild(node.right,val);
return node;
}
}
求树的深度
//求树的深度
static int depth(Node node){
//如node为null,深度为0
if (node==null) return 0;
//求出左子树的高度
int leftDepth = depth(node.left);
//求出右子树的高度
int rightDepth = depth(node.right);
//左右子树高度的最大值加上1就是本节点的高度
return Math.max(leftDepth,rightDepth)+1;
}
数组构建哈夫曼树
//构建哈夫曼树
static Node haff(int[] arr) {
List<Node> list = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
list.add(new Node(arr[i]));
}
while (list.size() > 1) {
Collections.sort(list, (o1, o2) -> o1.value - o2.value);
Node n1 = list.get(0);
Node n2 = list.get(1);
Node parent = new Node(n1.value + n2.value);
parent.left = n1;
parent.right = n2;
list.remove(n1);
list.remove(n2);
list.add(parent);
}
Node node = list.get(0);
return node;
}
}
平衡二叉树
添加节点
//平衡二叉树添加节点(root!=null)
static void addNode(Node root,Node node){
if (node==null) return;
if (node.value<=root.value){
if (root.left==null) root.left = node;
else addNode(root.left,node);
}else{
if (root.right==null) root.right = node;
else addNode(root.right,node);
}
}
左旋
//平衡二叉树的左旋,返回新头节点
static Node leftRotate(Node node){
Node newRoot = node.right;
node.right = newRoot.left;
newRoot.left = node;
return newRoot;
}
右旋
//平衡二叉树的右旋,返回新的头节点
static Node rightRotate(Node node){
Node newRoot = node.left;
node.left = newRoot.right;
newRoot.right = node;
return newRoot;
}
自调整
//平衡二叉树的自调整
static Node rotate(Node node){
//空树直接返回
if (node==null) return node;
//左子树深度-右子树>1,需要右旋
if (depth(node.left)-depth(node.right)>1) {
//判断左子树需不需要先左旋
if (node.left != null && depth(node.left.right) > depth(node.left.left)){
node.left = leftRotate(node.left);
}
return rightRotate(node);
}
//右子树深度-左子树>1,需要左旋
if (depth(node.right)-depth(node.left)>1) {
//判断右子树需不需要先右旋
if (node.right!=null&&depth(node.right.left)>depth(node.right.right)){
node.right = rightRotate(node.right);
}
return leftRotate(node);
}
return node;
}