数据结构算法 (树 的基本算法)

一、树的序列化 和反序列化

1) 将二叉树进行序列化  和反序列化; 使用的是前序.

package com.tree;

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

// 将一个两叉树 序列化成 字符串 ; 
// 和将一字符串 反序列为一个树.
public class TreeNode_Serialization {
    public static void main(String[] args) {
        TreeNode_Serialization s = new TreeNode_Serialization();
        String str = "2!3!10!#!#!12!123!#!#!#!18!100!#!#!#!"; // 前序
        TreeNode node = s.pre_deserializationTreeNode(str);
        s.test(node);
        System.out.println();
        System.out.println(s.pre_serializTreeNode(node));
    }
    // 将一个两叉树 序列化成 字符串
    public String pre_serializTreeNode(TreeNode tree) {
        if (tree == null) {
            return "#!";
        }
        String str = tree.val + "!";
        str += pre_serializTreeNode(tree.left);
        str += pre_serializTreeNode(tree.right);
        return str;
    }
    // 将一个 字符串 反序列为一个树;// 前序遍历反序列化
    public TreeNode pre_deserializationTreeNode(String str) {
        String[] arrStr = str.split("!");
        Queue<String> qu = new LinkedList<String>();
        for (String s : arrStr) {
            qu.add(s);
        }
        return pre_deserializationTreeNodeCore(qu);
    }
    // 前序遍历反序列化。
    private TreeNode pre_deserializationTreeNodeCore(Queue<String> qu) {
        String str = qu.poll();
        TreeNode tree = new TreeNode();
        if ("#".equals(str)) {
            return null;
        }
        tree.left = pre_deserializationTreeNodeCore(qu);
        tree.val = Integer.valueOf(str);
        tree.right = pre_deserializationTreeNodeCore(qu);
        return tree;
    }
    public void test(TreeNode tree) {
        if (tree != null) {
            test(tree.left);
            System.out.print(tree.val + " ");
            test(tree.right);
        }
    }
}

2) 将二叉树进行序列化  和反序列化; 使用的是层次遍历.

二 、树的遍历（前中后【递归与非递归】，层次，显示结构的层次遍历）

1）树的非递归遍历（前中后）

package tree;

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

public class BinaryTreeTraversal_Preorder_Inorder_Postorder {
    public static void main(String[] args) {
        BinaryTreeTraversal_Preorder_Inorder_Postorder d = new BinaryTreeTraversal_Preorder_Inorder_Postorder();
        String[] pre_arrs = { "2", "1", "4", "#", "#", "6", "#", "#", "3","99","#", "#",
                "#" };
        Queue<String> queue = new LinkedList<String>();
        for (String s : pre_arrs) {
            queue.add(s);
        }
        TreeNode root = preCreateTreeNode(queue);
        List<Integer> list1 = d.preorderTraversal(root);
         List<Integer> list2 = d.inorderTraversal(root);
        List<Integer> list3 = d.postorderTraversal(root);
        System.out.println(Arrays.toString(list1.toArray()));
        System.out.println(Arrays.toString(list2.toArray()));
        System.out.println(Arrays.toString(list3.toArray()));
    }

    private static TreeNode preCreateTreeNode(Queue<String> queue) {
        String value = queue.poll();
        if ("#".equals(value)) {
            return null;
        }
        TreeNode node = new TreeNode();
        node.val = Integer.valueOf(value);
        node.left = preCreateTreeNode(queue);
        node.right = preCreateTreeNode(queue);
        return node;
    }

    private class Command {
        String s;
        TreeNode node;

        Command(String s, TreeNode node) {
            this.s = s;
            this.node = node;
        }
    }
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<Command> stack = new Stack<Command>();
        if (root == null)
            return result;
        stack.push(new Command("go", root)); // 访问每一个结点时，使用“go”
        while (!stack.isEmpty()) {
            Command command = stack.pop();
            if (command.s.equals("print")) { // 打印的命令
                result.add(command.node.val);
            } else { // / 即命令是 "go"
                assert command.s.equals("go");
                if (command.node.right != null) {
                    stack.push(new Command("go", command.node.right));
                }
                if (command.node.left != null) {
                    stack.push(new Command("go", command.node.left));
                }
                stack.push(new Command("print", command.node));
            }
        }
        return result;
    }
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<Command> stack = new Stack<Command>();
        if (root == null)
            return result;
        stack.push(new Command("go", root)); // 访问每一个结点时，使用“go”
        while (!stack.isEmpty()) {
            Command command = stack.pop();
            if (command.s.equals("print")) { // 打印的命令
                result.add(command.node.val);
            } else { // / 即命令是 "go"
                assert command.s.equals("go");
                if (command.node.right != null) {
                    stack.push(new Command("go", command.node.right));
                }
                stack.push(new Command("print", command.node));
                if (command.node.left != null) {
                    stack.push(new Command("go", command.node.left));
                }
            }
        }
        return result;
    }

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<Command> stack = new Stack<Command>();
        if (root == null)
            return result;
        stack.push(new Command("go", root)); // 访问每一个结点时，使用“go”
        while (!stack.isEmpty()) {
            Command command = stack.pop();
            if (command.s.equals("print")) { // 打印的命令
                result.add(command.node.val);
            } else { // / 即命令是 "go"
                assert command.s.equals("go");
                stack.push(new Command("print", command.node));
                if (command.node.right != null) {
                    stack.push(new Command("go", command.node.right));
                }
                if (command.node.left != null) {
                    stack.push(new Command("go", command.node.left));
                }
            }
        }
        return result;
    }

}

 2） 树的层次遍历，并显示树的层次

 public List<List<Integer>> hierarch(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if (root == null)
            return result;
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> line = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                line.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            result.add(line);
            
        }
        return result;
    }