java实现二叉树插入，遍历，反转操作

直接贴代码了。代码中有解释，很简单。

二叉树定义类（我这里直接用的中文定义，因为我本地的工程很多知识点，用中文名方便查找）：

package com.service.common.二叉树;

public class 二叉树<T> {
    public String Name;
    public T Data;
    public 二叉树<T> Left;
    public 二叉树<T> Right;
    private Boolean isLeaf;

    public 二叉树() {

    }

    public 二叉树(T data) {
        this.Data = data;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public T getData() {
        return Data;
    }

    public void setData(T data) {
        Data = data;
    }

    public 二叉树<T> getLeft() {
        return Left;
    }

    public void setLeft(二叉树<T> left) {
        Left = left;
    }

    public 二叉树<T> getRight() {
        return Right;
    }

    public void setRight(二叉树<T> right) {
        Right = right;
    }

    public Boolean getIsLeaf() {
        return isLeaf;
    }

    public void setIsLeaf(Boolean isLeaf) {
        this.isLeaf = isLeaf;
    }

}

二叉树的部分操作方法类（很多方法都是举一反三，这里只是举了前序遍历）

 

 

package com.service.common.二叉树;

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

import org.apache.poi.ss.formula.functions.T;

public class 二叉树操作 {

    // 插入操作
    public void insert(二叉树<String> root, String data) { // 向二叉树中插入节点
        if (root.getData() == null) {
            root.Data = data;
        } else {
            if (data.compareTo(root.Data) > 0) // 二叉树的右节点都比根节点大
            {
                if (root.Right == null) {
                    root.Right = new 二叉树(data);
                } else {
                    this.insert(root.Right, data);
                }
            } else { // 二叉树的左节点都比根节点小
                if (root.Left == null) {
                    root.Left = new 二叉树(data);
                } else {
                    this.insert(root.Left, data);
                }
            }
        }
    }

    // 递归前序遍历二叉树
    public void 前序遍历(二叉树<String> root) {
        // 左中右的顺序遍历
        if (root.getLeft() != null) {
            前序遍历(root.getLeft());
        }
        System.out.println(root.getData());// 输出父节点

        if (root.getRight() != null) {
            前序遍历(root.getRight());
        }
    }

    // 反转二叉树
    public void 反转二叉树(二叉树<String> root) {
        if (root == null) {
            return;
        }
        二叉树<String> leftTemp = root.getRight();
        root.Right = root.getLeft();
        root.Left = leftTemp;
        this.反转二叉树(root.Right);
        this.反转二叉树(root.Left);
    }

    // 使用栈也一样，就是一个先进后出和一个先进先出的差别，在这里只是作为一个工具来遍历，交换
    public 二叉树<T> 非递归反转使用队列(二叉树<T> root) {
        Queue<二叉树<T>> queue = new LinkedList<二叉树<T>>();
        // 首先将根节点放到队列
        queue.offer(root);
        // 借助queue将二叉树的左右节点放到队列从而实现遍历。
        while (!queue.isEmpty()) {// 相比于递归，只是栈深度变小了。不会有栈溢出的情况
            // 第一步取出root
            二叉树<T> temptree = queue.poll();// 获取并移出元素
            // 交换左右子树
            二叉树<T> leftTemp = temptree.Left;
            temptree.Left = temptree.Right;
            temptree.Right = leftTemp;
            // 如果左子树不为空放入到队列再交换左子树的子树
            if (temptree.Left != null) {
                queue.offer(temptree.Left);
            }
            // 右子树也一样的道理
            if (temptree.Right != null) {
                queue.offer(temptree.Right);
            }
        }

        return root;
    }

    public static void main(String[] args) {
        二叉树操作 treeOperate = new 二叉树操作();
        二叉树 tree = new 二叉树();
        treeOperate.insert(tree, "4");
        treeOperate.insert(tree, "2");
        treeOperate.insert(tree, "3");
        treeOperate.insert(tree, "4");
        treeOperate.insert(tree, "5");
        treeOperate.insert(tree, "6");
        treeOperate.前序遍历(tree);
        // treeOperate.反转二叉树(tree);//递归实现反转
        tree = treeOperate.非递归反转使用队列(tree);
        System.out.println("反转后的二叉树为：");
        treeOperate.前序遍历(tree);

    }

}