王道上几道链表的小题（上）

• 设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点

void del_x(Linklist &L, ElemType x){
    LNode *p;
    if(L == NULL){
        return;
    }
    if(L->data == x){
        p = L;
        L = L->next;
        free(p);
        del_x(L, x);
    }else{
        del_x(L->next, x);
    }
}

• 在带头结点的单链表L中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一，试编写算法以实现上述操作

// 普通方式
void del_x(Linklist &L, ElemType x){
    LNode *p = L->next, *pre = L, *q;
    while(p != NULL){
        if(p->data == x){
            q = p;
            p = p->next;
            pre->next = p;
            free(q);
        }else{
            pre = p;
            p = p->next;
        }
    }
}

// 尾插法，值不为x的结点尾插建表，值为x的结点释放
void del_x(Linklist &L, ElemType x){
    LNode *p = L->next, *r = L,  *q;
    while(p != NULL){
        if(p->data != x){
            r->next = p;
            r = p;
            p = p->next;
        }else{
            q = p;
            p = p->next;
            free(q);
        }
    }
    r->next = NULL;
}

• 设L为带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值

// 递归输出后面的一个结点
void R_Print(Linklist L){
    if(L->next != NULL){
        R_Print(L->next);
    }
    print(L->data);
}

• 试编写在带头结点的单链表L中删除一个最小值结点的高效算法

// 遍历链表，使用一个指针记录最小值的结点，遍历结束后，删除该结点
LinkList del_min(Linklist &L){
    LNode *pre = L, *p = pre->next;
    LNode *minpre = pre, *minp = p;
    while(p != NULL){
        if(p->data < minp->data){
            minp = p;
            minpre = pre;
        }
        pre = p;
        p = p->next;
    }
    minpre->next = minp->next;// 删除最小值结点
    free(minp);
    return L;
}

• 试编写算法将带头结点的单链表就地逆置，所谓"就地"是指辅助空间复杂度为O(1)

LinkList Reverse(LinkList L){
    // 摘下结点，头插法建表，逆置元素
    LNode *p, *r;    
    p = L->next;
    L->next = NULL;
    while(p != NULL){
        r = p->next;
        p->next = L->next;
        L-next = p;
        p = r;
    }
    return L;
}

LinkList Reverse(LinkList L){
    // 遍历链表，逆转指针
    LNode *pre, *p = L->next, *r = p->next;
    p->next = NULL;// 处理第一个结点
    while(r != NULL){
        pre = p;
        p = r;
        r = r->next;
        p->next = pre;
    }
    L->next = p;// 处理最后一个结点
    return L;
}

• 有一个带头结点的单链表L，设计一个算法使其元素递增有序

void Sort(LinkList &L){
    // 单链表的直接插入排序
    LNode *p = L->next, *pre;
    LNode *r = p->next;
    p->next = NULL;// 构造只含一个结点的有序序列
    p = r;
    while(p != NULL){
        r = p->next;// 记录p的后继结点
        pre = L;
        // 查找合适的插入位置
        while(pre->next != NULL && pre->next->data < p->data){
            pre = pre->next;
        }
        // 交换无序序列第一个元素与插入位置元素的位置
        p->next = pre->next;
        pre->next = p;
        p = r;
    }
}

• 设在一个带头结点的单链表中所有元素结点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值（作为函数参数给出）之间的元素的元素（若存在）

void del_range(LinkList &L, int x, int y){
    // 思路很简单，遍历链表，查找介于x与y的元素，并删除
    LNode *p = L->link, *q;
    while(p != NULL){
        if(p->data > x && p->data < y){
            q = p;
            p = p->link;
            free(q);
        }else{
            p = p->link;
        }
    }
}

• 给定两个单链表，编写算法给出两个链表的公共结点

LinkList Search(Linklist L1, Linklist L2){
    // 有一个公共结点，意味着两链表从某一结点开始，它们的next都指向同一个结点
    // 求出二者长度之差，先遍历长的链表长度之差个结点，再同步遍历两个结点，直到找到相同的结点
    // 或者一直到链表结束
    int len1 = Length(L1),  len2 = Length(L2), dist;
    Linklist longList, shortList;
    if(len1 > len2){
        longList = L1->next;
        shortList = L2->next;
        dist = len1 - len2;
    }else{
        longList = L2->next;
        shortList = L1->next; 
        dist = len2 - len1;
    }

    while(dist--){
        longList = longList->next;
    }
    while(longList != NULL){
        if(longList == shortList){
            return longList;
        }else{
            longList = longList->next;
            shortList = shortList->next;
        }
    }
    return NULL;
}

• 给定一个带表头结点的单链表，设head为头指针，结点的结构(data, next)，data为整型元素，next为指针，试写出算法：按递增次序输出单链表中各节点的数据元素，并释放结点所占的存储空间（不允许用数组作为辅助空间）

void del_min(Linklist &head){
    // 遍历链表，每次删除最小元素并输出，直到链表为空
    LNode *pre, *p， *s;
    while(head->next != NULL){
        pre = head;
        p = pre->next;
        while(p->next != NULL){
            if(p->next->data < pre->next->data){
                pre = p;
            }
            p = p->next;
        }
        print(pre->next->data);
        s = pre->next;
        pre->next = s->next;
        free(s);
    }
    free(head);
}

• 将一个带头结点的单链表A分解为两个带头结点的单链表A和B，使得A表中含有原表中序号为奇数的元素，而B表中中含有原表中序号为偶数的元素，并保持其相对顺序不变

Linklist disCreate(Linklist &A){
    int i = 0;
    Linklist B = (Linklist)malloc(sizeof(LNode));
    B->next = NULL;
    LNode *ra = A, *rb = B, *p;
    p = A->next;
    A->next = NULL;
    while(p != NULL){
        i++;
        if(i % 2 == 0){
            rb->next = p;
            rb = p;
        }else{
            ra->next = p;
            ra = p;
        }
        p = p->next;
    }
    ra->next = NULL;
    rb->next = NULL;
    return B;
}

• 设C={a1, b1, a2, b2, ..., an, bn}为线性表，采用带头结点的hc单链表存放，设计一个就地算法，将其拆分为两个线性表，得A={a, a2, ..., an}，B={bn, ..., b2, b1}

Linklist disCreate(Linklist &A){
    // 尾插法建表B
    Linklist B = (Linklist)malloc(sizeof(LNode));// 创建B表表头
    B->next = NULL;
    LNode *ra = A;
    LNode *p = A->next, *q;
    while(p != NULL){
        ra->next = p;
        ra = p;
        q = p->next;// 用q记录结点，方便插入
        p = q->next;
        q->next = B->next;
        B->next = q;
    }
    ra->next = NULL;
    return B;
}

在一个递增有序得线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使表中不再有重复的元素。例如 （7, 10, 10, 21, 30, 42, 42, 42, 51, 70）将变作（7, 10, 21, 30, 42, 51, 70）

void del_same(Linklist &L){
    LNode *p = L->next, *q;
    if(p == NULL){
        return;
    }
    while(p->next != NULL){
        q = p->next;
        if(p->data == q->data){
            p->next = q->next;
            free(q);
        }else{
            p = p->next;
        }
    }
}