结点类:
public class BinaryTreeNode {
private int data;
private BinaryTreeNode left;
private BinaryTreeNode right;
public BinaryTreeNode() {
}
}
二叉树的插入:
// 插入节点
public void insert(int key, int value) {
// 没有根结点,直接新建
if (root == null) {
root = new BinaryNode(key, value);
}
BinaryNode currentNode = root;
BinaryNode parentNode = root;
boolean isLeftChild = true;
while (currentNode != null) { // 找到右子树或左子树为空 的结点 ,准备插入
parentNode = currentNode;// 每次都保存下当前的父结点
if (key < currentNode.key) { // 比父结点小
currentNode = currentNode.left; // 右结点设为当前结点
isLeftChild = true;// 确定是右子树
} else {// 比父结点大
currentNode = currentNode.right; // 左子树设为当前结点
isLeftChild = false;
}
}
BinaryNode newNode = new BinaryNode(key, value); // 找到位置后插入。
if (isLeftChild) {
parentNode.left = newNode;
} else {
parentNode.right = newNode;
}
}
二叉树的遍历:
public class BinaryTree {
// 前序遍历递归的方式
public void preOrder(BinaryTreeNode root) {
if (root != null) {
System.out.println(root.getData() + " ");
preOrder(root.getLeft());
preOrder(root.getRight());
}
}
// 前序遍历非递归的方式1
public void preOrderNoRecursive(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<>();
stack.push(root);// 进栈
while (!stack.isEmpty()) {
BinaryTreeNode newtree = stack.pop();
System.out.println(newtree.getData() + " ");
if (newtree.getRight() != null) {
stack.push(newtree.getRight());// 进栈
}
if (newtree.getLeft() != null) {
stack.push(newtree.getLeft());
}
}
}
// 前序遍历非递归的方式2
public void preOrderNoRecursive2(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<>();
while (root != null || !stack.isEmpty()) { // 左孩子压栈
if (root != null) {
stack.push(root);
System.out.println(root.getData() + " ");
root = root.getLeft();
} else {
root = stack.pop();
root = root.getRight();
}
}
}
// 中序遍历递归的方式
public void inOrder(BinaryTreeNode root) {
if (root != null) {
inOrder(root.getLeft());
System.out.println(root.getData() + " ");
inOrder(root.getRight());
}
}
// 中序遍历非递归
public void inOrderNoRecursive(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<>();
while (!stack.isEmpty() || root != null) {
if (root != null) {
stack.push(root);
root = root.getLeft(); // 先把左子树全部压入栈中
} else {
root = stack.pop(); // 出栈并访问
System.out.println(root.getData() + " ");
root = root.getRight();
}
}
}
// 后序遍历递归的方式
public void portOrder(BinaryTreeNode root) {
if (root != null) {
portOrder(root.getLeft());
portOrder(root.getRight());
System.out.println(root.getData());
}
}
// 后序遍历非递归--双栈法
public void portOrderNoRecursive(BinaryTreeNode root) {
Stack<BinaryTreeNode> stack = new Stack<>();
Stack<BinaryTreeNode> output = new Stack<>();// 构造一个中间栈来存储逆后序遍历的结果
while (root != null || !stack.isEmpty()) {
if (root != null) {
output.push(root);
stack.push(root);
root = root.getRight();
} else {
root = stack.pop();
root = root.getLeft();
}
}
System.out.println(output.size());
while(output.size()>0) {
System.out.println(output.pop()+" ");
}
}
// 层序遍历的方式
public void levelOrder(BinaryTreeNode root) {
BinaryTreeNode temp;
// 先进先出
Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
queue.offer(root);// 入队
while (!queue.isEmpty()) {
temp = queue.poll();// 队头出队
System.out.println(temp.getData() + " ");
if (temp.getLeft() != null) {
queue.offer(temp.getLeft());// 左入队
}
if (temp.getRight() != null) {
queue.offer(temp.getRight());// 右入队
}
}
}