结点类:
package hbtx.Btree;
public class Node {
Object value;
Node leftChild;
Node rightChild;
public Node() {
}
public Node(Node node) {
this.value=node.value;
this.leftChild=node.leftChild;
this.rightChild=node.rightChild;
}
public Node(Object value) {
super();
this.value = value;
}
public Node(Object value, Node leftChild, Node rightChild) {
super();
this.value = value;
this.leftChild = leftChild;
this.rightChild = rightChild;
}
@Override
public String toString() {
return "Node [value=" + value + ", leftChild=" + leftChild
+ ", rightChild=" + rightChild + "]";
}
}
实现类:
package hbtx.Btree;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
public class LinkedBinaryTree implements BinaryTree{
private Node root;
public LinkedBinaryTree() {
super();
}
public LinkedBinaryTree(Node root) {
super();
this.root = root;
}
@Override
public boolean isEmpty() {
return root == null;
}
@Override
public int getHeight() {
System.out.println("树的高度:");
return this.getHeight(root);
}
private int getHeight(Node root){
if(root == null){
return 0;
}else{
int nl = this.getHeight(root.leftChild);
int nr = this.getHeight(root.rightChild);
return nl > nr ? nl+1:nr+1;
}
}
//查询
@Override
public Node findKey(Object value) {
System.out.println("根据数据查询结点:");
return this.findKey(value, root);
}
private Node findKey(Object value,Node root) {
if(root == null){
return null;
}else if(root != null && root.value == value){
return root;
}else {
Node node1 = this.findKey(value, root.leftChild);
Node node2 = this.findKey(value, root.rightChild);
if(node1 != null && node1.value == value){
return node1;
}else if(node2 != null && node2.value == value){
return node2;
}else{
return null;
}
}
}
@Override
public void preOrderTraverse() {
System.out.println("先序递归:");
this.preOrderTraverse(root);
System.out.println();
}
private void preOrderTraverse(Node root) {
if(root != null){
System.out.print(root.value+" ");
this.preOrderTraverse(root.leftChild);
this.preOrderTraverse(root.rightChild);
}
}
@Override
public void inOrderTraverse() {
System.out.println("中序递归:");
this.inOrderTraverse(root);
System.out.println();
}
private void inOrderTraverse(Node root) {//node7
if(root != null){
this.inOrderTraverse(root.leftChild);//null
System.out.print(root.value+" ");//7
this.inOrderTraverse(root.rightChild);//null
}
}
@Override
public void postOrderTraverse() {
System.out.println("后序递归:");
this.postOrderTraverse(root);
System.out.println();
}
private void postOrderTraverse(Node node) {
if(node != null){
this.postOrderTraverse(node.leftChild);
this.postOrderTraverse(node.rightChild);
System.out.print(node.value+" ");
}
}
@Override
public void preOrderByStack() {
System.out.println("先序栈:");
Deque<Node> stack=new LinkedList<>();
Node current=new Node();
stack.push(root);
while(!stack.isEmpty()) {
current =stack.pop();
System.out.print(current.value+" ");
if(current.rightChild!=null)
stack.push(current.rightChild);
if(current.leftChild!=null)
stack.push(current.leftChild);
}
//方法二
// Deque<Node> stack=new LinkedList<>();
// Node current=new Node(root);
// while(current!=null||!stack.isEmpty()) {
// while(current!=null) {
// stack.push(current);
// System.out.print(current.value+" ");
// current=current.leftChild;
// }
// if(!stack.isEmpty()) {
// current=stack.pop();
// current=current.rightChild;
// }
// }
}
@Override
public void inOrderByStack() {
System.out.println("中序栈:");
Deque<Node> stack = new LinkedList<Node>();
Node current = root;
while (current != null || !stack.isEmpty()) {
while (current != null) {
stack.push(current);
current = current.leftChild;
}
if (!stack.isEmpty()) {
current = stack.pop();
System.out.print(current.value + " ");
current = current.rightChild;
}
}
System.out.println();
}
@Override
public void postOrderByStack() {
System.out.println("后序栈:");
// //方法一比较复杂不推荐
// Node current, pre = null;
// Deque<Node> stack = new LinkedList<>();
// stack.push(root);
// while (!stack.isEmpty()) {
// current = stack.peek();
// if ((current.leftChild == null && current.rightChild == null) ||
// (pre != null && (pre == current.leftChild || pre == current.rightChild))) {
// System.out.print(current.value + " ");
// stack.pop();
// pre = current;
// } else {
// if (current.rightChild != null)
// stack.push(current.rightChild);
// if (current.leftChild != null)
// stack.push(current.leftChild);
// }
// }
//方法二借助两个栈
Deque<Node> stack1 = new LinkedList<>();
Deque<Node> stack2 = new LinkedList<>();
Node node= new Node();
stack1.push(root);
while(!stack1.isEmpty()){
node=stack1.pop();
stack2.push(node);
if(node.leftChild!=null)
stack1.push(node.leftChild);
if(node.rightChild!=null)
stack1.push(node.rightChild);
}
while(!stack2.isEmpty()) {
System.out.print(stack2.pop().value+" ");
}
System.out.println();
}
@Override
public void levelOrderByStack() {
if(root==null)
return;
Queue<Node> queue=new LinkedList<>();
queue.offer(root);
Node node=new Node();;
while(queue.size()!=0) {
node=queue.poll();
System.out.print(node.value+" ");
if(node.leftChild!= null)
queue.offer(node.leftChild);
if(node.rightChild!= null)
queue.offer(node.rightChild);
}
}
@Override
public int size() {
System.out.println("树的元素的个数:");
return this.size(root);
}
private int size(Node root) {
if(root==null) {
return 0;
}
int nl=this.size(root.leftChild);
int nr=this.size(root.rightChild);
return nl+nr+1;
}
}
总结,二叉树是练习递归算法很好模块