史上最全二叉树的相关操作：二叉树创建，先中后层序递归非递归等

最新推荐文章于 2023-12-09 11:00:47 发布
最新推荐文章于 2023-12-09 11:00:47 发布
阅读量298 收藏
点赞数 1
分类专栏： java 文章标签： 二叉树 队列 stack 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43505820/article/details/104978216
版权

二叉树基本操作：

导语：你是否还在为不懂如何学好二叉树而发愁，是否还在纠结如何创建构造结点，如何将栈和队列巧妙的结合起来运行程序。徐小渣特对此做以归纳总结，希望能对大家有所帮助。
1.树结点的构造：

class BtNode {
public BtNode lchild;//左孩子结点
public BtNode rchild;//右孩子结点
public char data;//存储的数值
public BtNode(BtNode lchild,BtNode rchild){
    this.lchild=lchild;
    this.data=data;
}
public BtNode(char data){
    this.data=data;
}
public BtNode(){}
}

2.二叉树的创建方法：
法一：无参构造,向程序中输入内容，此代码默认为输入字符

//二叉树的创建方法
    public static BtNode CreateTree() {
        //char item;
        BtNode s = null;
        Scanner scanner = new Scanner(System.in);
        char item = scanner.next().charAt(0);
        if (item != '#') {
            //s.data=ite`m;
            s = new BtNode(item);
            s.lchild = CreateTree();
            s.rchild = CreateTree();
        }
        return s;
    }

法二：含有参数，参数为提供的字符串和下标

    static class Int {
        private int index;
        public Int() {
            index = 0;
        }
        public Int(int x) {
            index = x;
        }
        int GetIndex() {
            return index;
        }
        void ind() {
            index += 1;
        }
    }
    //利用字符串和下标创建树      注意此处不能用i++
    public static BtNode creat(String s, Int i) {
        // Queue<BtNode> queue= new Queue<>();
        BtNode b = null;
        //int in=i.GetIndex();
        if (s.charAt(i.GetIndex()) != '#') {
            b = new BtNode(s.charAt(i.GetIndex()));
            i.ind();
            b.lchild = creat(s, i);
            i.ind();
            b.rchild = creat(s, i);
        }
        return b;
    }

3.利用递归输出先序，中序，后序：

//先序
    public static void Preorder(BtNode node) {
        if (node != null) {
            System.out.println(node.data);
            Preorder(node.lchild);
            Preorder(node.rchild);
        }
    }
    //中序遍历
    public static void Inorder(BtNode node) {
        if (node != null) {
            Inorder(node.lchild);
            System.out.println(node.data);
            Inorder(node.rchild);
        }
    }
    //后序
    public static void lastorder(BtNode node) {
        if (node != null) {
            Preorder(node.lchild);
            Inorder(node.rchild);
            System.out.println(node.data);
        }
    }

4.利用非递归进行先中后序遍历：（后序相对复杂，小徐在此处采用的方法是设置标志位和栈）

   //先序非递归  利用栈：先进后出
    public static void NicePreOrder(BtNode tree){
      if(tree==null)return;
      Stack<BtNode> stack=new Stack<>();
      stack.push(tree);
      //栈的特征是先进先出，则先把树的右边的入栈后入左边
      while(!stack.empty()){
         BtNode btNode=stack.pop();
          System.out.print(btNode.data+" ");
          if(btNode.rchild!=null) stack.push(btNode.rchild);
          if(btNode.lchild!=null) stack.push(btNode.lchild);
      }
    }


//中序非递归   法一
    public static void NiceInOrder(BtNode tree){
        if(tree==null)return ;
        Stack<BtNode> stack=new Stack<>();
        while(!stack.empty()||tree!=null){
            while (tree!=null){
                stack.push(tree);
                tree=tree.lchild;
            }
            tree=stack.pop();
            System.out.print(tree.data+" ");
            tree=tree.rchild;
        }
    }
    //中序非递归法二
    public static void NiceInOrder2(StkNode tree){
        Stack<StkNode> stack=new Stack<>();
        if(tree ==null) return;
        stack.push(tree);
        while(!stack.empty()){
            StkNode node=stack.pop();
            if(++node.popnum==2){
                System.out.print(node.ptr.data+" ");
            if(node.ptr.rchild!=null){
               stack.push(new StkNode(node.ptr.rchild));
            }
            }else{
                stack.push(node);
                if(node.popnum==1&&node.ptr.lchild!=null){
                    stack.push(new StkNode(node.ptr.lchild));
                }
            }
        }
    }

    // 后序非递归法一
    public static void NiceLOrder(BtNode tree){
     Stack<BtNode> stack=new Stack<>();
     //设置标志位，用来表示右孩子是否输出
     BtNode flag=null;
     while(!stack.empty()||tree!=null){
         while(tree!=null){
             stack.push(tree);
             tree=tree.lchild;
         }
         //此时获取的元素为树最左边的根
         tree=stack.pop();
         //判断其是否有右子树，或者右子树是否被输出过
         //表示无右子树或者已被输出过
         if(tree.rchild==null||tree.rchild==flag){
             System.out.print(tree.data+" ");
             flag=tree;//把标志位转移到tree的位置
             tree=null;
         }
         else{stack.push(tree);
              tree=tree.rchild;
         }
     }
    }

```java
//法二:   后序非递归 
   static class StkNode{
        public BtNode ptr=null;
        public int popnum=0;
        public StkNode(BtNode p){ptr=p;popnum=0;}
}
    public static void NiceLOrder2(StkNode tree){
        Stack<StkNode> stack=new Stack<>();
        if(tree ==null) return;
        stack.push(tree);
        while(!stack.empty()){
            StkNode node=stack.pop();
            if(++node.popnum==3){
                System.out.print(node.ptr.data+" ");
            }else{
                stack.push(node);
                if(node.popnum==1&&node.ptr.lchild!=null){
                    stack.push(new StkNode(node.ptr.lchild));
                }
                else if(node.popnum==2&&node.ptr.rchild!=null){
                    stack.push(new StkNode(node.ptr.rchild));
                }
            }
        }
    }


**5.层序遍历：**
```java
//层序遍历   队的特点：先进先出
    public static void NiceLevelOrder(BtNode tree){
        Queue<BtNode> queue=new LinkedList<>();
         queue.offer(tree);
         while(!queue.isEmpty()){
             tree=queue.poll();
             System.out.print(tree.data+" ");
             //先入左边后入右边
             if(tree.lchild!=null)queue.offer(tree.lchild);
             if(tree.rchild!=null)queue.offer(tree.rchild);
         }
    }

6-7.已知先序和中序的输出结果，求原始二叉树：
（思路与下文七思路一致，有递归思想）
以该题为例：分析先序和中序的特点，先序的输出的第一个即为树的根，在中序的输出结果找到和他一致的元素，返回该下标，则以中序来说，可将其输出结果分为两部分，左边为根节点的左子树，右边为根节点的右子树，先序同理，找到上文提到的下标，则左子树为从根节点的下一个开始到该下标的元素，右节点为剩下所有的元素。在进行划分，利用递归思想即可解题。
查找下标代码：

/先查找对应的下标
    private static int search(String s,char value){
      int pos=-1;
        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i)==value) {pos=i;break;}
        }
        return pos;
    }

已知先序和中序的输出结果，求原始二叉树

 //  pstr  先序排列的字符串   istr的字符串  n所含元素个数
    private static BtNode CreatPI(String pstr, String istr, int n) {
        if(pstr!=null&&istr!=null) {
            BtNode s = new BtNode(pstr.charAt(0));;
            if (n > 0) {
                int pos = search(istr, s.data);
                if(pos==-1)return null;
                s.lchild = CreatPI(pstr.substring(1, pos + 1), istr.substring(0, pos), n);
                s.rchild = CreatPI(pstr.substring(pos + 1), istr.substring(pos + 1), n - pos - 1);
            }
            return s;
        }
        return null;
    }

已知中序和后序的输出结果,求原始二叉树

    //已知中序 后序 求原始二叉树
    private static BtNode CreatIL(String istr,String lstr,int n) {
        if (istr != null && lstr != null) {
            BtNode s = null;
            if (n > 0) {
                s = new BtNode(lstr.charAt(lstr.length() - 1));
                int pos = search(istr, lstr.charAt(lstr.length() - 1));
                if(pos==-1)return null;
                s.lchild = CreatIL(istr.substring(0, pos), lstr.substring(0, pos), pos);
                s.rchild = CreatIL(istr.substring(pos + 1), lstr.substring(pos, n - 1), n - pos - 1);
            }
            return s;
        }
        return null;
    }

写出k行的全部数值


    public static void Printk(BtNode ptr,int k){
        if(ptr==null||k<0)return;
        if(ptr!=null&&k==0){
            System.out.print(ptr.data+" ");
        }
        else if(ptr!=null){
            Printk(ptr.lchild,k-1);
            Printk(ptr.rchild,k-1);
        }
    }

获取节点个数 分治策略思想

   //获取节点个数   分治策略思想
    public static int Getsize(BtNode tree){
        if(tree==null) return 0;
        else return Getsize(tree.lchild)+Getsize(tree.rchild)+1;
    }

获取深度

//获取深度
public static int GetDepth(BtNode tree){
        if(tree==null) return 0;
        else  return Math.max(GetDepth(tree.lchild),GetDepth(tree.rchild))+1;
}

在树中查找某值是否存在

//在树中查找某值是否存在
public static  boolean FindValue(BtNode tree,char c){
        if(tree==null) return false;
    boolean flag=false;
       if(tree.data==c) return true;
        else {
            if(tree.lchild!=null) flag=FindValue(tree.lchild,c);
            else if(tree.rchild!=null) flag=FindValue(tree.rchild,c);
       }
       return flag;
}

获取双亲节点

//获取双亲
public static BtNode GetParent(BtNode tree,BtNode child) {
    if (child == null || tree == null || tree == child) return null;
    if ((tree.lchild != null && tree.lchild == child) || (tree.rchild != null && tree.rchild == child)) {
        return tree;
    } else if (tree.lchild != null) {
        tree = GetParent(tree.lchild, child);
        if (tree == null) {
            tree = GetParent(tree.rchild, child);
        }
    }
    return tree;
}

判断是否是满二叉树 要么树为空 要么树的左子树为满同时树的右子树为满且两者高度相同

//判断是否是满二叉树  要么树为空 要么树的左子树为满同时树的右子树为满且两者高度相同
public boolean IsFull(BtNode p){
        return (p==null||(IsFull(p.lchild)&&IsFull(p.rchild)&&(GetDepth(p.lchild)==(GetDepth(p.rchild)))));
}

判断是否是满二叉树

//判断是否是满二叉树
public boolean Is_Full(BtNode tree){
        Queue<BtNode> queue=new LinkedList<>();
        int n=1;
        boolean res=true;
        if(tree==null) return  res;
        queue.offer(tree);
        while(!queue.isEmpty()){
            if(queue.size()<n){
                res=false;
                break;
            }
            for (int i = 0; i < n; i++) {
                BtNode p=queue.poll();
                if(p.lchild!=null){
                    queue.offer(p.lchild);
                }
                if(p.rchild!=null){
                    queue.offer(p.rchild);
                }
            }
            n+=n;
        }
        return res;
}

判断是否是完全二叉树

//  判断是否是完全二叉树
public static boolean Is_ComTree(BtNode tree) {
    boolean res = true;
    if (tree == null) return res;
    Queue<BtNode> queue = new LinkedList<>();
    queue.offer(tree);
    while (!queue.isEmpty()) {
        tree = queue.poll();
        if (tree == null) break;
        queue.offer(tree.lchild);
        queue.offer(tree.rchild);
    }
    while (!queue.isEmpty()) {
        tree = queue.poll();
        if (tree != null) {
            res = false;
            break;
        }
    }
    return res;
}

对数组进行中序操作 递归操作

//对数组进行中序操作  递归操作
public static void Inorder_arr(int[] arr,int i,int end){
        if(i<=end&&arr[i]!=-1){
            Inorder_arr(arr,2*i+1,end);
            System.out.print(arr[i]+" ");
            Inorder_arr(arr,2*i+2,end);
        }
}

非递归操作

//非递归操作
public static void NiceInorder_arr(int[] arr){
        if(arr.length<=0)return;
        Stack<Integer> stack=new Stack<>();
        int i=0,end=arr.length-1;
        while((i<=end&&arr[i]!=-1)||!stack.empty()){
            while(i<=end&&arr[i]!=-1){
                stack.push(i);
                i=i*2+1;
            }
            i=stack.pop();
            System.out.print(arr[i]+" ");
            i=2*i+2;
        }
}

链式存储二叉树 将数组转换成链表的形式

public static BtNode CreatAr(int[] arr,int index){
        BtNode tree=null;
        if(index<arr.length-1&&arr[index]!=-1) {
            tree = new BtNode(arr[index]);
             tree.lchild=CreatAr(arr,index+1);
             tree.rchild=CreatAr(arr,index+1);
        }
        return tree;
}

将中序遍历转换为双向链表

//  将中序遍历转换为双向链表
public static void inoder(BtNode tree) {
        BtNode pre=null;
        BtNode ptr=tree;
    if (tree == null) return;
    Stack<BtNode> stack = new Stack<>();
    while (!stack.empty()||ptr!=null) {
        while (ptr != null) {
            stack.push(ptr);
            ptr=ptr.lchild;
        }
        ptr = stack.pop();
       if(pre==null){
           pre=ptr;
           tree=ptr;
       }
       else {
           pre.rchild=ptr;
           ptr.lchild=pre;
           pre=ptr;
       }
       ptr=ptr.rchild;
    }
}

主函数调用：

 public static void main(String[] args) {
        Int i=new Int(0);
        BtNode node= creat("abc####",i);
      //  System.out.print(node.data);
       // BtNode x=CreateTree();
      // Preorder(node);
        //lastorder(node);
        BtNode node1=new BtNode();
      //  String pstr="abdecfg";
        String istr="dbeafcg";
        String lstr="debfgca";
        //String istr="badc";
        //String lstr="bdca";
       node1=CreatIL(istr,lstr,7);
       // Preorder(node1);
       // NiceInOrder(node1);
        //NiceLOrder1(node1);
        //NiceLevelOrder(node1);
        StkNode node2=new StkNode(node1);
  //      NiceLOrder2(node2);
    //    NiceInOrder2(node2);
    //     Printk(node1,2);
      //  System.out.println(Getsize(node1));
        //System.out.println(GetDepth(node1));
        //System.out.println(FindValue(node1,'u'));
        System.out.println(Is_ComTree(node1));
    int[] arr={31,23,12,66,-1,5,17,70,62,-1,-1,88,-1,55};
     Inorder_arr(arr,0,arr.length-1);
 //    inoder(node1);
        NiceInorder_arr(arr);

    }
}
IT界的徐小渣
关注
专栏目录
Stack的三种含义
iOS逆向与安全
11-23 1万+
前言 这个词其实有三种含义，适用于不同的场合，必须加以区分。 正文 含义一：数据结构 stack的第一种含义是一组数据的存放方式，特点为LIFO，即后进先出（Last in, first out）。 在这种数据结构中，数据像积木那样一层层堆起来，后面加入的数据就放在最上层。使用的时候，最上层的数据第一个被用掉，这就叫做"
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
Java实现的二叉树常用操作是指使用Java语言来实现二叉树的各种操作，包括前序建树、前中后递归非递归遍历、层序遍历等。下面我们将详细介绍这些操作的实现方法。 一、前序建树 前序建树是指从一个数组中构建一个...
【数据结构二叉树】先序层序建立、递归非递归遍历层序遍历、树高、镜面、对称、子树、合并、目标路径、带权路径和等等
likinguuu的博客
11-02 189
【数据结构二叉树】先序层序建立、递归非递归遍历层序遍历、树高、镜面、对称、子树、合并、目标路径、带权路径和等等
高级数据结构 | 创建二叉树 —递归与非递归实现：先序中序创建、中序后序创建 ...
专注于C/C++/Linux领域创作
04-08 2885
对于使用二叉链表结构存储的二叉树，我们通常使用递归—先序的方式创建，并且在输入树中结点的数据时需要人为的加入‘#’以表示叶子节点（度为0的点）。 而我们知道，给定一颗二叉树的中序遍历序列和其他任意一种优先深度遍历方式的序列都可以得到其完整的二叉树结构，那么我们能不能使用计算机来完成这一转化呢？ 换言之，我们本章重点为： 使用先序和中序创建二叉树 使用中序和后序创建二叉树 文章目录一、使用递归创...
【数据结构】——队列实现二叉树的功能
Lehjy的博客
12-09 1057
队列实现二叉树的层序遍历和判断是否是完全二叉树
charAt()的方法
weixin_30918633的博客
08-19 4202
一、charAt() 方法介绍 charAt() 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1。 二、使用方法 String message = "Welcome to java!"; char result = message.charAt(1); System.out.println(result);　 三、总结 string是java...
c语言版本二叉树基本操作示例(先序 递归 非递归)
09-04
在本文中，我们将探讨如何在C语言中实现二叉树的基本操作，包括创建、先序、中序、后序以及层序遍历。这些遍历方法既可以通过递归方式，也可以通过非递归方式实现。 首先，我们定义一个二叉树节点结构体`BTNode`，...
二叉树的遍历附上注释（先序，中序，后序，层序，递归与非递归）
07-26
二叉树的遍历附上注释（先序，中序，后序，层序，递归与非递归）
二叉树非递归遍历在C语言中通常通过栈（或队列实现层序遍历）来实现
最新发布
08-27
二叉树非递归遍历在C语言中通常通过栈（或队列实现层序遍历）来实现。对于前序、中序或后序遍历，可以使用栈来模拟递归调用的过程，手动维护节点访问的顺序。通过不断将节点压栈并在适当时候出栈访问，实现非递归...
史上最全二叉树的遍历方法
shzhqmeng的博客
05-24 399
#include<iostream> #include<sstream> #include<set> #include<stack> #include<queue> #include<vector>using namespace std;namespace tree{struct TNode { TNode* left; TNode* right; int val;
关于charAt（）的使用方法
热门推荐
m0_63757558的博客
06-19 2万+
Java中charAt使用方法
二叉树遍历完整版整理（含层次与递归非递归实现）
hoNgzc..的博客
10-11 1302
数据结构那时二叉树学得不是很深入，理解不够，借这段时间的复习，把二叉树的先序，中序，后序，层次遍历的各种实现重新的理解了一遍，在vs2017上码了一遍，然后我把函数都逐一写进了头文件。 . 其中《大话数据结构》中只讲到了先中后的递归算法，所以我也将他们的非递归版本也想写出来，有始有终，整理下也便于今后的学习。 . 讲到非递归的实现，我们都听过“递归的过程就是出入栈的过程”，所有的递归都可以写成非递...
数据结构—二叉树的非递归建立（先序和层次）和非递归遍历（四种）
qq_40339331的博客
05-15 3218
  二叉树的递归建立和遍历十分简单好写，为了加深对二叉树的理解这篇文章用c++实现了二叉树的建立，遍历，以及寻找根节点和别的节点之间的路径等功能，为了实现这些功能还写了必要的栈和队列的实现。1. 二叉树节点：typedef struct Btnode { // 二叉树单个节点    char data; //可以重复    struct Btnode *rchild; //右孩子(子树)    s...
LeetCode-105.从前序遍历和中序遍历构造二叉树
weixin_44227633的博客
05-22 275
题目： 代码： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class Solution { private: unordered_map<int,
最全二叉树详解
qq_36469679的博客
10-27 722
遍历二叉树的方法合集 1.二叉树的中序遍历（leetcode 94） 2.二叉树的前序遍历（leetcode 144） 3.二叉树的后序遍历（leetcode 145） 递归解法 前序遍历 public static void preOrderRecur(TreeNode head) { if (head == null) { return; } System.out.print(head.value + " "); preOrderRecur(head.le
jsp+dao+bean+servlet（MVC模式）实现简单用户登录和注册页面（连接数据库，登录页面包含验证码，两周内免登陆等功能）
qq_43505820的博客
11-08 1万+
jsp+java servlet实现简单用户登录（使用数据库，包括注册页面）功能介绍前期工作准备实现登录页面创建数据库三个页面处理欢迎界面（jsp）验证码(jsp)登录处理页面（servlet）欢迎界面实现注册页面 功能介绍 本项目通过使用jsp和servlet实现简单的用户登录。主要逻辑为： 如果用户不存在，则首先进行注册（注册信息同步到数据库中）。 进行注册后，可进入登录页面对账号进行登录。 如果账号存在，则正确跳转到欢迎界面，否则提示用户账号信息输入错误。 用户进行登录页面时需要填写验证码同时可勾选
Spring介绍
qq_43505820的博客
07-06 4760
学习目录 Spring的介绍 Spring的IOC介绍（控制反转） Spring的DI介绍(依赖注入) Spring的AOP介绍（横向切面技术）(->动态代码) 低侵入式的扩展新的功能 Spring和Mybatis的整合介绍 （SSM） Spring中的JDBCTenplate Spring中的事务配置 Spring中的设计模式 参考书籍 《Spring实战》 Spring的介绍 Spring是一个企业级的Java应用开发的框架 Spring是一个开源框架，轻量级，基础版本只有2M大小 Spring主
求n重幂详细过程代码及思路（java）
qq_43505820的博客
06-17 2477
一. 问题描述 设给定n个变量x1,x2,-----xn.将这些变量依序作底和各层幂，可得n重幂如下： ，这里将上述n重幂看作是不确定的，当在其中加入适当的括号后，才能成为确定的n重幂。不同的加括号方式导致不同的n重幂。例如，当n=4时，全部4重幂有5个。试着设计一个动态规划算法，对n个变量计算出有多少个不同的n重幂。 二．问题分析及算法描述（包含主要变量和函数功能介绍） 方法一：一位数组 问题分析：该题目看似复杂，实则可以理解为给x1-xn添加括号，使其最终结果不同，求加括号的个数。 算法思想：由分析可知
C语言二叉树创建与遍历示例(先序、递归与非递归)
本文档详细地探讨了如何在C语言中实现二叉树的基本操作，包括创建二叉树、遍历方法以及递归与非递归的实现方式。 首先，创建二叉树是基础，通过`BinTreeCreateBinTree()`函数，我们可以为给定的元素序列构建一个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值