LinkedList-二叉树遍历

来源：互联网发布：php函数大全编辑：程序博客网时间：2024/05/21 19:44

LinkedList-二叉树遍历

标签： linkedlist二叉树

2015-04-05 00:00 821人阅读评论(1)收藏举报

分类：

漫步源码（2）

作者同类文章X

目录(?)[+]

数据结构
做个本分的List
Queue创建和遍历二叉树
Stack先序中序后序非递归遍历二叉树
LinkedList vs ArrayList
总结

LinkedList，从字面上明显可以看出它是一个基于链表的list。通常来说，我们也只把它当做一个ArrayList的替代品，因为它具备插入删除快，对存储要求低等优点。但是看过源码之后，你会发现它着实是个多面手。
LinkedList类定义:

public class LinkedList<E> extends AbstractSequentialList<E>    implements List<E>, Deque<E>, Cloneable, java.io.Serializable1
2

从类定义可以看出，LinkedList其实不止实现了List接口，Cloneable, Serializable这两个常规接口，此外还实现了Deque接口。正是如此，它不仅仅是个列表(List)，同时还是个双向队列(Deque)，栈(Stack)。接下来，本文将简单介绍LinkedList的基础数据结构，并通过实践叙述它的三大功能。

数据结构

现在，从基础数据结构说起。LinkedList由一个个Node组成，每个Node包括一个数据元素和两个分别纸箱前后结点的指针。Node的数据结构定义为：

    private static class Node<E> {        E item; //存储结点数据，允许为空        Node<E> next;        Node<E> prev;        Node(Node<E> prev, E element, Node<E> next) {            this.item = element;            this.next = next;            this.prev = prev;        }    }1
2
3
4
5
6
7
8
9
10

一个链表结构为：
基础结构
当删除第三个结点，链表结构变为：
删除结点
在Node4和Node5之间插入一个结点，链表结构变为：
新增结点

做个本分的List

作为一个list，它实现了基类List的所有方法，诸如add,remove,contains,get,set,size等。接下来我们简单实践几个简单的方法。

public class LinkedListGo {    public static void main(String[] args) {        List<String> list = new LinkedList<String>(Arrays.asList(new String[]{"HashMap", "TreeMap", "LinkedHashMap"}));        //使用addAll批量添加        list.addAll(Arrays.asList(new String[]{"ArrayList", "LinkedList", "Vector"}));        list.add("ConcurrentLinkedDeque");        list.add("Collections");        //使用size()方法获取list中元素个数        System.out.println("Size of this list is : " + list.size() + "\n");        //使用get(),set()方法获取和设置list中元素的值        System.out.println("The sixth element of the list is : " + list.get(6));        list.set(6, "ConcurrentHashMap");        System.out.println("After setting, the sixth element of the list is : " + list.get(6) + "\n");        //使用contains()判断列表是否包号某个元素,remove()删除元素        System.out.println("This lis contains \"Collections\": " + list.contains("Collections"));        list.remove("Collections");        System.out.println("After removing \"Collection\", this lis contains \"Collections\": " + list.contains("Collections") + "\n");        //使用toArray转化为数组，使用removeAll批量删除        String[] strs = list.toArray(new String[]{});        list.removeAll(new LinkedList<String>(Arrays.asList(strs)));        System.out.println("After removing all, currently, the list is empty: " + list.isEmpty());    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

关于LinkedList的几点说明
1. 以上代码中为LinkedList赋值时，语句中之所以要使用new LinkedList(...),看似多次一举，实则是处于安全考虑，集体请参考Java程序员常犯的十个错误；
2. 不同于ArrayList，但凡是涉及到元素index的操作，LinkedList不是直接根据index对元素进行操作，而是先遍历找到index对应元素，然后进行操作；

Queue:创建和遍历二叉树

现在我们要构建一棵二叉树，如下图所示：

首先定义二叉树结点：

public class TreeNode<E> {    public E data; //数据结点    public TreeNode<E> left; //指向左子树    public TreeNode<E> right; //指向右子树    public TreeNode() {    }    public TreeNode(E data, TreeNode<E> left, TreeNode<E> right) {        this.data = data;        this.left = left;        this.right = right;    }}1
2
3
4
5
6
7
8
9
10
11
12

然后定义一棵二叉树，代码如下：

public class BinaryTree<E> {    private TreeNode<E> root; //定义树根节点    public BinaryTree() {    }    public BinaryTree(TreeNode<E> root) {        super();        this.root = root;    }    public BinaryTree(E[] elements) {        super();        buildTree(elements); //构建二叉树，方法见下文    }    ...//二叉树相关方法}1
2
3
4
5
6
7
8
9
10
11
12
13
14

接下来我们通过队列构建二叉树，构建方法的参数为结点元素数组，代码如下：

public void buildTree(E[] elements) {    if (elements == null || elements.length == 0)        return;    //二叉树结点队列    Deque<TreeNode<E>> queue = new LinkedList<TreeNode<E>>();    TreeNode<E> node = new TreeNode<E>();    this.root = node;    for (E element : elements) {        node.data = element;        node.left = new TreeNode<E>();        node.right = new TreeNode<E>();        //将左右两个新创建结点加入队列        queue.offer(node.left);        queue.offer(node.right);        //创建完一个结点之后，从队列中取出一个结点接续操作        node = queue.poll();    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

接下来，我们同样可以使用队列实现对这棵二叉树的广度优先遍历，实现方法简单思路如下：

从根结点开始，将结点入队；
如果队列不为空，则从队列中取出一个结点，然后将此结点的左子树和右子树（如果存在）入队；
循环第2步，直到队列为空，整棵树的广度优先遍历结束。

代码如下：

public void breadthFirstTraverse() {    Deque<TreeNode<E>> queue = new LinkedList<TreeNode<E>>();     TreeNode<E> node = this.root;    queue.offer(node);    while (!queue.isEmpty()) {        node = queue.poll();        if (node.data != null) {                            System.out.print(node.data + "\t");        }        if(node.left != null) {            queue.offer(node.left);        }        if(node.right != null) {            queue.offer(node.right);        }    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

实验代码：

public static void main(String[] args) {        BinaryTree<String> tree = new BinaryTree<String>(new String[] { "1",                "2", "3", "4", "5", "6", "7", "8",                "9", "10" });        System.out.println("\n======Breadth-First Traverse======");        tree.breadthFirstTraverse();1
2
3
4
5
6

运行结果：
广度优先遍历

Stack:先序，中序，后序非递归遍历二叉树

二叉树的先序，中序和后续遍历是二叉树的最基本操作。因为二叉树和它的二叉子树具有结构相同的特征，因此，最通用的方法就是递归遍历。换个角度来看，三种遍历方法都可视为深度(DFS)优先遍历。既是深度优先遍历，那么我们首先联想到的便是使用栈实现。接下来我们将通过非递归遍历二叉树来实践LinkedList作为栈的功能。
非递归先序遍历

public void preOrderTraverse() {    if (root == null) {        return;    }    //使用LinkedList作为二叉树遍历的栈    Deque<TreeNode<E>> stack = new LinkedList<TreeNode<E>>();    TreeNode<E> node = root;    stack.push(node);    while (!stack.isEmpty()) {        node = stack.pop();//pop弹出栈最上方结点        if (node.data != null) {            System.out.print(node.data + "\t");        }        if (node.right != null) {            stack.push(node.right);//将右结点压栈        }        if (node.left != null) {            stack.push(node.left);//将左结点压栈        }    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

先序遍历较为简单，对于每个遍历到的结点，首先将其右结点压栈，再将其左结点压栈。然后每次从栈顶pop出一个结点，循环往复操作，直到栈中没有结点为止。
非递归中序遍历

public void inOrderTraverse() {    if (root == null) {        return;    }    //声明遍历使用的栈；    Deque<TreeNode<E>> stack = new LinkedList<TreeNode<E>>();    TreeNode<E> node = this.root;    while (node != null || !stack.isEmpty()) {                  if (node != null) {            stack.push(node);            node = node.left;        }        else if (!stack.isEmpty()) {            node = stack.pop();            if (node.data != null) {                                    System.out.print(node.data + "\t");            }            node = node.right;        }    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

中序遍历稍微有点绕脑筋，大家可以自行根据以上代码，画画入栈出栈图。
非递归后续遍历

public void postOrderTraverse() {    //遍历栈，用于遍历二叉树    Deque<TreeNode<E>> stack = new LinkedList<TreeNode<E>>();    //输出栈，将遍历结果存入此栈，最后一次性出栈输出    Deque<TreeNode<E>> output = new LinkedList<TreeNode<E>>();    TreeNode<E> node = this.root;    stack.push(node);    while (!stack.isEmpty()) {        node = stack.pop();        output.push(node);        if (node.left != null) {            stack.push(node.left);        }        if (node.right != null) {            stack.push(node.right);        }    }    while (!output.isEmpty()) {        TreeNode<E> out = output.pop();        if (out.data != null) {                         System.out.print(out.data + "\t");        }    }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

此处后续遍历的实现较为巧妙，我们用了两个栈进行遍历，第一个栈是个临时栈，遍历所有的结点；每当从临时栈中取出结点，将此结点压入输出栈，当遍历结束之后，一次性全部pop出输出栈中结点，即为后续遍历。
遍历结果如下：
先序中序后续遍历

LinkedListvs ArrayList

此处，我们将LinkedList和ArrayList进行比较，总结出它的优缺点。

优点缺点基于链表，一种动态数据结构，可以运行时进行动态扩展和收缩随机访问相较于ArrayList更慢插入和删除操作更简单，无需移动元素Java8中，没有添加诸如ArrayList中的新方法具备更高效的内存利用率，无需预分配内存（即需要多少，占用多少）更好地实现栈和队列功能，功能更丰富

总结

本文首先简单介绍了LinkedList的基本数据结构，然后通过举例说明了LinkedList作为列表，队列和栈的基本功能；最后和ArrayList进行比较，点明它的优缺点。

文中代码可点击此处下载：LinkedList实践代码

顶: 0

踩: 0

上一篇从ArrayList说起
下一篇ArrayList & LinkedList & Vector比较