数据结构——二叉树

最新推荐文章于 2022-06-09 18:51:16 发布
最新推荐文章于 2022-06-09 18:51:16 发布
阅读量224 收藏
点赞数
分类专栏： 算法设计 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dcwjh/article/details/102678964
版权

打印二叉树

	public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(Node head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String val = to + head.data + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(head.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

在这里插入图片描述

遍历

二叉树结构

	public static class Node{
        int data;
        Node left;
        Node right;
        public Node(int data){
            this.data = data;
        }
    }

实现二叉树的先序、中序、后序遍历
递归：

//根左右
    public static void preOrder(Node head){
        if(head == null)
            return;
        System.out.println(head.data);
        preOrder(head.left);
        preOrder(head.right);
    }
    
    
    //左根右
    public static void inOrder(Node head){
        if(head == null)
            return ;
        inOrder(head.left);
        System.out.println(head.data);
        inOrder(head.right);
    }
    
    //左右根
    public static void postOrder(Node head){
        if(head == null) 
            return;
        postOrder(head.left);
        postOrder(head.right);
        System.out.println(head.data);
        
    }

public static void Order(Node head){
        if(head == null)
            return ;
        Order(head.left);
        Order(head.right);
    }

这种遍历效果如下图：每个节点遍历三次
在这里插入图片描述
非递归

    public static void preOrderUnRecursion(Node head){
        if(head == null)
            return;
        Stack<Node> stack = new Stack<>();
        stack.add(head);
        while(!stack.isEmpty()){
            head = stack.pop();
            System.out.print(head.data + " ");
            if(head.right != null)
                stack.add(head.right);
            if(head.left != null)
                stack.add(head.left);
        }
    }



    //当前节点为空，从栈中拿一个打印，当前节点向右； 当前不空，当压入栈中，当前节点向左。
    public static void inOrderUnRecursion(Node head){
        if(head == null)
            return;
        Stack<Node> stack = new Stack<>();
        while(!stack.empty() || head != null){
            if(head != null){
                stack.add(head);
                head = head.left;  //左孩子不为空，一直压栈
            } else {
                head = stack.pop();
                System.out.print(head.data + " ");
                head = head.right;  //打印完该节点，向右继续遍历
            }
        }
    }


    //遍历顺序：左右中。 ==》中右左（先序遍历是中左右，参考先序遍历）
    public static void postOrderUnRecursion(Node head) {
        if(head == null)
            return ;
        Stack<Node> stack1 = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        stack1.add(head);
        while(!stack1.isEmpty()){
            head = stack1.pop();
            stack2.add(head);
            if(head.left != null)
                stack1.add(head.left);
            if(head.right != null)
                stack1.add(head.right);
        }
        while(!stack2.empty()){
            System.out.print(stack2.pop().data + " ");
        }

    }

    //难理解
    public static void posOrderUnRecur2(Node h) {
        System.out.print("pos-order: ");
        if (h != null) {
            Stack<Node> stack = new Stack<Node>();
            stack.push(h);
            Node c = null;
            while (!stack.isEmpty()) {
                c = stack.peek();
                if (c.left != null && h != c.left && h != c.right) {
                    stack.push(c.left);
                } else if (c.right != null && h != c.right) {
                    stack.push(c.right);
                } else {
                    System.out.print(stack.pop().value + " ");
                    h = c;
                }
            }
        }
        System.out.println();
    }

测试

	public static void main(String[] args) {
        Node head = new Node(5);
        head.left = new Node(3);
        head.right = new Node(8);
        head.left.left = new Node(2);
        head.left.right = new Node(4);
        head.left.left.left = new Node(1);
        head.right.left = new Node(7);
        head.right.left.left = new Node(6);
        head.right.right = new Node(10);
        head.right.right.left = new Node(9);
        head.right.right.right = new Node(11);

        printTree(head);

        // recursive
        System.out.println("==============recursive==============");
        System.out.print("pre-order: ");
        preOrderRecursion(head);
        System.out.println();
        System.out.print("in-order: ");
        inOrderRecursion(head);
        System.out.println();
        System.out.print("pos-order: ");
        postOrderRecursion(head);
        System.out.println();
//
//        // unrecursive
        System.out.println("============unrecursive=============");
        System.out.print("pre-order: ");
        preOrderUnRecursion(head);
        System.out.println();
        System.out.print("in-order: ");
        inOrderUnRecursion(head);
        System.out.println();
        System.out.print("pos-order: ");
        postOrderUnRecursion(head);
  }

在这里插入图片描述

在二叉树中找到一个节点的后继节点（中序遍历）

该节点有右子树，后继结点就是右子树的最左孩子
该节点无右子树，后继结点就是找到该节点所在左子树的最近父节点（父节点左子树的最后节点为该节点）

若右子树不为空Node->rchild!=NULL，则Suc=右子树最左的叶子节点；
若右子树为空，且拥有右父亲节点，则Suc=右父亲节点；
若右子树为空，且拥有左父亲节点(P)，则Suc=最近的右祖先节点(P)；

	public static class Node {
		public int value;
		public Node left;
		public Node right;
		public Node parent;

		public Node(int data) {
			this.value = data;
		}
	}

	public static Node getSuccessorNode(Node node) {
		if (node == null) {
			return node;
		}
		if (node.right != null) {  //该节点有右子树，右子树的最左系欸但
			return getLeftMost(node.right);
		} else {  //该节点无右子树，找到该节点所在子树的为最近父节点的左子树
			Node parent = node.parent;
			while (parent != null && parent.left != node) {
				node = parent;
				parent = node.parent;
			}
			return parent;
		}
	}

	//一路向左
	public static Node getLeftMost(Node node) {
		if (node == null) {
			return node;
		}
		while (node.left != null) {
			node = node.left;
		}
		return node;
	}

test

    public static void main(String[] args) {
        Node head = new Node(6);
        head.parent = null;
        head.left = new Node(3);
        head.left.parent = head;
        head.left.left = new Node(1);
        head.left.left.parent = head.left;
        head.left.left.right = new Node(2);
        head.left.left.right.parent = head.left.left;
        head.left.right = new Node(4);
        head.left.right.parent = head.left;
        head.left.right.right = new Node(5);
        head.left.right.right.parent = head.left.right;
        head.right = new Node(9);
        head.right.parent = head;
        head.right.left = new Node(8);
        head.right.left.parent = head.right;
        head.right.left.left = new Node(7);
        head.right.left.left.parent = head.right.left;
        head.right.right = new Node(10);
        head.right.right.parent = head.right;

        Node test = head.left.left;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.left.left.right;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.left;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.left.right;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.left.right.right;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.right.left.left;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.right.left;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.right;
        System.out.println(test.value + " next: " + getSuccessorNode(test).value);
        test = head.right.right; // 10's next is null
        System.out.println(test.value + " next: " + getSuccessorNode(test));
    }

在这里插入图片描述

前继节点：

二叉树的序列化和反序列化

package BinaryTree;

import java.util.LinkedList;
import java.util.Queue;

public class SerializeAndReconstructTree {

    public static class Node {
        public int value;
        public Node left;
        public Node right;

        public Node(int data) {
            this.value = data;
        }
    }

    public static String serialByPre(Node head) {
        if (head == null) {
            return "#_";
        }
        String res = head.value + "_";
        res += serialByPre(head.left);
        res += serialByPre(head.right);
        return res;
    }

    public static Node reconByPreString(String preStr) {
        String[] values = preStr.split("_");
        Queue<String> queue = new LinkedList<String>();
        for (int i = 0; i != values.length; i++) {
            queue.offer(values[i]);
        }
        return reconPreOrder(queue);
    }

    public static Node reconPreOrder(Queue<String> queue) {
        String value = queue.poll();
        if (value.equals("#")) {
            return null;
        }
        Node head = new Node(Integer.valueOf(value));
        head.left = reconPreOrder(queue);
        head.right = reconPreOrder(queue);
        return head;
    }

    public static String serialByLevel(Node head) {
        if (head == null) {
            return "#_";
        }
        String res = head.value + "_";
        Queue<Node> queue = new LinkedList<Node>();
        queue.offer(head);
        while (!queue.isEmpty()) {
            head = queue.poll();
            if (head.left != null) {
                res += head.left.value + "_";
                queue.offer(head.left);
            } else {
                res += "#_";
            }
            if (head.right != null) {
                res += head.right.value + "_";
                queue.offer(head.right);
            } else {
                res += "#_";
            }
        }
        return res;
    }

    public static Node reconByLevelString(String levelStr) {
        String[] values = levelStr.split("_");
        int index = 0;
        Node head = generateNodeByString(values[index++]);
        Queue<Node> queue = new LinkedList<Node>();
        if (head != null) {
            queue.offer(head);
        }
        Node node = null;
        while (!queue.isEmpty()) {
            node = queue.poll();
            node.left = generateNodeByString(values[index++]);
            node.right = generateNodeByString(values[index++]);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return head;
    }

    public static Node generateNodeByString(String val) {
        if (val.equals("#")) {
            return null;
        }
        return new Node(Integer.valueOf(val));
    }

    // for test -- print tree
    public static void printTree(Node head) {
        System.out.println("Binary Tree:");
        printInOrder(head, 0, "H", 17);
        System.out.println();
    }

    public static void printInOrder(Node head, int height, String to, int len) {
        if (head == null) {
            return;
        }
        printInOrder(head.right, height + 1, "v", len);
        String val = to + head.value + to;
        int lenM = val.length();
        int lenL = (len - lenM) / 2;
        int lenR = len - lenM - lenL;
        val = getSpace(lenL) + val + getSpace(lenR);
        System.out.println(getSpace(height * len) + val);
        printInOrder(head.left, height + 1, "^", len);
    }

    public static String getSpace(int num) {
        String space = " ";
        StringBuffer buf = new StringBuffer("");
        for (int i = 0; i < num; i++) {
            buf.append(space);
        }
        return buf.toString();
    }

    public static void main(String[] args) {
        Node head = null;
        printTree(head);

        String pre = serialByPre(head);
        System.out.println("serialize tree by pre-order: " + pre);
        head = reconByPreString(pre);
        System.out.print("reconstruct tree by pre-order, ");
        printTree(head);

        String level = serialByLevel(head);
        System.out.println("serialize tree by level: " + level);
        head = reconByLevelString(level);
        System.out.print("reconstruct tree by level, ");
        printTree(head);

        System.out.println("====================================");

        head = new Node(1);
        printTree(head);

        pre = serialByPre(head);
        System.out.println("serialize tree by pre-order: " + pre);
        head = reconByPreString(pre);
        System.out.print("reconstruct tree by pre-order, ");
        printTree(head);

        level = serialByLevel(head);
        System.out.println("serialize tree by level: " + level);
        head = reconByLevelString(level);
        System.out.print("reconstruct tree by level, ");
        printTree(head);

        System.out.println("====================================");

        head = new Node(1);
        head.left = new Node(2);
        head.right = new Node(3);
        head.left.left = new Node(4);
        head.right.right = new Node(5);
        printTree(head);

        pre = serialByPre(head);
        System.out.println("serialize tree by pre-order: " + pre);
        head = reconByPreString(pre);
        System.out.print("reconstruct tree by pre-order, ");
        printTree(head);

        level = serialByLevel(head);
        System.out.println("serialize tree by level: " + level);
        head = reconByLevelString(level);
        System.out.print("reconstruct tree by level, ");
        printTree(head);

        System.out.println("====================================");

        head = new Node(100);
        head.left = new Node(21);
        head.left.left = new Node(37);
        head.right = new Node(-42);
        head.right.left = new Node(0);
        head.right.right = new Node(666);
        printTree(head);

        pre = serialByPre(head);
        System.out.println("serialize tree by pre-order: " + pre);
        head = reconByPreString(pre);
        System.out.print("reconstruct tree by pre-order, ");
        printTree(head);

        level = serialByLevel(head);
        System.out.println("serialize tree by level: " + level);
        head = reconByLevelString(level);
        System.out.print("reconstruct tree by level, ");
        printTree(head);

        System.out.println("====================================");

    }
}
Dcwjh
关注
专栏目录
实现前缀树
我们的征途是星辰大海
09-02 379
class TrieNode { Boolean isWord; Character c; List<TrieNode> next; TrieNode() { isWord = false; } TrieNode(Character c) { ...
C++实现字典树的增删查写前缀打印
爱玲姐姐的博客
03-09 1289
C++实现字典树的增删查写前缀打印 // // Created by jal on 19-3-9. // #include &lt;bits/stdc++.h&gt; using namespace std; const int SIZE = 26; struct Node{ int sum; bool isEnd; char val; vector&lt;Node...
字典树详解
花言的博客
10-24 419
字典树 字典树：又称单词查找树(Trie树，又称前缀树)，是一种哈希树的变种。典型应用是用于统计、排序和保存大量的字符串(但不 仅限于字符串)，所以常被用于文本词频统计。 可用于快速查询「某个字符串/字符前缀」是否存在的数据结构。还可用于高效的存储和检索字符串数据集中的键。其核心是使用"边"来代表有无字符，使用"点"来记录是否为"单词结尾"以及“其后续字符串的字符是什么”。 优点：利用字符串的公共前缀来减少查询时间，尽量减少无谓的字符串比较，查询效率比哈希树高。 性质： 根节点不包含字符串
树结构-------前缀树
hongjie_lin
04-16 663
何为前缀树：又叫字典树、单词查找树或键树，是一种多叉树结构。如下图上图是一棵Trie树，表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”} 。从上图可以归纳出Trie树的基本性质：①根节点不包含字符，除根节点外的每一个子节点都包含一个字符。 ②从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。 ③每个节点的所有子...
第四课:二叉树
zhiyongbo的博客
03-22 138
1.二叉树递归遍历 前序： public static void preOrderRecur(Node head) { if(head==null){ return; } System.out.println(head.value); preOrderRecur(head.left); preOrderRecur(head.right); } 中序： public static void inOrderRecur(Node head) { if(head==null){
TIRE 前缀树（字典树）
weixin_45115771的博客
06-09 512
在计算机科学中，前缀树又称字典树（tire—源自于retrieval），是一种有序树。它用于保存关联数组，其中的键通常是字符串。
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
前缀树（Trie）原理及Java实现
有图有真相
05-02 2万+
前缀树的结构Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树或键树，是一种多叉树结构。如下图： 上图是一棵Trie树，表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”} 。从上图可以归纳出Trie树的基本性质： ①根节点不包含字符，除根节点外的每一个子节点都包含一个字符。 ②从根节点到某一个节点，路径上经过的
前缀树的简单实现
二哈
02-05 4791
1. 前缀树 前缀树又称为单词查找树，是一种树形的结构，用于存储大量的字符串，它的优点是：利用字符串的公共前缀来节约存储空间 Trie树主要是利用词的公共前缀缩小查词范围、通过状态间的映射关系避免了字符的遍历，从而达到高效检索的目的 2. 可以先声明一个节点TrieNode，节点包括以下几个属性： TrieNode children[] = new TrieNode[26]; TrieNo...
前缀树(java实现）
JZ
10-10 6942
package class_07; /** * * 前缀树 * * 例子： * 一个字符串类型的数组arr1，另一个字符串类型的数组arr2。 * arr2中有哪些字符，是arr1中出现的？请打印 * arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印 * arr2中有哪些字符，是作为arr1中某个字符串前缀出现的？请打印arr2中出现次数最大的前缀。 * ...
【java毕业设计】应急救援物资管理系统源码（springboot+vue+mysql+说明文档）.zip
11-06
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
基于java的音乐网站答辩PPT.pptx
11-06
基于java的音乐网站答辩PPT.pptx
基于Flexsim的公路交通仿真系统.zip
最新发布
11-06
基于Flexsim软件开发的仿真系统，可供参考学习使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值