二叉树的相关代码

最新推荐文章于 2024-09-10 21:01:04 发布
最新推荐文章于 2024-09-10 21:01:04 发布
阅读量656 收藏 6
点赞数
分类专栏： 算法 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaonianbz/article/details/81671590
版权

1、二叉树的先序，中序，后序遍历

import java.util.Stack;
/**
 * @Author zb
 * @Date 2018/8/14
 * 二叉树的先序，中序，后序遍历
 */
public class PreInPosTraversal {

    /**
     * 定义二叉树结点
     */
    public static class Node{
        public int value;
        public Node left;
        public Node right;
        public Node(int data){
            this.value = data;
        }
    }

    /**
     * 递归实现先序遍历
     * @param head
     */
    public static void preOrderRecur(Node head){
        if(head == null){
            return ;
        }
        System.out.print(head.value + " ");
        preOrderRecur(head.left);
        preOrderRecur(head.right);
    }

    /**
     * 递归实现中序遍历
     * @param head
     */
    public static void inOrderRecur(Node head){
        if(head == null){
            return ;
        }
        inOrderRecur(head.left);
        System.out.print(head.value + " ");
        inOrderRecur(head.right);
    }

    /**
     * 递归实现后序遍历
     * @param head
     */
    public static void posOrderRecur(Node head){
        if(head == null){
            return ;
        }
        posOrderRecur(head.left);
        posOrderRecur(head.right);
        System.out.print(head.value + " ");
    }

    /**
     * 非递归实现先序遍历
     * @param head
     */
    public static void preOrderUnRecur(Node head){
        System.out.println("pre-order: ");
        if(head != null){
            Stack<Node> stack = new Stack<Node>();
            //向栈中添加头结点
            stack.add(head);
            //当前结点
            Node cur;
            while(!stack.isEmpty()){
                cur = stack.pop();
                System.out.print(cur.value + " ");
                //注意：如果不为空，先压右，再压左(弹栈打印的时候才会是先左后右)
                if(cur.right != null){
                    stack.push(cur.right);
                }
                if(cur.left != null){
                    stack.push(cur.left);
                }
            }
        }
        System.out.println();
    }

    /**
     * 非递归实现中序遍历
     * @param head
     */
    public static void inOrderUnRecur(Node head){
        System.out.println("in-order：");
        if(head != null){
            Stack<Node> stack = new Stack<Node>();
            Node cur = head;
            //当前结点为空：从栈中拿一个打印，当前结点向右跑
            //当前结点不为空，当前结点压入栈，当前结点向左跑
            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();
    }

    /**
     * 非递归实现后序遍历(两个栈)
     * @param head
     */
    public static void posOrderUnRecur1(Node head){
        System.out.println("pos-order：");
        if(head != null){
            Stack<Node> s1 = new Stack<Node>();
            Stack<Node> s2 = new Stack<Node>();
            s1.push(head);
            Node cur = head;
            //根据先序遍历(中左右)的代码,求出(中右左)，再根据栈的特性，逆过来就是后序(左右中)
            //s2作为辅助栈,把先序遍历中要打印的结点，先压入栈中,最后打印，即为左右中
            while (!s1.isEmpty()){
                cur = s1.pop();
                s2.push(cur);
                if(cur.left != null){
                    s1.push(cur.left);
                }
                if(cur.right != null){
                    s1.push(cur.right);
                }
            }
            //打印
            while (!s2.isEmpty()){
                System.out.print(s2.pop().value + " ");
            }
        }
        System.out.println();
    }

    /**
     * 非递归实现后序遍历(一个栈)
     * @param head
     */
    public static void posOrderUnRecur2(Node head){
        System.out.println("pos-order：");
        if(head != null){
            Stack<Node> stack = new Stack<Node>();
            stack.push(head);
            Node cur = null;
            while(!stack.isEmpty()){
                cur = stack.peek();
                if(cur.left != null && head != cur.left && head != cur.right){
                    stack.push(cur.left);
                }else if(cur.right != null && head != cur.right){
                    stack.push(cur.right);
                }else {
                    System.out.print(stack.pop().value + " ");
                    head = cur;
                }
            }
        }
        System.out.println();
    }

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

        // 递归实现
        System.out.println("==============recursive==============");
        System.out.print("pre-order: ");
        preOrderRecur(head);
        System.out.println();
        System.out.print("in-order: ");
        inOrderRecur(head);
        System.out.println();
        System.out.print("pos-order: ");
        posOrderRecur(head);
        System.out.println();

        //非递归实现
        System.out.println("============unrecursive=============");
        preOrderUnRecur(head);
        inOrderUnRecur(head);
        posOrderUnRecur1(head);
        posOrderUnRecur2(head);
    }

}

2、二叉树的序列化与反序列化

import java.util.LinkedList;
import java.util.Queue;
/**
 * @Author zb
 * @Date 2018/8/14
 * 二叉树的序列化与反序列化
 */
public class SerializeTree {

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

    /**
     * 先序的序列化
     * 如果结点的值不为空用！隔离，如果为用#!
     * @param head
     * @return
     */
    public static String serialByPre(Node head){
        if(head == null){
            return "#!";
        }
        String res = head.value + "!";
        res += serialByPre(head.left);
        res += serialByPre(head.right);
        return res;
    }

    /**
     * 先序的反序列化
     * @param preStr
     * @return
     */
    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);
    }

    /**
     * 先序的反序列化方法
     * @param queue
     * @return
     */
    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 void main(String[] args) {
        Node 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);
        System.out.println(serialByPre(head));

    }

}

3、判断平衡二叉树

/**
 * @Author zb
 * @Date 2018/8/15
 */
public class IsBalanceTree {

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

    /**
     * 定义递归结构
     * isB：返回是否为平衡树
     * h：返回树的高度
     */
    public static class ReturnData{
        public boolean isB;
        public int h;
        public ReturnData(boolean isB, int h){
            this.isB = isB;
            this.h = h;
        }
    }

    /**
     * 递归过程
     * 判断一棵树是否为平衡二叉树的思路：
     * 对于任意结点，左子树是否平衡，右子树是否平衡，
     * 左子树和右子树的高度差是否不超过1
     * @param head
     * @return
     */
    public static ReturnData process(Node head){
        if(head == null){
            //空树也是平衡树
            return new ReturnData(true,0);
        }

        //返回当前结点的左树信息
        ReturnData leftData = process(head.left);
        if(!leftData.isB){
            //如果左树不平衡，返回false
            return new ReturnData(false,0);
        }

        //返回当前结点的右树信息
        ReturnData rightData = process(head.right);
        if(!rightData.isB){
            //如果右树不平衡，返回false
            return new ReturnData(false,0);
        }

        //左树和右树高度差大于1，返回false
        if(Math.abs(leftData.h - rightData.h) > 1){
            return new ReturnData(false,0);
        }
        return new ReturnData(true,Math.max(leftData.h, rightData.h)+1);
    }

    /**
     * 主函数：判断是否为平衡二叉树
     * @param head
     * @return
     */
    public static boolean isBTree(Node head){
        return process(head).isB;
    }

    public static void main(String[] args) {
        Node head = new Node(1);
        head.left = new Node(2);
        head.right = new Node(3);
        head.left.left = new Node(4);
        head.left.right = new Node(5);
        head.right.left = new Node(6);
        head.right.left.left = new Node(7);
        System.out.println(isBTree(head));
    }

}

4、判断二叉搜索树

import java.util.Stack;
/**
 * @Author zb
 * @Date 2018/8/15
 * 什么叫搜索二叉树：任何一个结点的左子树都比他小,右子树都比他大
 */
public class IsBST {

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

    /**
     * 判断是否为二叉搜索树方法一：Morris遍历
     * @param head
     * @return
     */
    public static boolean isBST1(Node head){
        if(head == null){
            return true;
        }
        boolean res = true;
        Node pre = null;
        Node cur1 = head;
        Node cur2 = null;
        while(cur1 != null){
            cur2 = cur1.left;
            if(cur2 != null){
                while (cur2.right != null && cur2.right != cur1) {
                    cur2 = cur2.right;
                }
                if (cur2.right == null) {
                    cur2.right = cur1;
                    cur1 = cur1.left;
                    continue;
                } else {
                    cur2.right = null;
                }
            }
            if (pre != null && pre.value > cur1.value) {
                res = false;
            }
            pre = cur1;
            cur1 = cur1.right;
        }
        return res;
    }

    /**
     * 判断是否为二叉搜索树方法二：中序遍历
     *   二叉树在中序遍历情况下是依次升序的就是搜索二叉树，
     *   否则就不是搜索二叉树
     */
    //定义上一个结点的值
    static int lastNodeValue = Integer.MIN_VALUE;
    public static boolean isBST2(Node head){
        if(head != null){
            Stack<Node> stack = new Stack<Node>();
            Node cur = head;
            while(!stack.isEmpty() || cur != null){
                if(cur != null){
                    stack.push(cur);
                    cur = cur.left;
                }else{
                    cur = stack.pop();
                    //升序判断,用上一个值和当前值比较
                    if(cur.value <= lastNodeValue){
                        return false;
                    }
                    lastNodeValue = cur.value;
                    cur = cur.right;
                }
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Node head = new Node(4);
        head.left = new Node(2);
        head.right = new Node(6);
        head.left.left = new Node(1);
        head.left.right = new Node(3);
        head.right.left = new Node(5);
        System.out.println(isBST1(head));
        System.out.println(isBST2(head));
    }

}

5、判断完全二叉树

import java.util.LinkedList;
import java.util.Queue;
/**
 * @Author zb
 * @Date 2018/8/15
 */
public class IsCompleteTree {

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

    /**
     * 判断是否为完全二叉树的思路：
     * 1、如果当前结点的左孩子为空，右孩子不为空，返回false
     * 2、如何当前结点的左孩子或右孩子有一个为空，或都为空(此次用一个变量标识，如果满足条件，
     * 则开启判断叶子结点的阶段)，则后面的结点都是叶子结点
     * @param head
     * @return
     */
    public static boolean isComTree(Node head){
        if(head == null){
            return true;
        }
        Queue<Node> queue = new LinkedList<Node>();
        //是否开启验证叶子结点阶段
        boolean leaf = false;
        Node leftChild = null;
        Node rightChild = null;
        Node cur = null;
        queue.offer(head);
        while (!queue.isEmpty()){
            //当前结点
            cur = queue.poll();
            //当前结点的左孩子
            leftChild = cur.left;
            //当前结点的有孩子
            rightChild = cur.right;

            //如果左孩子为空，右孩子不为空，返回false
            //如何开启了结点验证阶段，l或者r不为空,返回false
            if((leaf && (leftChild != null || rightChild != null)) || (leftChild == null && rightChild != null)){
                return false;
            }
            //宽度遍历(先判断左边，再判断右边)
            if(leftChild != null){
                queue.offer(leftChild);
            }
            if(rightChild != null){
                queue.offer(rightChild);
            }
            if(leftChild == null || rightChild == null){
                leaf = true;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Node head = new Node(4);
        head.left = new Node(2);
        head.left.left = new Node(1);
        head.left.right = new Node(3);
        System.out.println(isComTree(head));
    }

}

6、二叉树按层打印

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
/**
 * @Author zb
 * @Date 2018/9/4
 * 【树】把二叉树打印成多行
 *
 * 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
 */
public class Demo60 {

    public class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> lists = new ArrayList<ArrayList<Integer>>();
        if(pRoot == null){
            return lists;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //当前行的最后节点
        TreeNode last = pRoot;
        //下一行的最右节点
        TreeNode nlast = pRoot;
        queue.add(pRoot);
        ArrayList<Integer> list = new ArrayList<Integer>();
        while(!queue.isEmpty()){
            TreeNode out = queue.poll();
            list.add(out.val);
            if(out.left != null){
                queue.add(out.left);
                nlast = out.left;
            }
            if(out.right != null){
                queue.add(out.right);
                nlast = out.right;
            }
            if(out == last){
                //当前行打印完毕
                lists.add(list);
                last = nlast;
                list = new ArrayList<Integer>();
            }
        }
        return lists;
    }
}
shaonianbz
关注
专栏目录
二叉树相关算法源代码大全
04-22
二叉树相关算法源代码大全，包括二叉树的递归创建、先序中序后序遍历、二叉树结点数求解、二叉树叶结点路径求解、二叉树深度等常见的二叉树算法。 附带一个根据二叉树的先序遍历序列和中序遍历序列输出后序遍历序列的算法。
数据结构：二叉树相关代码
08-24
这个压缩包“数据结构：二叉树相关代码”很可能包含了各种二叉树操作的实现，如插入、删除、遍历等，以及可能的自定义二叉树类型，比如二叉搜索树、平衡二叉树（AVL树或红黑树）等。 首先，二叉树是一种非线性数据...
二叉树代码
weixin_44264668的博客
04-17 272
tree.h #ifndef __TREE_H #define __TREE_H #include <stdio.h> #include <stdlib.h> //声明描述节点的数据结构 typedef struct node { int data; //数据 struct node *left; //左子树地址 struct node *right; //右子树地址 }node_t; //声明描述整颗树的数据结构、 typedef struct tre
数据结构--二叉树
最新发布
分享技术，分享经验
09-10 1336
二叉树（Binary Tree）是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树是各种树结构的基础，广泛应用于数据存储、排序、搜索等领域。
二叉树的相关代码实现
SunSachin的博客
06-19 368
二叉树的创建和遍历 贴出自己练习的二叉树创建和遍历的代码，皆为递归算法： 头文件： #pragma once #include "stdafx.h" typedef struct tagBinTree { char dwValue;//二叉树的值 tagBinTree *LTree;//左子树 tagBinTree *RTree;//右子树 }TBinTree; class CBinTree { public: CBinTree() :pRoot(NULL){}; ~CBinTree();
二叉树模板代码 二叉树习题
03-20
本主题将深入探讨二叉树的基本概念、常见操作以及模板代码实现，帮助你理解和解决二叉树相关的习题。 一、二叉树定义与基本概念 二叉树是由n（n>=0）个有限节点组成的数据结构，每个节点最多有两个子节点，分别称为...
二叉树java代码
01-22
java作业中的二叉树代码。在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为...
C语言二叉树相关的代码.zip
10-28
本文将深入探讨C语言实现二叉树的相关知识点，包括二叉树的基本概念、常用操作以及如何在C语言中编码实现。 首先，我们要理解什么是二叉树。二叉树是每个节点最多有两个子节点的树形数据结构，通常分为左子节点和右...
C语言编写二叉树的代码
07-05
该二叉树代码不使用链表进行遍历，而是使用结构体里面包含变量已经多个该结构体本身的结构体指针进行遍历。定义一个结构体，包括数据变量，和两个自身的结构体指针(二叉树的左边遍历指针和右边遍历指针两个)。函数...
二叉树程序代码
01-18
二叉树代码程序，二叉树是遍历，要明白递归s=函数的使用方法，进一步学会
二叉树相关操作代码
05-08
二叉树代码 相关操作删除 插入 查找 数据结构中的二叉排序树
二叉树源代码
09-14
就是一个二叉树源代码，就是一个二叉树源代码，就是一个二叉树源代码，就是一个二叉树源代码，就是一个二叉树源代码，
二叉树相关代码
weixin_40459023的博客
11-16 148
#include &lt;iostream&gt; using namespace std; int n = 0; int sum = 0; struct Bnode{ int data; Bnode *lch; Bnode *rch; }; Bnode*creat(){ Bnode *p; int x; cin &gt;&gt; x; if(x == 0) p = NULL;...
二叉树相关实现代码
07-21 101
.h文件 typedefunsignedcharelemtype; #include<stdio.h> #include<iostream> #include<tchar.h> #include<stack> usingnam...
二叉树的代码
FlyingJack
04-25 383
#include <bits/stdc++.h> using namespace std; int const N = 1000 + 10; typedef struct BST{ struct BST *left,*right; int val; }*Node; Node insert(Node root,int key){ if(root == NULL)...
二叉树系列的代码
如月之恒，如日之升
09-07 873
代码随想录笔记
二叉树遍历代码实现及基础知识
"二叉树和数列是计算机科学中基础的数据结构，这段代码提供了创建、遍历二叉树的基本实现。" 二叉树是一种特殊的数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在计算机科学中，二叉树常用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值