王道数据结构链表习题实现（持续更新）

1.链表定义及基本操作

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;

typedef struct LNode{
    int data;
    struct LNode *next;
}LNode, *LinkList;

//遍历单链表
void printLinkList(LinkList L){
    LNode *p = L->next;
    while(p!= nullptr){
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
}
//头插法建立单链表
void createLinkList(LinkList &L){
    LNode *p;int x;
    scanf("%d",&x);
    while(x!=11){
        p = (LNode *) malloc(sizeof(LNode));
        p->data = x;
        p->next = L->next;
        L->next = p;
        scanf("%d",&x);
    }
}
//初始化单链表
void InitLinkList(LinkList &L){
    L = (LinkList) malloc (sizeof(LNode));
    L ->next = nullptr;
}

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

//1.判断当前节点是否值为x 若是则删除，否则将后面的部分看作一个单链表
//注意传入的是引用 链不会断
void test1(LinkList &L,int x){
    LNode *p ;
    if(L== nullptr){
        return ;
    }
    if(L->data==x){
        p = L;
        L = L ->next;
        free(p);
        test1(L,x);
    }else
        test1(L->next,x);
}

第二题:在带头节点的单链表中删除所有值为x的节点，并释放其空间，假设值为x的节点不唯一，设编写算法实现上述操作

void test2(LinkList &L,int x){
    LNode *p = L;LNode *q = L->next;
    LNode * f;
    while(q!= nullptr){
        if(q->data == x){
            f = q;
            q = q -> next;
            p ->next = q;
            free(f);
        }else{
            p = q;
            q = q->next;
        }
    }
}

第三题：设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值

void test3(LinkList L){
    if(L->next!= nullptr) test3(L->next);
    if(L!= nullptr) printf("%d ",L->data);
}

第四题：试编写在带头节点的单链表L中删除一个最小值的高效算法(假设最小值节点是唯一的)

void test4(LinkList &L){
    LNode *p = L; LNode *q = L->next;
    LNode *minptr; int min = q->data;
    while(q->next!= nullptr){
        p = q;
        q = q->next;
        if(q->data<min){
            min = q->data;
            minptr = p;
        }
    }
    minptr->next = minptr->next->next;
}

第五题：试编写算法将带头节点的单链表就地逆置 ，空间复杂度要求o(1)

void test5(LinkList &L){
    LNode *p = L;
    LNode *q = p->next;
    L->next = nullptr;
    while(q!= nullptr){
        p = q;
        q = q ->next;
        p->next = L->next;
        L->next = p;
    }
}

第六题 ：有一个带头节点的单链表L，设计一个算法使元素递增有序

//思想:直接插入排序 时间复杂度o(n2)
void test6(LinkList &L){
    if(L->next== nullptr) return;
    LNode *p = L->next; LNode *q = p->next;
    p->next = nullptr;
    //把包含q指针和后面的元素进行选择排序
    LNode *r; LNode *pre;
    while(q!= nullptr){
        r = q->next;
        //找插入的前驱
        pre = L;
        while(pre->next!= nullptr&&pre->next->data<=q->data){
            pre = pre->next;
        }
        //pre插入前驱节点
        q->next = pre->next;
        pre->next = q;
        q = r;
    }
}

第七题：设在一个带表头节点的单链表中所有元素节点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值之间的元素

void test7(LinkList &L,int a,int b){
    LNode *p = L;LNode *q = L->next;
    LNode *f;
    while(q!= nullptr){
        if(q->data>a&&q->data<b){
            f = q;
            p->next = q->next;
            free(f);
            q = p->next;
        }else {
            p = q;
            q = q->next;
        }
    }
}

第八题：给定两个单链表，编写算法找出两个链表的公共节点

• 思路：同时遍历A，B链表，若A链表遍历完后从B链表头进行遍历
  若B链表遍历完后从A链表头遍历 两个链表必在公共节点处交汇

LNode * test8(LinkList &headA,LinkList &headB ){
    auto p = headA, q = headB;
    while(p != q) {
        if(p) p = p->next;
        else p = headB;
        if (q) q = q->next;
        else q = headA;
    }
    return p;
}

未完持续更新！