算法导论读书笔记（10）基本数据结构

第三部分 数据结构

第10章 基本数据结构

1. 栈和队列

栈

• 对一个空栈执行弹出操作，则称栈下溢
• 如S.top超过了n，则称栈上溢
  

Stack-Empty(S)
    if S.top == 0
        return true
    else
        return false

未考滤上溢
Push(S, x)
    S.top = S.top + 1
    S.top = x

Pop(S)
    if Stack-Empty(S)
        error "underflow"
    else
        S.top = S.top - 1
        return S[S.top + 1]

队列

• Q.head指向队头元素
• Q.tail指向下一个新元素将要插入的位置
• Q.head = Q.tail时，队列为空
• Q.head = Q.tail = 1，删除队列元素发生下溢
• Q.head = Q.tail + 1，队列满
  

未考滤上下溢

EnQueue(Q, x)
    Q[Q.tail] = x
    if Q.tail == Q.length
        Q.tail = 1
    else
        Q.tail = Q.tail + 1

DeQueue(Q)
    x = Q[Q.tail]
    if Q.head = Q.length
        Q.head = 1
    else
        Q.head = Q.head + 1
    return x

2. 链表

双向链表

• x.next指向它的后继元素，如果x.next = NIL，则x没有后继，即为链表的尾
• x.prev指向它的前驱元素，如果x.prev = NIL，则x没有前驱，即为链表的头
• x.head指向第一个元素，如果x.head = NIL，则链表为空
  

List-Search(L, k)
    x = L.head
    while x != NIL and x.key != k
        x = L.next
    return x

List-Insert(L, x)
    x.next = L.head
    if L.head != NIL
        L.head.prev = x
    L.head = x
    x.prev = NIL

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

哨兵双向循环链表

• 哨兵L.nil位于表头和表尾之间
• L.nil.next指向表头
• L.nil.prev指向表尾
• 表尾的next和表头的prev同时指向L.nil
• 慎用哨兵，哨兵所占用的额外的存储空间会造成严重的存储浪费
  

List-Search'(L, k)
    x = L.nil.next
    while x != L.nil and x.key != k
        x = x.next
    return x

List-Insert'(L, x)
    x.next = L.nil.next
    L.nil.next.prev = x
    L.nil.next = x
    x.prev = L.nil