二叉树的四种遍历算法实现,没你想得那么难

二叉树的遍历

我用下图的树为例,做树的遍历:

二叉树结构

树节点的定义:

public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
    public TreeNode(int val, TreeNode left, TreeNode right) {
        super();
        this.val = val;
        this.left = left;
        this.right = right;
    }}树的结构的代码实现:public static void main(String[] args) {
       TreeNode e = new TreeNode(1);
       TreeNode g = new TreeNode(2);
       TreeNode h = new TreeNode(3);
       TreeNode i = new TreeNode(4);
       TreeNode d = new TreeNode(5,null,g);
       TreeNode f = new TreeNode(6,h,i);
       TreeNode b = new TreeNode(7,d,e);
       TreeNode c = new TreeNode(8,f,null);
       TreeNode root = new TreeNode(9,b,c);}

中序遍历

  • 先处理左子树,然后处理当前节点,再处理右子树。
  • 对于一颗二叉查找树,所有的信息都是有序排列的,中序遍历可以是信息有序输出,且运行时间为O(n)。
  • 递归实现中序遍历:
public static void printTree(TreeNode t){
       if(t!=null){
           printTree(t.left);
           System.out.print(t.val+" ");
           printTree(t.right);
       }
   }

输出结果:
5 2 7 1 9 3 6 4 8

后序遍历

  • 先处理左右子树,然后再处理当前节点,运行时间为O(n)。
  • 递归实现后序遍历:
public static void printTree(TreeNode t){
        if(t!=null){
            printTree(t.left);
            printTree(t.right);
            System.out.print(t.val+" ");
        }
    }

输出结果:
2 5 1 7 3 4 6 8 9

先序遍历

  • 先处理当前节点,在处理左右子树。
  • 递归实现先序遍历:
public static void printTree(TreeNode t){
        if(t!=null){
            System.out.print(t.val+" ");
            printTree(t.left);
            printTree(t.right);
        }
    }

输出结果:
9 7 5 2 1 8 6 3 4

有没有觉得树的先序,中序,后序遍历都非常简单,递归三行代码就搞定了。好吧,下边厉害的要来了

层序遍历

  • 层序遍历:所有深度为D的节点要在深度为D+1的节点之前进行处理,层序遍历与其他类型的遍历不同的地方在于它不是递归地执行的,它用到队列,而不使用递归所默示的栈。
  • 算法思想:
  1. 定义节点 TreeNode lastNode指向当前行最有节点,TreeNode nlastNode指向下一行最右节点。
  2. 利用队列,首先将根节点入队,再循环里出队,并将其子节点入队,定义TreeNode tmpNode节点指向当前出队列的节点,当tmpNode==lastNode时,代表当前行遍历结束,输出换行,再令lastNode=nlastNode,nlastNode在子节点入队列时指向下一行最右节点。循环直到对列为空就行。
  • 层序遍历代码:
package Tree;import java.util.ArrayList;import java.util.LinkedList;import java.util.List;import java.util.Queue;/* * 层序遍历 *  */public class TreePrinter1 {
     public static int[][] printTree(TreeNode root) {
         List< List<Integer> > list = new ArrayList< List<Integer> >();
         list.add(new ArrayList<Integer>());
         Queue<TreeNode> queue = new LinkedList<TreeNode>();
            queue.add(root);
            TreeNode lastNode = root;    // 当前行最右节点
            TreeNode nlastNode = root;    // 下一行最右节点
            TreeNode tmpNode = null;
            int hight = 0;                // 树的高度
            while(!queue.isEmpty()){
                tmpNode = queue.poll();
                if(tmpNode!=null){
                    list.get(hight).add(tmpNode.val);
                }
                if(tmpNode.left!=null){
                    queue.add(tmpNode.left);
                    nlastNode = tmpNode.left;
                }
                if(tmpNode.right!=null){
                    queue.add(tmpNode.right);
                    nlastNode = tmpNode.right;
                }
                if(tmpNode == lastNode){
                    lastNode = nlastNode;
                    hight++;
                    list.add(new ArrayList<Integer>());
                }
            }
            int[][] data = new int[list.size()][];
            for(int i=0;i<list.size();i++){
                for(int j=0;j<list.get(i).size();j++){
                    data[i][j] = list.get(i).get(j);
                }
            }

        return data;
     }
     public static void main(String[] args) {
           TreeNode e = new TreeNode(1);
           TreeNode g = new TreeNode(2);
           TreeNode h = new TreeNode(3);
           TreeNode i = new TreeNode(4);
           TreeNode d = new TreeNode(5,null,g);
           TreeNode f = new TreeNode(6,h,i);
           TreeNode b = new TreeNode(7,d,e);
           TreeNode c = new TreeNode(8,f,null);
           TreeNode root = new TreeNode(9,b,c);
           int[][] data  =TreePrinter.printTree(root);
           for(int s=0;s<data.length;s++){
               for(int j=0;j<data[s].length;j++){
                   System.out.print(data[s][j]+" ");
               }
               System.out.println();
           }
    }}

输出结果:
9
7 8
5 1 6
2 3 4

原文地址:https://www.cnblogs.com/bianchengrufeng/p/11152890.html

时间: 2024-10-09 18:02:48

二叉树的四种遍历算法实现,没你想得那么难的相关文章

二叉树的四种遍历方式

二叉树的四种遍历方式: 二叉树的遍历(traversing binary tree)是指从根结点出发,按照某种次序依次访问二叉树中所有的结点,使得每个结点被访问依次且仅被访问一次.四种遍历方式分别为:先序遍历.中序遍历.后序遍历.层序遍历. 遍历之前,我们首先介绍一下,如何创建一个二叉树,在这里博主宝宝用的是先建左树在建右树的方法, 首先要声明结点TreeNode类,代码如下: public class TreeNode { public int data; public TreeNode le

二叉树的四种遍历方法(递归、迭代)

一.前序遍历 前序遍历简单来讲,遍历顺序是:根节点-左子树-右子树 1.递归遍历 1 void preorder(BinTree *T) 2 { 3 if(T==NULL) 4 return; 5 cout << T->data; 6 preorder(T->left); 7 preorder(T->right); 8 } 2.迭代遍历(用栈实现) 1 void preorder2(BinTree *T) 2 { 3 //空树,直接返回 4 if(T==NULL) 5 ret

java实现二叉树的三种遍历算法(递归)

一,定义一个节点类: package test; public class Node { private int data; private Node left; private Node right; public Node(int data) { this.data = data; } public int getData() { return data; } public void setData(int data) { this.data = data; } public Node ge

C++算法之 求二叉树的节点个数、深度、四种遍历方法

//节点的数据结构 class BTree { public: int m_nValue; BTree* m_nLeft; BTree* m_nRight; public: BTree(int value) { m_nValue = value; } }; 一:求二叉树的节点个数: /* 求二叉数中的节点个数 递归解法: 1:如果二叉树为空,节点的个数为0 2:如果二叉树不为空,二叉树节点的个数 = 左子树节点个数+右子树节点的个数+1: */ int GetNodeCount(BTree* p

二叉树几种遍历算法的非递归实现

二叉树遍历的非递归实现 相对于递归遍历二叉树,非递归遍历显得复杂了许多,但换来的好处是算法的时间效率有了提高.下面对于我学习非递归遍历二叉树算法的过程进行总结 为了便于理解,这里以下图的二叉树为例,分析二叉树的三种遍历方式的实现过程. 一.非递归实现二叉树的前序遍历 不借助递归,要实现二叉树的前序遍历,我们需要用到前面学过的栈这种数据结构.根据前序遍历的定义,先访问根节点,再访问左子树,最后访问右子树.声明指向节点的指针pCur,我们可以先访问根节点,之后让根节点进栈,并让pCur在左子树上移动

二叉树的创建和四种遍历(前序、先序、后序、层次、结点的层数、深度、叶子数等)—java描述

二叉树的创建和四种遍历(前序.先序.后序.层次.结点的层数.深度.叶子数等)—java描述 package javab; //树的结点类 public class TreeNode { String data; TreeNode leftChild,rightChild,next; public TreeNode(String data){ this.data=data; } public TreeNode(String data,TreeNode left,TreeNode right){ l

PHP四种基础算法详解

许多人都说 算法是程序的核心,一个程序的好于差,关键是这个程序算法的优劣.作为一个初级phper,虽然很少接触到算法方面的东西 .但是对于冒泡排序,插入排序,选择排序,快速排序四种基本算法,我想还是要掌握的. 需求:分别用 冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中 的值按照从小到的顺序进行排序. $arr=array(11,3,56,62,21,66,32,78,36,76,39,88,34); 1.冒泡排序 介绍: 冒泡排序(Bubble Sort,台湾译为:泡沫排序或气泡排

php四种基础算法:冒泡,选择,插入和快速排序法

转自:http://www.php100.com/html/php/rumen/2013/1029/6333.html 许多人都说 算法是程序的核心,一个程序的好于差,关键是这个程序算法的优劣.作为一个初级phper,虽然很少接触到算法方面的东西 .但是对于冒泡排序,插入排序,选择排序,快速排序四种基本算法,我想还是要掌握的.下面是我按自己的理解,将四个方法分析一遍. 需求:分别用 冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中 的值按照从小到的顺序进行排序. $arr(1,43,5

php四种基础算法:冒泡,选择,插入和快速排序法PHP基础教程

许多人都说 算法是程序的核心,一个程序的好于差,关键是这个程序算法的优劣.作为一个初级phper,虽然很少接触到算法方面的东西.但是对于冒泡排序,插入排序,选择排序,快速排序四种基本算法,我想还是要掌握的.下面兄弟连PHP培训 小编将四个方法分析一遍. 需求:分别用 冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中 的值按照从小到的顺序进行排序. $arr(1,43,54,62,21,66,32,78,36,76,39); 1. 冒泡排序法 * 思路分析:法如其名,就是像冒泡一样,每次