树的遍历

4人阅读 评论(0) 收藏 举报
分类:
package tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class Solution {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[][] nums = {{1, 2, 3, 4, 5}, {4, 5, 3, 2, 1}};
        TreeNode root = solution.buildTree(new int[]{1, 2, 3, 4, 5, 6, 7});
        solution.prePrint(root);
        System.out.println();
        solution.preIterator(root);
        System.out.println();
        solution.inPrint(root);
        System.out.println();
        solution.inIterator(root);
        System.out.println();
        solution.postPrintTree(root);
        System.out.println();
        solution.postIterator(root);
        System.out.println();

    }

    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> al = new ArrayList<>();
        if (root == null) return al;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Queue<TreeNode> temp = new LinkedList<>();
            while (!queue.isEmpty()) {
                TreeNode cur = queue.poll();
                al.add(cur.val);
                if (cur.left != null) temp.offer(cur.left);
                if (cur.right != null) temp.offer(cur.right);
            }
            queue = temp;
        }
        return al;
    }

    public boolean HasSubtree(TreeNode root1, TreeNode root2) {
        if (root1 == null || root2 == null) return false;
        if (root1.val == root2.val) {
            if (isSubTree(root1, root2)) return true;
        }
        return HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
    }

    private boolean isSubTree(TreeNode root1, TreeNode root2) {
        if (root2 == null) return true;
        else if (root1 == null) return false;
        if (root1.val != root2.val) return false;
        return isSubTree(root1.left, root2.left) && isSubTree(root1.right, root2.right);
    }

    public void Mirror(TreeNode root) {
        if (root == null) return;
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        Mirror(root.left);
        Mirror(root.right);
    }

    public TreeNode buildTree(int[] nums) {
        int index = 0;
        TreeNode root = new TreeNode(nums[index++]);
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        pointA:
        while (index < nums.length) {
            Queue<TreeNode> temp = new LinkedList<>();
            while (!queue.isEmpty()) {
                TreeNode cur = queue.poll();
                if (index < nums.length) {
                    cur.left = new TreeNode(nums[index++]);
                    temp.offer(cur.left);
                }
                if (index < nums.length) {
                    cur.right = new TreeNode(nums[index++]);
                    temp.offer(cur.right);
                } else {
                    break pointA;
                }
            }
            queue = temp;
        }
        return root;
    }

    //先序遍历
    public void prePrint(TreeNode root) {
        if (root == null) return;
        System.out.print(root.val + ",");
        if (root.left != null) prePrint(root.left);
        if (root.right != null) prePrint(root.right);
    }
    public void preIterator(TreeNode root) {
        if (root == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while (!stack.empty() || p != null) {
            while (p != null) {
                System.out.print(p.val + "-->");//若节点不为空先访问再压栈(每个节点都可以看成根节点)
                stack.push(p);
                p = p.left;//将当前节点置为p的左孩子,若不为空继续访问并压栈
            }
            //当p为空时,说明根节点和左孩子打印遍历完毕了,接下来出栈遍历右孩子
            if (!stack.empty()) {
                p = stack.pop();
                p = p.right;
            }
        }
    }
    //中序遍历
    public void inPrint(TreeNode root){
        if (root == null) return;
        if (root.left != null) inPrint(root.left);
        System.out.print(root.val + ",");
        if (root.right != null) inPrint(root.right);
    }
    public void inIterator(TreeNode root) {
        if (root == null)
            return;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;//让p指向根节点
        while (!stack.empty() || p != null) {
            //一直遍历到左子树最下边,边遍历边保存根节点到栈中(每个节点都可以看成一个新的子树的根节点)
            while (p != null) {
                stack.push(p);//若节点的左孩子不为空,将左孩子压栈,因为需要借助遍历过的节点进入右子树
                p = p.left;
            }
            //当p为空时,说明已经到达左子树最下边,这时需要出栈了
            if (!stack.isEmpty()) {
                p = stack.pop();
                System.out.print(p.val + "-->");//访问根节点
                p = p.right;//进入右子树,此时p是右子树的根节点(开始新一轮的遍历)
            }
        }

    }

    //后序遍历
    public void postPrintTree(TreeNode root) {
        if (root == null) return;
        if (root.left != null) postPrintTree(root.left);
        if (root.right != null) postPrintTree(root.right);
        System.out.print(root.val + ",");
    }

    public void postIterator(TreeNode root) {
        if (root == null)
            return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode pre = null;//当前节点的之前访问的节点
        TreeNode current;
        stack.push(root);
        while (!stack.empty()) {
            current = stack.peek();
            if ((current.left == null && current.right == null) ||  //当前节点是叶子节点,可以直接访问该节点
                    (pre != null && (pre == current.left || pre == current.right)))
            //当前一个节点不为空并且是当前节点的左孩子或者右孩子,当是左孩子时说明当前节点右孩子为空,当是右孩子时,说明左右孩子都访问过了,且都不为空
            {
                System.out.print(current.val + "-->");
                stack.pop();
                pre = current;
            } else  //当前节点为栈顶元素  如果当前节点不是叶子节点,在当前节点之前访问的那个节点不是当前节点的孩子,则进行压栈
            {
                if (current.right != null) //先压栈右节点再压栈左节点 这样出栈时是先左后右
                {
                    stack.push(current.right);
                }
                if (current.left != null) {
                    stack.push(current.left);
                }
            }
        }
    }

    public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
        return reConstructBinaryTree(pre, in, 0, in.length - 1);
    }

    public TreeNode reConstructBinaryTree(int[] pre, int[] in, int begin, int end) {
        TreeNode node;
        if (begin > end) return null;
        else if (begin == end) return new TreeNode(in[begin]);
        int index = -1;
        BEGIN:
        for (int i : pre) {
            for (int j = begin; j <= end; j++) {
                if (in[j] == i) {
                    index = j;
                    break BEGIN;
                }
            }
        }
        if (index == -1) return null;
        node = new TreeNode(in[index]);
        node.left = reConstructBinaryTree(pre, in, begin, index - 1);
        node.right = reConstructBinaryTree(pre, in, index + 1, end);
        return node;
    }

    public void levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {

            Queue<TreeNode> temp = new LinkedList<>();

            while (!queue.isEmpty()) {
                TreeNode cur = queue.poll();
                System.out.print(cur.val + ",");
                if (cur.left != null) temp.offer(cur.left);
                if (cur.right != null) temp.offer(cur.right);
            }

            queue = temp;
        }
        System.out.println();
    }

}
查看评论

jquery遍历节点树

  • 2011年03月29日 16:36
  • 2KB
  • 下载

数据结构 树 节点

  • 2011年11月03日 09:11
  • 33KB
  • 下载

数据结构——树的遍历

原文地址:Tree Traversals 不像线性数据结构(数组,列表,队列,堆栈等),它们在逻辑上只有一种遍历方式,树可以有不同的遍历方式。下面就是遍历树的一般所用的方法: 深度优先遍历: ...
  • sinat_36246371
  • sinat_36246371
  • 2016-11-26 15:08:15
  • 1214

树的基本概念和遍历规则

树的递归定义 树是n(n>0)个结点的有限集,这个集合满足以下条件:       ⑴有且仅有一个结点没有前驱(父亲结点),该结点称为树的根;       ⑵除根外,其余的每个结点都有且仅有一个前驱; ...
  • BOYxiejunBOY
  • BOYxiejunBOY
  • 2015-07-21 12:00:26
  • 2202

【数据结构和算法】全面剖析树的各类遍历方法

面试中常考到树的前序,中序,后序和层序遍历,这篇博文就带你深度剖析一下二叉树的各类遍历算法的实现二叉树的遍历主要有四种,前序、中序、后序和层序遍历的实现方式主要是:递归和非递归递归遍历的实现非常容易,...
  • terence1212
  • terence1212
  • 2016-08-11 15:10:52
  • 8079

B-树的插入和遍历

B-树是一种平衡的多叉树,一颗M阶(M>2)的B树,是一颗平衡的M路平衡搜索树,可以是空树或者满足下列性质: 1. 根节点至少有两个孩子 2. 每个非根节点有[ [M/2],M]个孩子 3. 每个非根...
  • no_name_sky
  • no_name_sky
  • 2017-05-08 14:21:34
  • 717

树遍历的应用——树的重建

树遍历的应用——树的重建 问题描述:现有两个结点序列,分别是对同一个二叉树进行前序遍历和中序遍历。请输出该二叉树的后序遍历。   输入:第一行输入二叉树的结点数。            第二行...
  • wyf12138
  • wyf12138
  • 2016-10-29 10:15:54
  • 239

树的完整实现--遍历--应用

//Tree.h #pragma once #include #include using namespace std; template class Tree; template class Tre...
  • zr1076311296
  • zr1076311296
  • 2016-03-18 22:31:27
  • 989

PATL2-006. 树的遍历

用的是递归的思想,找到每一层的根节点,然后进行建树。最后用个bfs将这个树输出 AC代码: /* *********************************************** A...
  • sinat_30126425
  • sinat_30126425
  • 2016-07-11 21:11:06
  • 1940

树以及树的遍历和搜索

普通树的定义、数据结构表示,树的前序、后序、中序遍历的递归和非递归算法实现,树的深度搜索和广度搜索算法实现....
  • whucyl
  • whucyl
  • 2013-11-12 20:29:58
  • 3004
    个人资料
    持之以恒
    等级:
    访问量: 6179
    积分: 913
    排名: 5万+
    最新评论