二叉排序树

二叉排序树

主要记录了二叉排序数的建立，前中后便利（递归的和非递归的）。代码主要使用Java语言编写。如下所示：

import java.util.Scanner;
import java.util.Stack;

public class Main {

    public static class TreeNode {
        int val;
        TreeNode lefTreeNode;
        TreeNode rightTreeNode;

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

    public static class BinaryTree {
        TreeNode root;

        public BinaryTree(int root_data) {
            root = new TreeNode(root_data);
        }

        public void insert(int data) {
            TreeNode current_node = root;
            TreeNode before_node = root;
            while (current_node != null) {
                if (current_node.val < data) {
                    before_node = current_node;
                    current_node = current_node.rightTreeNode;
                } else {
                    before_node = current_node;
                    current_node = current_node.lefTreeNode;
                }
            }
            if (before_node.val < data) {
                before_node.rightTreeNode = new TreeNode(data);
            } else {
                before_node.lefTreeNode = new TreeNode(data);
            }
        }

        public void preOrder(TreeNode current_node) {
            if (current_node != null) {
                System.out.print(current_node.val + " ");
                this.preOrder(current_node.lefTreeNode);
                this.preOrder(current_node.rightTreeNode);
            }
        }

        public void noRecursionPreOrder() {
            Stack<TreeNode> stack = new Stack<>();
            stack.push(root);
            while (!stack.empty()) {
                TreeNode current_node = stack.pop();
                System.out.print(current_node.val + " ");
                if (current_node.rightTreeNode != null)
                    stack.push(current_node.rightTreeNode);
                if (current_node.lefTreeNode != null)
                    stack.push(current_node.lefTreeNode);
            }
        }

        public void inOrder(TreeNode current_node) {
            if (current_node != null) {
                this.inOrder(current_node.lefTreeNode);
                System.out.print(current_node.val + " ");
                this.inOrder(current_node.rightTreeNode);
            }
        }

        public void noRecursionInOrder() {
            Stack<TreeNode> stack = new Stack<>();
            TreeNode current_nodeNode = root;
            while (!stack.empty() || current_nodeNode != null) {
                while (current_nodeNode != null) {
                    stack.push(current_nodeNode);
                    current_nodeNode = current_nodeNode.lefTreeNode;
                }
                if (!stack.empty()) {
                    current_nodeNode = stack.pop();
                    System.out.print(current_nodeNode.val + " ");
                    current_nodeNode = current_nodeNode.rightTreeNode;
                }
            }
        }

        public void postOrder(TreeNode current_node) {
            if (current_node != null) {
                this.postOrder(current_node.lefTreeNode);
                this.postOrder(current_node.rightTreeNode);
                System.out.print(current_node.val + " ");
            }
        }

        public void noRecursionPostOrder() {
            Stack<TreeNode> stack = new Stack<>();
            Stack<TreeNode> outStack = new Stack<>();
            stack.push(root);
            while (!stack.empty()) {
                TreeNode current_node = stack.pop();
                outStack.push(current_node);
                if (current_node.lefTreeNode != null)
                    stack.push(current_node.lefTreeNode);
                if (current_node.rightTreeNode != null)
                    stack.push(current_node.rightTreeNode);
            }
            while (!outStack.empty()) {
                TreeNode currendNode = outStack.pop();
                System.out.print(currendNode.val + " ");
            }
        }

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] arrays = new int[n];
        for (int i = 0; i < n; i++) {
            arrays[i] = scanner.nextInt();
        }

        BinaryTree binaryTree = new BinaryTree(arrays[0]);
        for (int i = 1; i < arrays.length; i++)
            binaryTree.insert(arrays[i]);
        // binaryTree.preOrder(binaryTree.root);
        // binaryTree.inOrder(binaryTree.root);
        // binaryTree.postOrder(binaryTree.root);
        // binaryTree.noRecursionPreOrder();
        //binaryTree.noRecursionInOrder();
         binaryTree.noRecursionPostOrder();
    }

}

测试数据

输入：

10
59 88 55 12 77 11 22 33 66 75

输出：

前序：59 55 12 11 22 33 88 77 66 75 
中序：11 12 22 33 55 59 66 75 77 88 
后序：11 33 22 12 55 75 66 77 88 59