二叉树的一些基础知识及创建、遍历

 

红黑树：是一种平衡二叉查找树，具有以下性质

 

（1）节点拥有颜色，不是黑色就是红色

（2）根节点是黑色的

（3）叶子节点也是黑色的（叶子结点null节点）

（4）每个红色节点的两个子节点都是黑色的，即从叶子到根不存在两个连续的节点都是红色的

（5）从任一节点到单个叶子节点的任意简单路径所包含的黑色节点的数目是一样的

 

二叉排序树/二叉查找树或者是一棵空树，或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

 

完全二叉树：除最后一层，其余层的节点数都达到最大值，且最后一层的节点是从左向右排列的

满二叉树：除了叶子节点外，每个节点都有2个子节点，且所有叶子节点都在同一层

平衡二叉树：平衡二叉树的左右子数都是平衡二叉树，且左右子树的高度差的绝对值不大于1

 

以下为创建遍历二叉树的代码

 

 

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

/**
 * Created by 亮大王 on 2017/9/18.
 */
public class treeNode {
    public int data;
    public treeNode lchild;
    public treeNode rchild;

    public treeNode(int data) {
        this.data = data;
        lchild = null;
        rchild = null;
    }

    /**
     * 先序创建一个二叉树
     */
    public treeNode createTree(int[] a, int i) {//传入的数组a[]为一个先序遍历的数组，元素为-1代表为空子树
        treeNode root = null;
        if (i < a.length) {
            if (a[i] != -1) {
                root = new treeNode(a[i]);
                root.lchild = createTree(a, i++);
                root.rchild = createTree(a, i++);
            }
        }
        return root;
    }

    /**
     * 先序遍历
     */

    public void prePrint(treeNode root) {
        if (root != null) {
            System.out.println(root.data);
            prePrint(root.lchild);
            prePrint(root.rchild);
        }
    }

    public void prePrint1(treeNode root) { //非递归前序遍历1
        Stack<treeNode> stack = new Stack<treeNode>();
        treeNode node = null;
        if (root != null) {
            stack.push(root);
            while (!stack.empty()) {
                node = stack.pop();
                System.out.println(node.data);
                if (node.rchild != null)
                    stack.push(node.rchild);
                if (node.lchild != null)
                    stack.push(node.lchild);
            }
        }
    }

    public void prePrint2(treeNode root) { //非递归前序遍历2
        Stack<treeNode> stack = new Stack<treeNode>();
        treeNode node = root;
        while (node != null || !stack.empty()) {
            while (node != null) {
                System.out.println(node.data);
                stack.push(node);
                node = node.lchild;
            }
            if (!stack.empty()) {
                node = stack.pop();
                node = node.rchild;
            }
        }
    }

    /**
     * 中序遍历
     */

    public void midPrint(treeNode root) {
        if (root != null) {
            midPrint(root.lchild);
            System.out.println(root.data);
            midPrint(root.rchild);
        }
    }

    public void midPrint1(treeNode root) { //非递归中序遍历
        Stack<treeNode> stack = new Stack<treeNode>();
        treeNode node = root;
        while (node != null || !stack.empty()) {
            while (node != null) {
                stack.push(node);
                node = node.lchild;
            }
            if (!stack.empty()) {
                node = stack.pop();
                System.out.println(node.data);
                node = node.rchild;
            }
        }
    }

    /**
     * 后序遍历
     */

    public void binPrint(treeNode root) {
        if (root != null) {
            binPrint(root.lchild);
            binPrint(root.rchild);
            System.out.println(root.data);
        }
    }

    public void binPrint1(treeNode root) { //非递归后序遍历
        Stack<treeNode> stack = new Stack<treeNode>();
        treeNode pcur = null; //当前结点
        treeNode pre = null; //上一个输出的节点
        if (root != null)
            stack.push(root);
        while (!stack.empty()) {
            pcur = stack.peek(); // peek()和pop()两者都可以得到栈顶的元素，区别是peek不把元素弹出，pop会弹出元素
            if ((pcur.lchild == null && pcur.rchild == null) ||
                    ((pre != null) && (pcur.lchild == pre || pcur.rchild == pre))) {
                System.out.println(pcur.data);
                stack.pop();
                pre = pcur;
            } else {
                if (pcur.rchild != null)
                    stack.push(pcur.rchild);
                if (pcur.lchild != null)
                    stack.push(pcur.lchild);
            }
        }
    }

    /**
     * 层序遍历
     */

    public void queuePrint(treeNode root) {//层序遍历
        if (root == null)
            return;
        treeNode node = root;
        Queue<treeNode> queue = new LinkedList<treeNode>();
        queue.add(node);
        while (!queue.isEmpty()) {
            node = queue.poll();
            System.out.println(node.data);
            if (node.lchild != null)
                queue.add(node.lchild);
            if (node.rchild != null)
                queue.add(node.rchild);
        }
    }
}