二叉树学习总结（Java实现）

最近学习二叉树，做一些总结，内容包括：

1.创建二叉树

2.递归方法：先序 中序 后序

3.非递归：先序 中序 后序

4.宽度优先搜索

5.寻找父节点

如果有错误，还请及时指出，谢谢！

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

public class BinaryTreeStudy {

    public static void main(String[] args) {
        BinTree tree = new BinTree();
        tree.create();

        tree.preOrderWithRecusion();
        tree.inOrderWithRecusion();
        tree.postOrderWithRecusion();

        tree.preOrderWithoutRecusion();
        tree.inOrderWithoutRecusion();
        tree.postOrderWithoutRecusion();

        tree.levelOrader();

        tree.searchParent(5);

    }
}

class Node {
    int data;
    Node leftChild;
    Node rightChild;
}

class Item {
    Node node;
    boolean tag = false;
}

class BinTree {
    Node root;
    Scanner scanner = new Scanner(System.in);

    public BinTree() {
        root = null;
    }

    public void create() {
        System.out.println("请输入根节点,-1表示节点为空");
        root = createTree();
    }

    public Node createTree() {
        Node subRoot;
        int data = scanner.nextInt();
        if (data == -1) {
            subRoot = null;
        } else {
            subRoot = new Node();
            subRoot.data = data;
            System.out.println("请输入" + data + "的左子树");
            subRoot.leftChild = createTree();
            System.out.println("请输入" + data + "的右子树");
            subRoot.rightChild = createTree();
        }

        return subRoot;
    }

    public void preOrderWithRecusion() {
        System.out.println("递归：先序输出二叉树");
        preOrderWithRecusion(root);
        System.out.println();
    }

    // 递归：先序
    private void preOrderWithRecusion(Node root) {
        if (root != null) {
            System.out.print(root.data);
            preOrderWithRecusion(root.leftChild);
            preOrderWithRecusion(root.rightChild);
        }
    }

    public void inOrderWithRecusion() {
        System.out.println("递归：中序输出二叉树");
        inOrderWithRecusion(root);
        System.out.println();
    }

    // 递归：中序
    private void inOrderWithRecusion(Node root) {
        if (root != null) {
            inOrderWithRecusion(root.leftChild);
            System.out.print(root.data);
            inOrderWithRecusion(root.rightChild);
        }
    }

    public void postOrderWithRecusion() {
        System.out.println("递归：后序输出二叉树");
        postOrderWithRecusion(root);
        System.out.println();

    }

    // 递归：后序
    private void postOrderWithRecusion(Node root) {
        if (root != null) {
            postOrderWithRecusion(root.leftChild);
            postOrderWithRecusion(root.rightChild);
            System.out.print(root.data);
        }
    }

    public void preOrderWithoutRecusion() {
        System.out.println("非递归：先序输出二叉树");
        preOrderWithoutRecusion(root);
        System.out.println();
    }

    // 非递归：先序
    private void preOrderWithoutRecusion(Node subRoot) {
        Stack<Node> stack = new Stack<Node>();
        Node pointer = subRoot;

        while (pointer != null) {
            System.out.print(pointer.data);

            if (pointer.rightChild != null) {
                stack.push(pointer.rightChild);
            }

            if (pointer.leftChild != null) {
                pointer = pointer.leftChild;
            } else {
                if (!stack.isEmpty()) {
                    pointer = stack.pop();
                } else {
                    pointer = null;
                }
            }

        }

    }

    public void inOrderWithoutRecusion() {
        System.out.println("非递归：中序输出二叉树");
        inOrderWithoutRecusion(root);
        System.out.println();
    }

    // 非递归：中序
    private void inOrderWithoutRecusion(Node subRoot) {
        Stack<Node> stack = new Stack<Node>();
        Node pointer = subRoot;

        while (pointer != null || !stack.isEmpty()) {
            if (pointer != null) {
                stack.push(pointer);
                pointer = pointer.leftChild;
            } else {
                pointer = stack.pop();
                System.out.print(pointer.data);
                pointer = pointer.rightChild;
            }
        }
    }

    public void postOrderWithoutRecusion() {
        System.out.println("非递归：后序输出二叉树");
        postOrderWithoutRecusion(root);
        System.out.println();
    }

    // 非递归：后序
    private void postOrderWithoutRecusion(Node subRoot) {
        boolean LEFT = false;
        boolean RIGHT = true;
        Stack<Item> stack = new Stack<Item>();
        Node pointer = subRoot;
        while (pointer != null || !stack.isEmpty()) {
            Item item = null;
            while (pointer != null) {
                item = new Item();
                item.node = pointer;
                item.tag = LEFT;
                stack.push(item);
                pointer = pointer.leftChild;
            }

            item = stack.pop();
            pointer = item.node;

            if (item.tag == LEFT) {
                item.tag = RIGHT;
                stack.push(item);
                pointer = pointer.rightChild;
            } else {
                System.out.print(pointer.data);
                pointer = null;
            }

        }
    }

    public void levelOrader() {
        System.out.println("宽度优先：");
        levelOrader(root);
        System.out.println();
    }

    // 宽度优先搜索二叉树
    private void levelOrader(Node subRoot) {
        LinkedList<Node> nodes = new LinkedList<Node>();

        Node pointer = subRoot;
        if (pointer != null) {
            nodes.offer(pointer);
        }

        while (!nodes.isEmpty()) {
            pointer = nodes.poll();
            System.out.print(pointer.data);

            if (pointer.leftChild != null) {
                nodes.offer(pointer.leftChild);
            }

            if (pointer.rightChild != null) {
                nodes.offer(pointer.rightChild);
            }

        }

    }

    public void searchParent(int data) {
        System.out.println("搜索" + data + "的父节点：");
        Node parent = searchParent(root, data);
        System.out.println(parent.data);
    }

    // 查找父节点
    private Node searchParent(Node subRoot, int data) {
        if (subRoot == null) {
            return null;
        }

        if (subRoot.leftChild != null && subRoot.leftChild.data == data) {
            return subRoot;
        }

        if (subRoot.rightChild != null && subRoot.rightChild.data == data) {
            return subRoot;
        }

        Node pointer = null;
        if ((pointer = searchParent(subRoot.leftChild, data)) != null) {
            return pointer;
        }

        if ((pointer = searchParent(subRoot.rightChild, data)) != null) {
            return pointer;
        }

        return null;
    }

}

 非递归搜索父节点：

   public void searchParentWithoutRecusion(int data) {
        System.out.println("非递归搜索" + data + "的父节点：");
        Node parent = searchParentWithoutRecusion(root, data);
        System.out.println(parent.data);
    }

    private Node searchParentWithoutRecusion(Node subRoot, int data) {
        Node pointer = subRoot;
        Stack<Node> nodes = new Stack<Node>();
        nodes.push(null);
        while (pointer != null) {
            if (pointer.leftChild != null && pointer.leftChild.data == data) {
                return pointer;
            }

            if (pointer.rightChild != null && pointer.rightChild.data == data) {
                return pointer;
            }

            if (pointer.rightChild != null) {
                nodes.push(pointer.rightChild);
            }

            if (pointer.leftChild != null) {
                pointer = pointer.leftChild;
            } else {
                pointer = nodes.pop();
            }
        }

        return null;
    }