树-常见数据结构与算法

二叉树常见数据结构与算法

入门（先序遍历/中序遍历/后序遍历/层次遍历）

掌握preOrder/InOrder/PostOrder/LevelOrder是最基础的！下面给出的是Java的递归版本。

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

class Node{
    int key;
    Node left;
    Node right;
    public Node(int item){
        key=item;
        left=null;
        right=null;
    }
}
public class TreeTraversals {
    //先序遍历
    public static void printPreorder(Node node){
        if(node==null){
            return;
        }
        System.out.print(node.key+" ");
        printPostorder(node.left);
        printPostorder(node.right);
    }
    //中序遍历
    public static void printInorder(Node node){
        if(node==null){
            return;
        }
        printPostorder(node.left);
        System.out.print(node.key+" ");
        printPostorder(node.right);
    }
    //后序遍历
    public static void printPostorder(Node node){
        if(node==null){
            return;
        }
        printPostorder(node.left);
        printPostorder(node.right);
        System.out.print(node.key+" ");
    }
    //层次遍历
    public static void printLevelOrder(Node node){
        Queue<Node> queue=new LinkedList<>();
        queue.add(node);
        while (!queue.isEmpty()){
            Node tempNode=queue.poll();   //获取并移除
            System.out.println(tempNode.key);
            if(tempNode.left!=null){
                queue.add(tempNode.left);
            }
            if(tempNode.right!=null){
                queue.add(tempNode.right);
            }
        }
    }
    public static void main(String[] args) {
        Node node=new Node(1);
        node.left=new Node(2);
        node.right=new Node(3);
        node.left.left=new Node(4);
        node.left.right=new Node(5);
        printLevelOrder(node);
    }
}

练习题

/*有一棵二叉树，请设计一个算法，按照层次打印这棵二叉树。

给定二叉树的根结点root，请返回打印结果，结果按照每一层一个数组进行储存，所有数组的顺序按照层数从上往下，且每一层的数组内元素按照从左往右排列。保证结点数小于等于500。*/

import java.util.ArrayList;
import java.util.LinkedList;

//按层次遍历并层打印
public class LevelOrderPractice {

    public static void LevelPrint(TreeNode root){
        LinkedList<TreeNode> queue=new LinkedList<>();       //实现层次遍历的队列
        ArrayList<Integer> temp=new ArrayList<>();  //记录每层的数组
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();  //二维ArrayList
        TreeNode node =null;  //进入循环的节点，作用相当于指针
        TreeNode last=root;
        TreeNode nlast=last;
        queue.offer(root);
        if(root==null){
            return ;
        }
        while (!queue.isEmpty()){
            node =queue.poll();
            temp.add(node.val);

            if(node.left!=null){
                queue.offer(node.left);
                nlast= node.left;
            }
            if(node.right!=null){
                queue.offer(node.right);
                nlast= node.right;
            }
            if(node ==last){
                res.add(temp);
                temp=new ArrayList<Integer>();
                last=nlast;
            }
        }
        System.out.println("层数："+res.size());
        int[][] result = new int[res.size()][];
        for(int i=0;i<res.size();i++){
            result[i] = new int[res.get(i).size()];
            for(int j=0;j<result[i].length;j++){
                result[i][j] = res.get(i).get(j);
                System.out.println(result[i][j]);
            }
        }
    }
    public static void main(String[] args) {
        TreeNode treeNode =new TreeNode(1);
        treeNode.left=new TreeNode(2);
        treeNode.right=new TreeNode(3);
        treeNode.left.left=new TreeNode(4);
        treeNode.left.right=new TreeNode(5);
        LevelPrint(treeNode);
    }
}