二叉树在Java中有两种方法可以实现，用数组实现和用链表实现，本篇主要讲这两个方法：
一、数组实现二叉树，缺点是浪费空间，代码如下：
package offer.tree;
/**
* Created by Taoyongpan on 2017/10/15.
* 二叉树的创建和一般操作
* 数组实现二叉树，浪费很多的内存空间
* 左孩子下标 = 父节点下标*2
* 右孩子下标 = 父节点下标*2+1
*/
public class TreeDemo {
// int root = 1;
int btree[];
private int root = 1;
private int leftchild;
private int rightchild;
public TreeDemo(int data){
btree = new int[16];
btree[1] = data;
}
//新增
public void add(int data){
int root =1;
while (btree[root]!=0){
if (btree[root]>=data){
root = root*2;
}else {
root = root*2+1;
}
}
btree[root] = data;
}
//遍历
public void display(){
for (int i = 1 ; i<btree.length;i++){
System.out.println("btree["+i+"]="+btree[i]);
}
}
//删除
public void del(int data){
int root = 1;
while (btree[root]!=data){
if (btree[root]>data){
root = root*2;
}else if (btree[root]<data){
root = root*2+1;
}
}
btree[root] = 0;
}
//查找
public int query(int data){
int root = 1;
while (btree[root]!=data){
if (btree[root]>data){
root = root*2;
}else if (btree[root]<data){
root = root*2+1;
}
}
return root;
}
public static void main(String[] args){
TreeDemo tree = new TreeDemo(10);
tree.add(8);
tree.add(7);
tree.add(11);
tree.add(3);
tree.add(20);
tree.display();
tree.del(3);
tree.display();
}
}
二、用链表实现，代码如下：
package offer.tree;
/**
* Created by Taoyongpan on 2017/10/15.
* 链表实现二叉树
*/
public class TreeNode {
int data;
TreeNode leftchild;
TreeNode rightchild;
//初始化
public TreeNode(){
data = 0;
leftchild = null;
rightchild =null;
}
//新增节点
public TreeNode(int data){
this.data = data;
leftchild = null;
rightchild =null;
}
}
package offer.tree;
import java.util.*;
/**
* Created by Taoyongpan on 2017/10/15.
* 前序遍历 ：根节点，左节点，右节点
* 中序遍历：左节点，根节点，右节点
* 后序遍历：左节点，右节点，根节点
*/
public class TreeLink {
TreeNode root = null;
//创建根节点
public TreeLink(int data){
root = new TreeNode(data);
}
//创建节点
public void add(int data){
TreeNode d = new TreeNode(data);
TreeNode p = root;
while (p!=null){
if (p.data>=d.data){
//往左走
if (p.leftchild!=null){
p = p.leftchild;
}else {
p.leftchild=d;
break;
}
}else {
//往右走
if (p.rightchild!=null){
p = p.rightchild;
}else {
p.rightchild = d;
break;
}
}
}
}
//前序遍历
public void display(TreeNode root){
TreeNode p = root;
System.out.println("p.data="+p.data);
if (p.leftchild!=null){
display(p.leftchild);
}
if (p.rightchild!=null){
display(p.rightchild);
}
}
//递归版前序遍历
public static List<Integer> preorderRecursively(TreeNode root){
List<Integer> tree = new ArrayList<>();
if (root==null){
return tree;
}
tree.add(root.data);
tree.addAll(preorderRecursively(root.leftchild));
tree.addAll(preorderRecursively(root.rightchild));
return tree;
}
//递归版中序遍历
public static List<Integer> inorderRecursively(TreeNode root){
List<Integer> tree = new ArrayList<>();
if (root==null){
return tree;
}
tree.addAll(inorderRecursively(root.leftchild));
tree.add(root.data);
tree.addAll(inorderRecursively(root.rightchild));
return tree;
}
//递归版后序遍历
public static List<Integer> postorderRecursively(TreeNode root){
List<Integer> tree = new ArrayList<>();
if (root==null){
return tree;
}
tree.addAll(postorderRecursively(root.leftchild));
tree.addAll(postorderRecursively(root.rightchild));
tree.add(root.data);
return tree;
}
//非递归版本前序遍历
public static List<Integer> preorderIteratively(TreeNode root){
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
TreeNode p = root;
if (root == null){
return list;
}
while (p!=null||!stack.isEmpty()){
if (p!=null){
list.add(p.data);
stack.push(p);
p = p.leftchild;
}else {
p = stack.pop().rightchild;
}
}
return list;
}
//非递归版本中序遍历
public static List<Integer> inorderIteratively(TreeNode root){
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
TreeNode p = root;
while (p!=null||!stack.isEmpty()){
if (p!=null){
stack.push(p);
p = p.leftchild;
}else {
list.add(stack.peek().data);
p = stack.pop().rightchild;
}
}
return list;
}
//非递归版后序遍历
public static List<Integer> postorderIteratively(TreeNode root){
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
TreeNode p = root;
TreeNode d = null;
while (p!=null||!stack.isEmpty()){
if (p!=null){
stack.push(p);
p = p.leftchild;
}else {
p = stack.peek().rightchild;
if (p!=null&&d!=p){
stack.push(p);
p = p.leftchild;
}else {
d = stack.pop();
list.add(d.data);
p = null;
}
}
}
return list;
}
//层序遍历
public static List<Integer> levelorder(TreeNode root){
Queue<TreeNode> queue = new LinkedList<>();
TreeNode p = null;
List<Integer> list = new LinkedList<>();
if (root==null){
return null;
}
queue.offer(root);
while (!queue.isEmpty()){
p = queue.poll();
list.add(p.data);
if (p.leftchild!=null){
queue.offer(p.leftchild);
}
if (p.rightchild!=null){
queue.offer(p.rightchild);
}
}
return list;
}
//主函数
public static void main(String[] args){
TreeLink tree = new TreeLink(10);
tree.add(8);
tree.add(11);
tree.add(20);
tree.add(7);
tree.add(3);
//递归版前序遍历
tree.display(tree.root);
//递归版前序遍历
System.out.println("递归版本前序遍历：");
List<Integer> list = preorderRecursively(tree.root);
for (int i = 0 ; i<list.size();i++){
System.out.println(list.get(i));
}
//递归版中序遍历
System.out.println("递归版本中序遍历：");
List<Integer> list1 = inorderRecursively(tree.root);
for (int i = 0 ; i<list1.size();i++){
System.out.println(list1.get(i));
}
//递归版后序遍历
System.out.println("递归版本后序遍历：");
List<Integer> list2 = postorderRecursively(tree.root);
for (int i = 0 ; i<list2.size();i++){
System.out.println(list2.get(i));
}
//非递归版本前序遍历
System.out.println("非递归版本前序遍历：");
List<Integer> list3 = preorderIteratively(tree.root);
for (int i = 0 ; i<list3.size();i++){
System.out.println(list3.get(i));
}
//非递归版本中序遍历
System.out.println("非递归版本中序遍历：");
List<Integer> list4 = inorderIteratively(tree.root);
for (int i = 0 ; i<list4.size();i++){
System.out.println(list4.get(i));
}
//非递归版本后序遍历
System.out.println("非递归版本后序遍历：");
List<Integer> list5 = postorderIteratively(tree.root);
for (int i = 0 ; i<list5.size();i++){
System.out.println(list5.get(i));
}
//层序遍历
System.out.println("非递归版本后序遍历：");
List<Integer> list6 = levelorder(tree.root);
for (int i = 0 ; i<list6.size();i++){
System.out.println(list6.get(i));
}
}
}