昨晚中兴笔试题，第一题是给定二叉树，每个节点的数据结构是 value,left,right，比较根节点到各个叶子节点路径和的大小，输出路径和的最小值。(补充：用ArrayList可以存储)

以前没做过关于树的题，所以没想到如何处理各个节点的左右子节点，即不会遍历二叉树，在这里做一个总结

1.递归实现遍历

//递归实现遍历，各种不同的遍历实际上是输出的位置不同，但是都是递归

//先序遍历，传入 t = root1

public void preOrder(Node t){

if(t == null)

return;

System.out.println(t.getValue());

pre(t.getLeft());

pre(t.getRight());

}

//中序遍历，传入 t = root1

public void inOder(Node t){

if(t == null)

return;

inOrder(t.getLeft());

System.out.println(t.getValue());

inOrder(t.getRight());

}

//后序遍历，传入 t = root1

public void postOder(Node t){

if(t == null)

return;

postOrder(t.getLeft());

postOrder(t.getRight());

System.out.println(t.getValue());

2.非递归实现遍历

非递归实现遍历，用到栈来存储路径，输出路径

//先序遍历1，传入t =root1

public void iteratorPre(Node t){

Stack stack = new Stack();

stack.push(t);

//每次取出节点的顺序总是根，左，右

while(!stack.Empty()){

t = stack.pop();

System.out.println(t.getValue());

//先压入右节点，再压入左节点，因为栈是先进后出的

if(t.getRight() != null)

stack.push(t.getRight());

if(t.getLeft() != null)

stack.push(t.getLeft());

}

}

//先序遍历2

protected static void iterativePreorder2(Node p) {

Stack stack = new Stack();

Node node = p;

while (node != null || stack.size() > 0) {

while (node != null) {//压入所有的左节点，压入前访问它

visit(node);

stack.push(node);

node = node.getLeft();

}

if (stack.size() > 0) {//

node = stack.pop();

node = node.getRight();

}

}

}

//中序遍历，传入 t = root1

protected static void iterativeInorder(Node p) {

Stack stack = new Stack();

Node node = p;

while (node != null || stack.size() > 0) {

//压入根节点和左节点

while (node != null) {

stack.push(node);

node = node.getLeft();

}

if (stack.size() > 0) {

node = stack.pop();

visit(node);

node = node.getRight();

}

}

}

//后序遍历，单栈

protected static void iterativePostorder3(Node p) {

Stack stack = new Stack();

Node node = p, prev = p;

while (node != null || stack.size() > 0) {

while (node != null) {

stack.push(node);

node = node.getLeft();

}

if (stack.size() > 0) {

Node temp = stack.peek().getRight();

if (temp == null || temp == prev) {

node = stack.pop();

visit(node);

prev = node;

node = null;

} else {

node = temp;

}

}

}

}

3.计算所有路径中的最小值

import java.util.;

public class Main{

/来源：

* 中兴机试题：计算二叉树根节点到叶子节点的最短路径

* 注意：为了记录路径，用栈，找到叶子节点后计算，然后pop()出去，再找下一个

* */

static List list = new ArrayList();

public static void main(String[] args){

Node root1 = new Node();

Node node1 = new Node();

Node node2 = new Node();

Node node3 = new Node();

Node node4 = new Node();

Node node5 = new Node();

Node node6 = new Node();

root1.setLeft(node1);

root1.setRight(node2);

node1.setLeft(node3);

node1.setRight(node4);

node4.setLeft(node5);

node4.setRight(node6);

root1.setValue(8);

node1.setValue(8);

node2.setValue(7);

node3.setValue(9);

node4.setValue(2);

node5.setValue(4);

node6.setValue(7);

//先序遍历

//pre(root1);

//用栈记录路径

Stack n = new Stack();

findMin(root1,n);

//list中是各条路径的和

for(int i = 0;i < list.size();i++){

System.out.println(list.get(i));

}

}

//递归实现，每当发现叶子节点，就计算一次

public static void findMin(Node t,Stack n){

if(t == null)

return;

n.push(t);

//t是叶子节点,此时计算路径和

if(t.getLeft() == null && t.getRight() == null){

int sum =0;

//clone()方法，避免修改原来的栈

Stack s1= (Stack)n.clone();

for(int j =0;j < n.size();j++){

sum += s1.pop().getValue();

}

list.add(sum);

//去除叶子节点

n.pop();

}else{

//递归寻找

findMin(t.getLeft(),n);

findMin(t.getRight(),n);

//经过该节点的路径已找完，删除该节点

n.pop();

}

}

public static void pre(Node t){

if(t == null)

return;

System.out.println(t.getValue());

pre(t.getLeft());

pre(t.getRight());

}

}

//节点结构

class Node{

private int value;

public int getValue() {

return value;

}

public void setValue(int value) {

this.value = value;

}

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;

}

private Node left;

private Node right;

}