java树结构_Java 实现树结构

树是一种非常重要的数据结构，其中二叉树是最常用到的，之前学的时候用的都是c++，很长时间没有用了也忘得差不多了，最近一直都在用Java，所以总结一下怎样用java来实现二叉树的数据结构，用二叉树来存一个数组。

二叉树得特点有以下几个：1. 每个节点最多有两棵子树。2. 左子树和右子树是有顺序的，次序不能任意颠倒。3. 即使树中只有一课子树，也要区分他是左子树还是右子树；

二叉树的遍历：是指从根结点出发，按照某种次序，依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次；二叉树的遍历方式有好多种，如果我们限制了从左到右的习惯方式，那么主要就有以下几种：前序遍历，中序遍历，后序遍历和层序遍历。

二叉树的实现：二叉树也可以通过顺序存储和链式存储来实现；

二叉树的顺序存储就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系，比如父结点与子结点的逻辑关系，子结点与子结点之间的关系；但顺序存储的实用性不强；所以一般采用链式存储；

在Java中，采用类来声明树的节点 如下所示

public class Node

{

private char

key;  //

数据

private Node

left, right;  //

左右子结点

public

Node(char key)

{

this(key, null, null);

}

public

Node(char key, Node left, Node right)

{

this.key = key;

this.left = left;

this.right = right;

}

public char

getKey()

{

return key;

}

public void

setKey(char key)

{

this.key = key;

}

public Node

getLeft()

{

return left;

}

public void

setLeft(Node left)

{

this.left = left;

}

public Node

getRight()

{

return right;

}

public void

setRight(Node right)

{

this.right = right;

}

}

接下来就是创建一个二叉树，以及对二叉树进行前序遍历，中序遍历，后序遍历和层序遍历。

public class Tree

{

protected

Node root;

public

Tree(Node root)

{

this.root = root;

}

public Node

getRoot()

{

return root;

}

//

初始化，构造二叉树

public

static Node init()

{

Node a = new Node('A');

Node b = new Node('B', null,

a);

Node c = new Node('C');

Node d = new Node('D', b, c);

Node e = new Node('E');

Node f = new Node('F', e,

null);

Node g = new Node('G', null,

f);

Node h = new Node('H', d, g);

return h;  //

根结点

}

//

访问节点

public

static void visit(Node p)

{

System.out.print(p.getKey() +

" ");

}

//

递归实现前序遍历

protected

static void preorder(Node p)

{

if (p != null)

{

visit(p);

preorder(p.getLeft());

preorder(p.getRight());

}

}

//

递归实现中序遍历

protected

static void inorder(Node p)

{

if (p != null)

{

inorder(p.getLeft());

visit(p);

inorder(p.getRight());

}

}

//

递归实现后序遍历

protected

static void postorder(Node p)

{

if (p != null)

{

postorder(p.getLeft());

postorder(p.getRight());

visit(p);

}

}

//

非递归实现前序遍历

protected

static void iterativePreorder(Node p)

{

Stack stack = new Stack();

if (p != null)

{

stack.push(p);

while (!stack.empty())

{

p =

stack.pop();

visit(p);

if

(p.getRight() != null)

stack.push(p.getRight());

if

(p.getLeft() != null)

stack.push(p.getLeft());

}

}

}

//

非递归实现后序遍历

protected

static void iterativePostorder(Node p)

{

Node q = p;

Stack stack = new Stack();

while (p != null)

{

// 左子树入栈

for (; p.getLeft() != null; p = p.getLeft())

stack.push(p);

// 当前结点无右子结点或右子结点已经输出

while (p != null && (p.getRight() ==

null || p.getRight() == q))

{

visit(p);

q = p;

// 记录上一个已输出结点

if

(stack.empty())

return;

p =

stack.pop();

}

// 处理右子结点

stack.push(p);

p = p.getRight();

}

}

//

非递归实现中序遍历

protected

static void iterativeInorder(Node p)

{

Stack stack = new Stack();

while (p != null)

{

while (p != null)

{

if

(p.getRight() != null)

stack.push(p.getRight());

// 当前结点右子结点入栈

stack.push(p);  // 当前结点入栈

p =

p.getLeft();

}

p = stack.pop();

while (!stack.empty() && p.getRight() ==

null)

{

visit(p);

p =

stack.pop();

}

visit(p);

if (!stack.empty())

p =

stack.pop();

else

p = null;

}

}

}