《算法导论》笔记 第10章 10.2 链表

【笔记】

哨兵不能降低各种操作的渐进时间界，但可以降低常数因子，简化代码。

template <typename ITEM>class list {private:    struct DATA{        ITEM key;        DATA *prev, *next;        DATA() {}        DATA(ITEM x):key(x) {}    }NIL;    DATA *nil;    int sz;public:    list(){        nil = &NIL;        nil->next=nil;        nil->prev=nil;    }    ~list(){        while (sz) remove(nil->next);    }    void insert(ITEM x) {        DATA *p = new DATA(x);        p->next = nil->next;        nil->next->prev = p;        nil->next = p;        p->prev = nil;        sz++;    }    bool search(ITEM k) {        DATA* p = nil->next;        while (p != nil && p->key != k) p = p->next;        return p != nil;    }    void remove(DATA* p) {        p->prev->next = p->next;        p->next->prev = p->prev;        delete p;        sz--;    }};

【练习】

10.2-1 动态集合上的操作INSERT能否用一个单链表在O(1)时间内实现？对DELETE操作呢？

INSERT 能在O(1)内实现，DELETE不能。

10.2-2 用一单链表L实现一个栈，要求PUSH和POP操作的时间仍为O(1)。

const int MAXN = 10;struct NODE{    int key;    NODE *next;    NODE():key(0) {}    NODE(int x):key(x) {}};NODE* head[MAXN];void prepare(int L) {    head[L] = NULL;}NODE* search(int L,int k) {    NODE* p = head[L];    while (p!=NULL && p->key!=k) p = p->next;    return p;}void insert(int L,int x) {    NODE *p = new NODE(x);    p->next = head[L];    head[L] = p;}void remove(int L,NODE *p) {    if (p==NULL) return;    if (head[L] == p) {        head[L] = p->next;        delete p;        return;    }    NODE *t = head[L];    while (t->next!=NULL && t->next!=p) t = t->next;    if (t->next==NULL) return;    t->next = p->next;    delete p;}void push(int L,int x) {    insert(L,x);}int pop(int L) {    if (head[L]==NULL) return -1;    int res = head[L]->key;    remove(L,head[L]);    return res;}

10.2-3 用一单链表L实现一个队列，要求ENQUEUE和DEQUEUE操作的时间仍为O(1)。

struct NODE{    int key;    NODE *next;    NODE():key(0) {}    NODE(int x):key(x) {}};NODE *head[MAXN],*tail[MAXN];void prepare(int L) {    head[L] = NULL;    tail[L] = NULL;}void push(int L,int x) {    NODE *p = new NODE(x);    p->next = NULL;    if (head[L] == NULL) head[L] = p;    if (tail[L] != NULL) tail[L]->next = p;    tail[L] = p;}int pop(int L) {    if (head[L]==NULL) return -1;    int res = head[L]->key;    NODE *p = head[L];    head[L] = head[L]->next;    delete p;    return res;}

10.2-4 如前文所写，LIST-SEARCH'过程的每一次循环迭代都需要做两个测试：一个检查x!=nil[L]，一个检查key[x]!=k。说明如何能够在每次迭代中，省去对x!=nil[L]的检查。

将哨兵的值赋为要查找的值，在循环结束后判断找到的结点是否为哨兵即可。

10.2-5 用环形单链表来实现字典操作INSERT、DELETE和SEARCH，并给出它们的运行时间。

O(1) O(n) O(n) ?

10.2-6 动态集合操作UNION以两个不想交的集合S1和S2作为输入，输出集合S=S1∪S2包含了S1和S2的所有元素。该操作常常会破坏S1和S2。说明应如何选用一种数据结构，以便支持在O(1)时间内的UNION操作。

采用链表，head[L]指向表头，tail[L]指向表尾。合并时将tail[S1]->next 指向head[S2]。新集合的表头为head[S1]。

10.2-7 请给出一个θ(n)时间的非递归过程，它对含n个元素的单链表的链进行逆转。除了链表本身占用的空间外，该过程应仅使用固定量的存储空间。

void reverse(int L) {    NODE *pre, *p, *nxt;    pre = NULL;    p = head[L];    nxt = p->next;    while (p) {        if (nxt == NULL) {            head[L] = p;            break;        }        p->next = pre;        pre = p;        p = nxt;        nxt = nxt->next;    }}

*10.2-8 说明如何对每个元素仅用一个指针np[x]来实现双链表。

用异或即可，由a^b^b=a可知，np[x]中储存的是next[x]^prev[x]。

从前向后遍历时，prev[x]已知，令pt为prev[x]，next[x]即为np[x]^pt，pt初值存在head[L]中。

从后向前遍历时，next[x]已知，令pt为next[x]，prev[x]即为np[x]^pt。