【算法导论】学习笔记——第10章 基本数据结构

基本数据结构主要包括：栈、队列、链表和有根树。

10.1 栈和队列
栈和队列都是动态集合，且在其上进行DELETE操作所移除的元素时预先设定的。在栈中，被删除的是最近插入的元素：栈实现的是一种后进先出（LIFO）策略。队列实现的是一种先进先出（FIFO）策略。
栈
栈上的INSERT操作称为压入（PUSH），无参数的DELETE操作称为弹出（POP）。栈操作的代码非常简单：

typedef struct {
    int A[MAXN];
    int top;
} Stack_st;

int StackIsEmpty(Stack_st *S) {
    if (S->top == 0)
        return 1;
    return 0;
}

void Push(Stack_st *S, int x) {
    if (S->top+1 < MAXN) {
        S->top = S->top + 1;
        S->A[S->top] = x;
    }
}

int Pop(Stack_st *S) {
    if ( StackIsEmpty(S) ) {
        perror("underflow\n");
        return -1;
    } else {
        --S->top;
        return S->A[S->top+1];
    }
}

三种栈操作的执行时间都是O(1)。
队列
队列上的INSERT操作称为入队（ENQUEUE），DELETE操作称为出队（DEQUEUE）。队列操作的代码也非常简单：

typedef struct {
    int A[MAXN];
    int head, tail;
    int length;
} Queue_st;

int QueueIsEmpty(Queue_st *Q) {
    if (Q->head == Q->tail)
        return 1;
    return 0;
}

int QueueIsFull(Queue_st *Q) {
    if ((Q->tail+1)%Q->length == Q->head)
        return 1;
    return 0;
}

void Enqueue(Queue_st *Q, int x) {
    if (QueueIsFull(Q)) {
        perror("overflow\n");
        return ;
    }
    Q->A[Q->tail] = x;
    if (Q->tail == Q->length)
        Q->tail = 1;
    else
        ++Q->tail;
}

int Dequeue(Queue_st *Q) {
    int x;

    if (QueueIsEmpty(Q)) {
        perror("underflow\n");
        return -1;
    } else {
        x = Q->A[Q->head];
        if (Q->head == Q->length)
            Q->head = 1;
        else
            ++Q->head;
        return x;
    }
}

10.2 链表
链表（linked list）是一种这样的数据结构，其中的各对象按线性顺序排列。与数组不同的是，链表的顺序是由各个对象里的指针决定的。链表主要包括搜索、插入和删除操作。双向链表的操作代码如下。

typedef struct Node {
    int key;
    struct Node *pre, *next;
} Node;

typedef struct {
    Node *head;
} List;

void List_Init(List *L) {
    L->head = NULL;
}

Node *List_Search(List L, int k) {
    Node *p = L.head;
    while (p!=NULL && p->key!=k)
        p = p->next;
    return p;
}

void List_Insert(List *L, Node *x) {
    x->next = L->head;
    if (L->head != NULL)
        L->head->pre = x;
    L->head = x;
    x->pre = NULL;
}

void List_Delete(List *L, Node *x) {
    if (x->pre != NULL)
        x->pre->next = x->next;
    else
        L->head = x->next;
    if (x->next != NULL)
        x->next->pre = x->pre;
    free(x);
}

哨兵(sentinel)是一个哑对象，其作用是简化边界条件的处理。使用哨兵后，相关操作如下所示。

typedef struct Node {
    int key;
    struct Node *pre, *next;
} Node;

typedef struct {
    Node *nil;
} LList;

void LList_Init(LList *L) {
    L->nil = (Node *)malloc(sizeof(Node));
    L->nil->next = L->nil;
    L->nil->pre = L->nil;
}

Node *LList_Search(LList L, int k) {
    Node *p = L.nil->next;
    L.nil->key = k;
    while (p->key!=k)
        p = p->next;
    return p;
}

void LList_Insert(LList *L, Node *x) {
    x->next = L->nil->next;
    L->nil->next->pre = x;
    L->nil->next = x;
    x->pre = L->nil;
}

void LList_Delete(LList *L, Node *x) {
    x->pre->next = x->next;
    x->next->pre = x->pre;
    free(x);
}

哨兵基本不能降低数据结构相关操作的渐近时间界，但可以降低常数因子。这哨兵其实就是《数据结构》里的头结点。

10.2-4 LIST_SEARCH'过程中的每一次循环迭代都需要两个测试，一是检查x!=L.nil，另一个是检查x.key!=k试说明如何在每次迭代中省略对x!=L.nil的检查。
解：x!=L.nil主要是为了防止循环无限查找，为了省略x!=L.nil的检查，即需要在检查到尾结点可退出循环，即尾结点的下一个结点需要满足x.key==k，则进行搜索过程后，将哨兵的key值赋为k即可，代码实现如下：

Node *LList_Search(LList L, int k) {
    Node *p = L.nil->next;
    L.nil->key = k;
    while (p->key!=k)
        p = p->next;
    return p;
}

10.2-6 选用合适的数据结构，支持O(1)时间的UNION操作。
解：双向循环链表（其实带不带哨兵均可，以带哨兵为例）。没什么技巧，就是把头尾结点该链的链好。

void LList_Union(LList *L, LList *L1, LList *L2) {
    L->nil->pre = L2->nil->pre;
    L->nil->next = L1->nil->next;
    L1->nil->pre->next = L2->nil->next;
    L2->nil->next->pre = L1->nil->pre;
    L2->nil->pre->next = L->nil;
    L1->nil->next->pre = L->nil;
}

10.2-7 给出一个theta(n)时间的非递归过程，实现对一个含n个元素的逆转。要求除存储链表本身所需的空间外，该过程只能使用固定大小的存储空间。
解：还是比较简单的，解释改变单链表结点的连接关系。代码如下：

void List_Reverse(List *L) {
    Node *cur = L->head;
    Node *pre = NULL;
    Node *tmp;

    while (cur != NULL) {
        tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }
    L->head = pre;
}

10.2-8 说明如何在每个元素仅使用一个指针x.np(而不是普通的next和prev)的情况下实现双链表。假设所有指针的值都可视为k位的整型数，且定义x.np = x.next XOR x.prev，说明表头所需信息，并说明如何在该表上实现SEARCH、INSERT和DELETE操作，以及如何在O(1)时间内实现该表的逆转。
解：这题难度一般，主要利用异或的性质：A XOR (A XOR B) = B。表头需要两个指针，指向元素头以及元素尾。代码实现如下：

typedef struct Node {
    int key;
    struct Node *np;
} Node;

typedef struct {
    Node *head;
    Node *tail;
} List;

void List_Init(List *L) {
    L->head = L->tail = NULL;
}

void List_Insert(List *L, Node *x) {
    if (L->head != NULL)
        L->head->np = (Node *)((int)L->head->np ^ (int)x);
    x->np = L->head;
    L->head = x;
    if (L->tail == NULL)
        L->tail = x;
}

Node *List_Search(List L, int k) {
    Node *cur = L.head;
    Node *pre = NULL;
    Node *tmp;

    while (cur!=NULL && cur->key!=k) {
        tmp = cur;
        cur = (Node *)((int)pre ^ (int)cur->np);
        pre = tmp;
    }
    return cur;
}

void List_Delete(List *L, Node *x) {
    Node *cur = L->head;
    Node *pre = NULL;
    Node *tmp, *next;

    while (cur != x) {
        tmp = cur;
        cur = (Node *)((int)pre ^ (int)cur->np);
        pre = tmp;
    }
    next = (Node *)((int)pre ^ (int)cur->np);
    pre->np = (Node *)((int)pre->np ^ (int)cur ^ (int)next);
    next->np = (Node *)((int)next->np ^ (int)cur ^ (int)pre);
    free(x);
}

void List_Reverse(List *L) {
    Node *tmp = L->head;
    L->head = L->tail;
    L->tail = tmp;
}

10.3 指针和对象的实现
对象的多数组表示，核心思想就是使用多个数组存储下标索引，使用索引代替指针。对象的单数组表示，就是使用一个数组，key、next、prev的偏移量分别为0，1，2。使用数组实现指针，还需要有自由表（free list）的配合，通过，ALLOCATE-OBJECT()过程分配一个对象，通过FREE-OBJECT(x)过程释放对象。这两个过程的代码如下：

typedef struct {
    int next[MAXN], key[MAXN], pre[MAXN];
    int free;
} AList;

int Allocate_Object(AList *A) {
    int x;
    if (A->free == NULL) {
        perror("out of space");
        return -1;
    } else {
        x = A->free;
        A->free = A->next[x];
        return x;
    }
}

void Free_Object(AList *A, int x) {
    A->next[x] = A->free;
    A->free = x;
}

初始时自由表有全部n个对象，同一个自由表可以被多个链表共用。

10.3-2 对一组同构对象使用单数组表示法实现，写出ALLOCATE-OBJECT过程和FREE-OBJECT过程。
解：代码如下：

typedef struct {
    int A[3*MAXN];
    int free;
} AList;

int Allocate_Object(AList *A) {
    int x;
    if (A->free == NULL) {
        perror("out of space");
        return -1;
    } else {
        x = A->free;
        A->free = A->next[x+1];
        return x;
    }
}

void Free_Object(AList *A, int x) {
    A->next[x+1] = A->free;
    A->free = x;
}

10.3-4 双向链表在多数组表示中保持紧凑，实现ALLOCATE-OBJECT过程和FREE-OBJECT过程。
解：核心思想是，每当执行FREE-OBJECT(x)操作时，则用栈顶的key值替换x处的key值，然后弹栈，并把当前栈顶的next值设为null。每当执行ALLOCATE-OBJECT()操作时，把当前栈顶的next值设置为栈顶+1，然后压栈，返回当前栈顶值。
代码实现如下：

typedef struct {
    int key, next, pre;
} Node;

typedef struct {
    Node A[MAXN];
    int top;
} Stack_st;

int Allocate_Object(Stack_st *S) {
    int x;
    if (S->top == MAXN - 1) {
        perror("out of space");
        return -1;
    } else {
        S->A[S->top].next = S->top + 1;
        ++S->top;
        return S->top;
    }
}

void Free_Object(Stack_st *S, int x) {
    S->A[x].key = S->A[S->top].key;
    --S->top;
    S->A[S->top].next = NULL;
}

10.3-5 L是一个长度为n的双向链表，存储于长度为m的数组key、prev和next中。假设这些数组由维护双链自由表F的两个过程ALLOCATE-OBJECT()和FREE-OBJECT进行管理。又假设m个元素中，恰有n个元素在链表L上，m-n个在自由表上。给定链表L和自由表F，试写出COMPACITY-LIST(L, F)，用来移动L中的元素使其占用数组中1,2...n的位置，调整自由表F以保持其正确性，并占用数组中n+1,n+2...m的位置。要求所写的过程运行时间应为theta(n)，且只使用固定量的额外存储空间。请证明所写的过程是正确的。
解：这道题目其实很简单，但是我理解错题意了，题意是将已经在多数组中的L放置于1~n的位置，将n+1~m的位置空出来。重点是要维护好自由表F，其实也可采用如下的方法实现。
10.3-X 10.3-5开始想错题意，以为要将一个链表L以及已经在多数组中的双向链表F进行合并，其实这个操作的实现也挺麻烦。就留下来吧
解：首先，想到了第一种算法，伪代码如下：

COMPACITY-LIST(L, F)
    p = L.head
    q = F.head
    pre = NULL
    while F.free!=NULL
        x = ALLOCATE-OBJECT()
        if x<=n
            cur = x
        else
            while q>n
                q = F.next[q]
            F.key[x] = F.key[q]
            F.next[x] = F.next[q]
            F.prev[x] = F.prev[q]
            F.prev[F.next[q]] = x
            F.next[F.prev[q]] = x
            cur = q
            q = F.next[q]
        F.key[cur] = p.key
        F.prev[cur] = pre
        if pre != NULL
            F.next[pre] = cur
        pre = cur
    F.next[cur] = NULL

先分析一下核心思想，每次分配一个空间x，如果该索引大于n，显然应该存放自由表中的元素，因此从自由表中不断搜索，直到找到一个q(q>n)，然后将索引q的key、next、prev替换索引x的key、next、prev，注意，同时需要更新q.next.prev以及q.prev.next的值(均指向x)，从而保证F的连同性不被破坏。然后该索引结点即可以使用。因此，每次while循环内都可以找到一个空闲结点存放链表L的数据。
这应该是一个很普通的方法：最坏情况下，内层的while采用均摊分析，共需循环m次，外层循环n次，因此每次均摊m/n次，故T(n)<n*(c2*m/n+c1) f(n) < (c2*m + c1*n)，因为m大于n，因此无法保证O(n)复杂度。显然，这种均摊不符合需要，这也是显然的，因为对m-n数组均摊，则很难保证theta(n)的复杂度。因此，必须想办法对n进行均摊，n可以表示空闲的索引数目以及链表L的结点数目。假定，我们把n个空闲结点分配给链表L后，还剩余x个结点(均大于n)，这些结点应该分配给自由表，因此，我们只要再遍历一次前n个结点能够找到那些属于F的结点既可以保证theta(n)的复杂度。又因为仅可以使用固定量的额外存储空间，因此O(n)的visit标记不适用。
想到这里，解决方法是使用prev属性，对于前n个元素，那x个结点的prev属性均为有效值；因此，每当ALLOCATE-OBJECT分配的可行结点，将它们的prev属性修改为无效值，如-1、m+1等，再次遍历时即可以区分是属于链表L的还是索引结点F的。当然，还需要注意的是，不要修改它们的next属性，因为调用ALLOCATE-OBJECT后，我们仍然可以根据这n个结点的next属性找到原有的free结点，而这次则将大于n的与那些不属于L的进行替换。最后，更新前n个元素的prev属性和next属性。伪代码如下：

COMPACITY-LIST(L, F)
    p = L.head
    q = F.free
    while F.free!=NULL
        x = ALLOCATE-OBJECT()
        if x<=n
            F.key[x] = p.key
            F.prev[x] = -1        // invalid index means belong to L
            p = p.next
    for i=1 to n
        if F.prev[i] != -1
            while q<=n
                q = F.next[q]
            if (F.head == q)
                F.head = i
            F.key[q] = F.key[i]
            F.prev[q] = F.prev[i]
            F.next[q] = F.next[i]
            F.next[F.prev[i]] = q
            F.prev[F.next[i]] = q
            q = F.next[q]
            F.key[i] = p.key
            p = p.next
    for i=1 to n
        F.next[i] = i+1
        F.prev[i] = i-1
    F.next[n] = NULL
    F.prev[1] = NULL

该算法同样采用均摊分析，4~9为theta(n)，因为free结点数目为n；24~26同样为theta(n)；10~23的for循环，即检查前n个结点中属于自由表的结点，并将它们与自由结点中(索引大于n)的进行交换，再将链表L中的数据写回。内层的while至多共计循环n次(可能加上q!=NULL条件更清晰)，外层for循环n次，因此每次均摊1次。同样的时间为theta(n)。因此，该算法整体的复杂度可实现theta(n)。

10.4 有根树的表示
10.4-5 O(n)时间内，非递归输出树的键值，且不能对树做任何修改。
解：这道题目非常有趣，解法是使用标记表示访问的方向已达到回溯。以flg作为标记，flg=1表示从父亲到左儿子方向，flg=2表示从父亲到右儿子方向，flg=-1表示从左儿子返回父节点，flg=-2表示从右儿子返回父节点。同时需要比较当前结点是其父节点的左儿子，还是右二子。伪代码如下：

Print-Key(T)
    cur = T
    flg = 0
    while cur!=NULL
        if (flg >= 0)
            print(cur.key)
        if cur.left!=NULL && flg>=0
            flg = 1
            cur = cur.left
        else if cur.right!=NULL && flg!=-2
            flg = 2
            cur = cur.right
        else
            if (cur!=T && cur = cur.root.left)
                flg = -1
            else
                flg = -2
            cur = cur.root

10.4-6 任意有根树的左孩子、右兄弟结构，每个结点只有两个指针与一个布尔值，如何在与孩子数成线性关系的时间内访问其父亲结点或所有的孩子结点。
解：一个指针存放兄弟结点，另一个指针存放左孩子或父结点（由布尔值控制，布尔为真表示为孩子点，否则为父结点）。若布尔值为假，表示无孩子，存放父节点；若布尔值为真，表示有孩子，可以通过该孩子结点的兄弟结点开始遍历所有孩子结点，最右的孩子的兄弟结点存放其父节点。那么何时停止循环，伪代码如下：

if r.boolean == FALSE
    Father = r.lchild
else
    q = r.lchild
    while q.boolean==FALSE || q.lchild!=r6         q = q.rchild
    Father = q

第5行的while循环条件为结点的布尔值为假或者它的左孩子不等于r。当该兄弟结点没有孩子时，即q.boolean==FALSE（此时它的左孩子存放的是r，与if类似），因此需要继续探索其兄弟结点；当该兄弟结点有孩子时，可能已经是父节点了，因此通过q.lchild!=x判断。