算法(第4版)-1.3.3 链表

Posted Guure

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了算法(第4版)-1.3.3 链表相关的知识,希望对你有一定的参考价值。

总结:本小节讲述了链表的概念,以及用链表实现Stack、Queue和Bag的过程和优缺点。

 

重点:

1. 定义:链表是一种递归的数据结构,它或者为空(null),或者是指向一个结点(node)的引用,该结点含有一个泛性的元素和一个指向另一条链表的引用。

 

2. 我们首先用一个嵌套类来定义结点的抽象数据类型:

private class Node {
    Item item;
    Node next;
}

它们实现的不是抽象数据类型,因为我们会直接使用其实例变量。

 

3. 所需的时间和链表的长度无关的三种操作:

· 在表头插入结点;

· 从表头删除结点;

· 在表尾插入结点。

这是重点,一定要理解!

 

4. 实现任意插入和删除操作的标准解决方案是使用双向链表,其中每个结点都含有两个链接,分别指向不同的方向。

 

5. 栈的实现(原因:3):

当使用push()压入一个元素时,我们会按照1.3.3.3节所讨论的代码将该元素添加在表头;

当使用pop()删除一个元素时,我们会按照1.3.3.4节讨论的代码将该元素从表头删除。

public class Stack<Item> {
    private Node first;    // 栈顶(最近添加的元素)
    private int N;            // 元素数量
    private class Node {
        // 定义了结点的嵌套类
        Item item;
        Node next;
    }
    public boolean isEmpty() {
        return first == null;
    }
    public int size() {
        return N;
    }
    public void push(Item item) {
        // 向栈顶添加元素
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
        N++;
    }
    public Item pop() {
        // 从栈顶删除元素
        Item item = first.item;
        first = first.next;
        N--;
        return item;
    }
}

链表的方向:栈顶 -> 栈底

 

6. 队列的实现(原因:3):

要将一个元素入列(enqueue()),我们就将它添加到表尾(在链表为空时需要将first和last都指向新结点);

要将一个元素出列(dequeue()),我们就删除表头的结点(当链表为空时需要更新last的值)。

public class Queue<Item> {
    private Node first;    // 指向最早添加的结点的链接
    private Node last;    // 指向最近添加的结点的链接
    private int N;            // 队列中的元素数量
    private class Node {
        // 定义了结点的嵌套类
        Item item;
        Node next;
    }
    public boolean isEmpty() {
        return first == null;    // 或: N == 0.
    }
    public int size() {
        return N;
    }
    public void enqueue(Item item) {
        // 向表尾添加元素
        Node oldlast = last;
        last = new Node();
        last.item = item;
        last.next = null;
        if (isEmpty())    first = last;
        else                        oldlast.next = last;
        N++;
    }
    public Item dequeue() {
        // 从表头删除元素
        Item item = first.item;
        first = first.next;
        if (isEmpty())    last = null;
        N--;
        return item;
    }
}

链表的方向:队头 -> 队尾

 

7. 链表的使用达到了我们的最优设计目标:

· 它可以处理任意类型的数据;

· 所需的空间总是和集合的大小成正比;

· 操作所需的时间总是和集合的大小无关。

 

8. 编程语言历史上的一块里程碑就是McCathy在20世纪50年代发明的LISP语言,而链表则是这种语言组织程序和数据的主要结构。

 

9. 背包的实现:

只需要将Stack中的push()改名为add(),并去掉pop()的实现即可。

import java.util.Iterator;

public class Bag<Item> implements Iterable<Item> {
    private Node first;    // 链表的首结点
    private int N;
    private class Node {
        Item item;
        Node next;
    }
    public boolean isEmpty() {
        return first == null;
    }
    public int size() {
        return N;
    }
    public void add(Item item) {
        // 和Stack的push()方法完全相同
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
        N++;
    }
    public Iterator<Item> iterator() {
        return new ListIterator();
    }
    private class ListIterator implements Iterator<Item> {
        private Node current = first;
        public boolean hasNext() {
            return current != null;
        }
        public void remove() {}
        public Item next() {
            Item item = current.item;
            current = current.next;
            return item;
        }
    }
}

*hasNext()方法会检测current是否为null。

以上是关于算法(第4版)-1.3.3 链表的主要内容,如果未能解决你的问题,请参考以下文章

算法(Algorithms)第4版 练习 1.3.31

算法(第4版)-1.3.4 综述

LeetCode链表算法题(java版)

单向链表反转算法——递归版和迭代版

《图灵程序设计丛书 算法》第4版.pdf

3)数据结构和算法学习_链表