链表

链表

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

双向链表

查询

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

LIST_SEARCH(L, k)

x = L.head
while x != NIL and x.key != k
    x = x.next
return x

插入

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

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

删除

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

if x.prev != NIL
    x.prev.next = x.next
else L.head = x.next
if x.next != NIL
    x.next.prev = x.prev

双向循环链表

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

查询

LIST_SEARCH(L, k)

x = L.nil.next
while x != L.nil and x.key != k
    x = x.next
return x

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

插入

LIST_INSERT(L, k)

x.next = L.nil.next
L.nil.next.prev = x
L.nil.next = x
x.prev = L.nil

删除

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

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

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

应用

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

PUSH(L, x)

x.next = L.head
L.head = x

POP(L)

if L.head == NIL
    error "underflow"
x = L.head
L.head = L.head.next
return x

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

队列图：

ENQUEUE(L, x)

L.tail.next = x
L.tail = x

DEQUEUE(L)

if L.head == NIL
    error "underflow"
x = L.head
L.head = L.head.next
return x

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

DICT_INSERT(L, x)

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

T(N) = O(1)

DICT_DELETE(L, x)

p = L.nil
while p.next != L.nil and p.next != x
    p = p.next
if p.next != L.nil  
    p.next = x.next

T(N) = O(N)

DICT_SEARCH(L, x)

x = L.nil.next
while x != L.nil and x.key != k
    x = x.next
return x

T(N) = O(N)