本文主要讲怎么实现二叉树的相关功能:
树结点类:
public class Node {
Node leftChild;
Object value;
Node rightChild;
public Node(Node leftChild, Object value, Node rightChild) {
super();
this.leftChild = leftChild;
this.value = value;
this.rightChild = rightChild;
}
public Node(Object value) {
super();
this.value = value;
}
@Override
public String toString() {
return "Node [leftChild=" + leftChild + ", value=" + value + ", rightChild=" + rightChild + "]";
}
}
实现代码:
public class LinkedBinaryTree implements BinaryTree{
Node root;//二叉树的根
public LinkedBinaryTree(Node root) {
super();
this.root = root;
}
/**
* 是否为空树
*
*/
@Override
public boolean isEmpty() {
return root == null;
}
/**
* 树的结点数量
*/
@Override
public int size() {
return this.size(root);
}
private int size(Node root){
if(root == null){
return 0;
}else{
int nl = this.size(root.leftChild);
int nr = this.size(root.rightChild);
return nl+nr+1;
}
}
/**
* 获取二叉树的高度
*/
@Override
public int getHeight() {
return getHeight(root);
}
private int getHeight(Node root){
if(root==null){
return 0;
}else{
int nl = getHeight(root.leftChild);
int nr = getHeight(root.rightChild);
return nl>nr?nl+1:nr+1;
}
}
/**
* 查询指定的结点
*/
@Override
public Node findKey(int value) {
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 preOrderTravese() {
System.out.print("先序遍历:");
this.preOrderTravese(root);
System.out.println();
}
private void preOrderTravese(Node root){
if(root != null){
System.out.print(root.value+" ");
this.preOrderTravese(root.leftChild);
this.preOrderTravese(root.rightChild);
}
}
/**
* 中序递归遍历
*/
@Override
public void inOrderTraverse() {
System.out.print("中序遍历:");
this.inOrderTraverse(root);
System.out.println();
}
private void inOrderTraverse(Node root){
if(root != null){
this.inOrderTraverse(root.leftChild);
System.out.print(root.value+" ");
this.inOrderTraverse(root.rightChild);
}
}
/**
* 后续递归遍历
*/
@Override
public void postOrderTraverse() {
System.out.print("后序遍历:");
this.postOrderTraverse(root);
System.out.println();
}
private void postOrderTraverse(Node root){
if(root != null){
this.postOrderTraverse(root.leftChild);
this.postOrderTraverse(root.rightChild);
System.out.print(root.value+" ");
}
}
/**
* 前序非递归遍历
*/
@Override
public void preOrderByStack() {
System.out.print("前序非递归遍历:");
Deque<Node> stack = new LinkedList<Node>();
while(root != null || !stack.isEmpty()){
while(root != null){
System.out.print(root.value+" ");
stack.push(root);
root = root.leftChild;
}
if(!stack.isEmpty()){
root = stack.pop();
root = root.rightChild;
}
}
System.out.println();
}
/**
* 中序非递归遍历
*/
@Override
public void inOrderByStack() {
System.out.print("中序非递归遍历:");
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.print("后序非递归遍历");
Deque<Node> stack1 = new LinkedList<>();
Deque<Integer> stack2 = new LinkedList<>();
Node current = root;
stack1.push(current);
stack2.push(0);
do{
while(current!= null){
current = current.leftChild;
if(current!=null){
stack1.push(current);
stack2.push(0);
}
}
while(!stack1.isEmpty()){
if(stack2.peek()==1){
System.out.print(stack1.pop().value+" ");
stack2.pop();
}else{
stack2.pop();
stack2.push(1);
current = stack1.peek().rightChild;
if(current!=null){
stack1.push(current);
stack2.push(0);
}
break;
}
}
}while(!stack1.isEmpty());
}
/**
* 按照层次遍历二叉树
*/
@Override
public void levelOrderByStack() {
System.out.print("层次遍历");
if(root == null)
return;
Queue<Node> queue = new LinkedList<Node>();
queue.add(root);
while(queue.size()!=0){
int len = queue.size();
for(int i=0;i<len;i++){
Node temp = queue.poll();
System.out.print(temp.value+" ");
if(temp.leftChild != null) queue.add(temp.leftChild);
if(temp.rightChild != null) queue.add(temp.rightChild);
}
}
System.out.println();
}
}