链表

链表分单向链表，双向链表
下面我看一下双向链表(最常用如图：
(图一)

双向链表

查询

查询程序LIST_SEARCH(L,k)找数据为k的元素在L里面，通过一个简单线性查找，返回一个指向这个元素的指针。如果k没有出现在出现在这个列表，则这个程序就会返回空(NIL)。

LIST_SEARCH(L, k)

x = L.headwhile x != NIL and x.key != k    x = x.nextreturn x

插入

给定一个元素属性已经设置好了的，然后将其插入链表的头部,如图一中的(b)与(a)相比
LIST_INSERT(L, x)

x.next = L.headif L.head != NIL    L.head.prev = xL.head = xx.prev = NIL

删除

从链表L中删除一个元素x.但是必须提供一个指向x的指针,可通过LIST_SEARCH(L, x)返回.
LIST_DELETE(L, x)

if x.prev != NIL    x.prev.next = x.nextelse L.head = x.nextif x.next != NIL    x.next.prev = x.prev

双向循环链表

下图是带哨兵的双向循环链表，哨兵的next就是链表头，哨兵的prev就是链表的尾.

查询

LIST_SEARCH(L, k)

x = L.nil.nextwhile x != L.nil and x.key != k    x = x.nextreturn x

上面这种写法还可以优化可以去掉每次对 x != NIL 的判断，但是我不知道如何去掉，这是算法导论的练习题.

插入

LIST_INSERT(L, k)

x.next = L.nil.nextL.nil.next.prev = xL.nil.next = xx.prev = L.nil

删除

带哨兵的双向循环链表可以降低常数因子，只是简洁了代码，如果短的链表很多的情况下哨兵是会浪费内存。
LIST_DELETE(L, x)

x.prev.next = x.nextx.next.prev = x.prev

因为单链表删除操作的话，定位花费时间为O(n)所以一般都会使用双向链表.

应用

用单链表实现stack，而且push和pop只花O(1)时间

PUSH(L, x)

x.next = L.headL.head = x

POP(L)

if L.head == NIL    error "underflow"x = L.headL.head = L.head.nextreturn x

用单链表实现queue,ENQUEUE和DEQUEUE都只花O(1)时间

队列图：

ENQUEUE(L, x)

L.tail.next = xL.tail = x

DEQUEUE(L)

if L.head == NIL    error "underflow"x = L.headL.head = L.head.nextreturn x

使用单向循环链表实现字典操作INSERT, DELETE 和 SEARCH，并给出所写过程的运行时间

DICT_INSERT(L, x)

x.next = L.nil.nextL.nil.next = x

T(N) = O(1)

DICT_DELETE(L, x)

p = L.nilwhile p.next != L.nil and p.next != x    p = p.nextif p.next != L.nil      p.next = x.next

T(N) = O(N)

DICT_SEARCH(L, x)

x = L.nil.nextwhile x != L.nil and x.key != k    x = x.nextreturn x

T(N) = O(N)