王道2023线性表部分代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

// 单链表
typedef struct LNode{
    int data;
    struct LNode * next;
}LNode, *LinkList;

// 头插法
LinkList head_insert(LinkList * L){
    LNode * s;
    (*L) = (LinkList)malloc(sizeof(LNode));
    (*L)->next = NULL;
    int x = 0;

    printf("请输入插入的数据(输入9999为结束输入):\n");
    scanf("%d",&x);
    while(x != 9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        s->next = (*L)->next;
        (*L)->next = s;
        printf("请输入插入的数据(输入9999为结束输入):\n");
        scanf("%d",&x);
    }
    return *L;
}
// 尾插法
LinkList tail_insert(LinkList*L){
    (*L) = (LinkList)malloc(sizeof(LNode));
    LNode *r,*s; // 指向头结点
    r = (*L);
    int x = 0;

    printf("请输入插入的数据(输入9999为结束输入):\n");
    scanf("%d",&x);
    while(x != 9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;

        printf("请输入插入的数据(输入9999为结束输入):\n");
        scanf("%d",&x);
    }
    r->next = NULL;

    return *L;
}
LinkList loop_tail_insert(LinkList * L){
    (*L) = (LinkList)malloc(sizeof(LNode));
    LNode *r,*s; // 指向头结点
    r = (*L);
    int x = 0;

    printf("请输入插入的数据(输入9999为结束输入):\n");
    scanf("%d",&x);
    while(x != 9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;

        printf("请输入插入的数据(输入9999为结束输入):\n");
        scanf("%d",&x);
    }
    r->next = (*L);
    return *L;
}
// 按序号查找结点
LNode* getelementsequence(LinkList L, int i){
    LNode * s = L;
    for(int j = 1; j<=i; j++){
        s = s->next;
    }
    return s;
}
// 按照值查找结点
LNode* getelementvalue(LinkList L, int value){
    LNode * s = L->next;
    for(int j = 1;j!=value;j++){
        s = s->next;
    }
    return s;
}
// 插入某个结点
LinkList insertLNode(LinkList *L, int i, int data){
    LNode * s = (*L);
    LNode * r = NULL;
    s = getelementsequence(*L,i-1);
    r = (LNode *)malloc(sizeof(LNode));
    r->data = data;
    r->next = s->next;
    s->next = r;
    (*L)->data++;
    return *L;
}

LinkList insertLNode1(LinkList L, int i, int data){
    LNode * s = L;
    LNode * r = NULL;
    s = getelementsequence(L,i-1);

    r = (LNode *)malloc(sizeof(LNode));
    r->data = data;
    r->next = s->next;
    s->next = r;
    L->data++;
    return L;
}
// 删除某个结点
LinkList deletelement(LinkList *L, int i){
    LNode * s = (*L)->next;
    LNode * r = NULL;
    s = getelementsequence(*L,i-1);
    r = s->next;
    s->next = r->next;
    free(s);// 忘写 
    (*L)->data--;
    return *L;
}
// 打印每个结点
void output(LinkList L){
    LNode *s = L->next;
    for(int i =1;s!=NULL;i++){
        printf("%d\n",s->data);
        s = s->next;
    }
}
void loop_output(LinkList L){
    LNode *s = L->next;
    for(int i =1;s!=L;i++){
        printf("%d\n",s->data);
        s = s->next;
    }
}
// 双链表
typedef struct DNode{
    int data;
    struct DNode * prior, *next;
}DNode, *DLinklist;
// 双链表尾插法
DLinklist D_tail_insert(DLinklist * D){
    (*D) = (DLinklist)malloc(sizeof(DNode));
    (*D)->prior = NULL;
    DNode *r,*s;
    r = (*D);
    int x = 0;
    int length = 0;
    printf("请输入插入的数据(输入9999结束输入):\n");
    scanf("%d",&x);
    while(x != 9999){
        s = (DNode*)malloc(sizeof(DNode));
        s->data = x;
        r->next = s;
        s->prior = r;
        r = s;
        length++;
        printf("请输入插入的数据(输入9999结束输入):\n");
        scanf("%d",&x);
    }
    r->next = NULL;
    (*D)->data = length;
    return *D;
}
DLinklist Loop_D_tail_insert(DLinklist * D){
    (*D) = (DLinklist)malloc(sizeof(DNode));
    (*D)->prior = NULL;
    DNode *r,*s;
    r = (*D);
    int x = 0;
    int length = 0;
    printf("请输入插入的数据(输入9999结束输入):\n");
    scanf("%d",&x);
    while(x != 9999){
        s = (DNode*)malloc(sizeof(DNode));
        s->data = x;
        r->next = s;
        s->prior = r;
        r = s;
        length++;
        printf("请输入插入的数据(输入9999结束输入):\n");
        scanf("%d",&x);
    }
    r->next = (*D)->next;
    (*D)->next->prior = r;
    (*D)->data = length;
    return *D;
}
// 双链表插入
DLinklist insertDNode(DLinklist * D, int i, int data){
    DNode * r = (*D)->next;
    DNode * s = (DLinklist)malloc(sizeof(DNode));
    for(int j = 1;j<i-1;j++){
        r = r->next;
    }
    s->data = data;
    s->next = r->next;
    r->next->prior = s;
    r->next = s;
    s->prior = r;
    (*D)->data++;
    return *D;
}
// 双链表删除
DLinklist deleteDNode(DLinklist * D, int i){
    DNode *s = (*D)->next;
    for(int j = 1;j<i-1;j++){
        s = s->next;
    }
    DNode *r = s->next;
    s->next = r->next;
    r->next->prior = s;
    free(r);
    (*D)->data--;
    return (*D);
}
// 打印每个结点
void D_output(DLinklist D){
    DNode * s = D->next;
    for(int j = 1;j<=D->data;j++){
        printf("%d\n",s->data);
        s = s->next;
    }
}
// 第一题
// 结构体在上边
// 不带头结点不会写
LinkList nohead_tail_build(LinkList*L, int *length){
    int data = 0;
    printf("请输入数据(输入9999为结束输入:)\n");
    scanf("%d",&data);
    LNode * s, *r;
    (*L) = (LinkList)malloc(sizeof(LNode));
    // 对首元结点的处理
    if (data!= 9999){
        (*L)->data = data;
        printf("请输入数据(输入9999为结束输入:)\n");
        scanf("%d",&data);
        (*length)++;
    }
    else{
        (*L) = NULL;
        return (*L);
    }
    r = (*L);
    while(data!=9999){
        s = (LNode*)malloc(sizeof(LNode));
        s->data = data;
        r->next = s;
        r = s;
        (*length)++;
        printf("请输入数据(输入9999为结束输入:)\n");
        scanf("%d",&data);
    }
    r->next = NULL;
    
    return (*L);
}
// 不带头结点的头插法
// 不带头结点的头插法如何逆序(头结点提前处理)
LinkList nohead_head_build(LinkList*L, int*length){
    int data = 0;
    (*L) = (LinkList)malloc(sizeof(LNode));
    LNode *s;
    printf("请输入数据(输入9999为结束输入:)\n");
    scanf("%d", &data);
    if (data != 9999){
        (*L)->data = data;
        (*L)->next = NULL;
        (*length)++;
        printf("请输入数据(输入9999为结束输入:)\n");
        scanf("%d", &data);
    }
    else{
        (*L) = NULL;
        return (*L);
    }
    while(data != 9999){
        s = (LNode*)malloc(sizeof(LNode));
        s->data = data;
        s->next = (*L);
        (*L) = s;
        (*length)++;
        printf("请输入数据(输入9999为结束输入:)\n");
        scanf("%d", &data);
    }
    return (*L);
}
// output
void nohead_output(LinkList L, int length){
    LNode * s;
    s = L;
    for(int j = 0;j<length;j++){
        printf("%d\n",s->data);
        s = s->next;
    }
}
// 第一题 只能free 不能打印
void free_node(LinkList *L, int x, int *length){
    LNode *p;
    if ((*L)->data == x){
        p  = (*L);
        (*L) = (*L)->next;
        free(p);
        (*length)--;
    }
    else{
        *L = (*L)->next;
    }
    if ((*L) != NULL){
        free_node(L, x, length);
    }
}
// 第二题
void Delete_x_Node(LinkList *L, int x){
    LNode *s, *r;
    r = *L;
    s = r->next;
    while(s != NULL){
        if (s->data == x){
            r->next = s->next;
            free(s);
            s = r->next;
        }
        else{
            r = r->next;
            s = r->next;
        }
    }
}
// 第三题
// 主函数
    // LinkList L;
    // tail_insert(&L);
    // output(L);
    // printf("\n");
    // reverse_output(L->next);// 将头指针mute
void reverse_output(LinkList L){
    
    if (L->next !=NULL){
        reverse_output(L->next);
        printf("%d\n",L->data);
    }
    else{
        printf("%d\n",L->data);
    }

}
// 第四题 
void Delet_min(LinkList *L){
    LNode *s = (*L)->next;
    (*L)->data = 9999;
    int index = 0;
    while(s != NULL){
        if ((s->data)< (*L)->data){
            (*L)->data = s->data;
            index++;
        } 
        s = s->next;
    }
    LNode * r = (*L);
    LNode * q = r->next;
    while(q->data != (*L)->data||q == NULL){
        r = r->next;
        q = q->next;
    }
    r->next = q->next;
    free(q);
}
// 第五题
// 想法有问题
// 我想的是直接在原先地方不变，以至于无法在头上设置NULL 也无法修改
// 答案直接将原先地方修改 头上变成NULL 最后把修改好的加在链表中
void reverse_stay(LinkList *L){
    LNode * before;
    LNode * now = (*L)->next;
    LNode * after = now->next;
    // 首先将头设置为NULL
    now->next = NULL;
    while(after){
        before = now;
        now = after;
        after = after->next;
        // 为什么这时候now->next=before不改变L
        // 因为在上边now = after
        now->next = before;
    }
    (*L)->next = now;
}
// 第六题
void sort_Linklist(LinkList * L){
    int t = 0;
    // 选择
    for(LNode *s = (*L)->next; s->next != NULL ;s = s->next){
        for (LNode *r = s->next; r != NULL;r = r->next){
            if (r->data<s->data){
                t = r->data;
                r->data = s->data;
                s->data = t;
            }
        }
    }
}
// 第七题 先排序再删除
void Delet_between_a_and_b(LinkList *L, int a, int b){
    sort_Linklist(L);
    LNode *A, *B;
    LNode *s = (*L)->next;
    while(s->next!=NULL){
        if(s->data<a && s->next->data>=a){
            A = s;
        }
        if (s->data<b && s->next->data>=b){
            B = s->next;
        }
        s = s->next;
    }
    if (A!=NULL &&B!=NULL){
        A->next = B;
    }
}
// 第八题
LNode * common_node(LinkList L1, LinkList L2){
    int t = 0;
    LNode *s;
    LNode *r;
    s = L1->next;
    r = L2->next;
    if (L1->data>L2->data){
        t = L1->data - L2->data;
        while(t!=0){
            s = s->next;
            t--;
        }
    }
    else{
        t = L2->data - L1->data;
        while(t!=0){
            r = r->next;
            t--;
        }
    }
    while(s->next != r->next){
        s = s->next;
        r = r->next;
    }
    return s->next;
}
// 第九题
void free_everynode(LinkList *L){
    if ((*L)->next != NULL){
        (*L) = (*L)->next;
        free_everynode(L);
    }
    else{
        LNode *s = (*L);
        free(s);
    }
}
void sort_and_free(LinkList *L){
    sort_Linklist(L);
    free_everynode(L);
}
// 第十题
// odd为奇数 even为偶数
// 空间复杂度太高
// 题理解错误 不是数 是序号
void split_to_two_Linklisterror(LinkList *L, LinkList *odd, LinkList *even){
    LNode *s = (*L)->next;
    *even = (LinkList)malloc(sizeof(LNode));
    *odd = (LinkList)malloc(sizeof(LNode));
    LNode *o = (*odd);
    LNode *e = (*even);
    o->next = NULL;
    e->next = NULL;
    while(s != NULL){
        LNode * Nodeo = (LNode*)malloc(sizeof(LNode));
        LNode * Nodee = (LNode*)malloc(sizeof(LNode));
        if (s->data % 2 == 0){
            Nodeo = (LNode*)malloc(sizeof(LNode));
            Nodeo->data = s->data;
            Nodeo->next = o->next;
            o->next = Nodeo;
            o = Nodeo;
        }
        else{
            Nodee = (LNode*)malloc(sizeof(LNode));
            Nodee->data = s->data;
            Nodee->next = e->next;
            e->next = Nodee;
            e = Nodee;
        }
        s = s->next;
    }
}
// 出错次数很多
// 主要原因：
// 中间想让一个指向head 另一个指向nexthead 后来发现head进入next nexthead也进入这个数
// 对指针的理解不牢固
void split_to_two_Linklist(LinkList L, LinkList * even, LinkList *odd){
    LNode* head = L->next;
    LNode* nexthead = head->next;
    *odd = (LinkList)malloc(sizeof(LNode));
    *even = (LinkList)malloc(sizeof(LNode));
    LNode * o = *odd;
    LNode * e = *even;

    o->next = head;
    e->next = nexthead;

    o = o->next;
    e = e->next;

    while (e&&e->next) {
        o->next = e->next;
        o = o->next;
        e->next = o->next;
        e = e->next;
    }
    o->next = NULL;
}
//第十一题
//与第十一题相似,最后将b原地逆序即可
void spilt_Linklist(LinkList L, LinkList *a, LinkList *b){
    split_to_two_Linklist(L, a, b);
    reverse_stay(a);
}
// 第十二题
void delete_same_element(LinkList *L){
    LNode * head = (*L)->next;
    LNode * nexthead = head->next;
    while(nexthead){
        if (head->data == nexthead->data){
            head->next = nexthead->next;
        }
        else{
            head = head->next;
        }
        nexthead = nexthead->next;
    }
}
// 第十三题
void rebuild_a_drop_list(LinkList a, LinkList b, LinkList * c){
    // 首先逆序
    reverse_stay(&a);
    reverse_stay(&b);
    LNode *s, *m, *n;
    (*c) = (LinkList)malloc(sizeof(LNode));
    m = a->next;
    n = b->next;
    s = (*c);
    while(m&&n){
        if (m->data>=n->data){
            s->next = m;
            m = m->next;
        }
        else if(m->data<n->data){
            s->next = n;
            n = n->next;
        }
        s = s->next;
    }
    if (m==NULL){
        s->next = n;
    }
    else{
        s->next = m;
    }
}
// 第十四题
void common_list(LinkList a, LinkList b, LinkList *c){
    (*c) = (LinkList)malloc(sizeof(LNode));
    LNode *x, *y;
    LNode * head = (*c);
    LNode *temp;
    x = a->next;
    y = b->next;
    while(x&&y){
        if(x->data == y->data){
            temp = (LNode*)malloc(sizeof(LNode));
            temp->data = x->data;
            temp->next = head->next;
            head->next = temp;
            head = temp;
            x = x->next;
            y = y->next;
        }
        else if(x->data>y->data){
            y = y->next;
        }
        else{
            x = x->next;
        }
    }
}
// 第十五题
void intersection_list(LinkList a, LinkList b, LinkList * c){
    (*c) = (LinkList)malloc(sizeof(LNode));
    LNode * x, *y, *z, *temp,*head;
    x = a->next;
    y = b->next;
    z = (*c);
    head = (*c);
    head->next = NULL;
    while(x&&y){
        if(x->data<y->data){
            x = x->next;
        }
        else if(x->data>y->data){
            y = y->next;
        }
        else{
            temp = (LNode*)malloc(sizeof(LNode));
            temp->data = x->data;
            temp->next = head->next;
            head->next = temp;
            head = temp;
            x = x->next;
            y = y->next;
        }
    }
}
// 第十六题 KMP 暂时跳过
// 第十七题
bool symmetric_dlist(DLinklist D){
    DNode * head, *rear;
    head = D->next;
    rear = head->prior;
    while(head!=rear && head->next != rear){
        if(head->data!=rear->data){
            printf("false");
            return false;
        }
        head = head->next;
        rear = rear->prior;
    } 
    printf("true");
    return true;
}
// 第十八题
void connect_two_loop_Linklist(LinkList*a, LinkList*b){
    LNode *a_head,* a_rear, *b_head, *b_rear;
    a_head = (*a)->next;
    b_head = (*b)->next;
    while(a_head->next != (*a)){
        a_head = a_head->next;
    }
    a_rear = a_head;
    while(b_head->next != (*b)){
        b_head = b_head->next;
    }
    
    b_rear = b_head;
    a_rear->next = (*b)->next;
    b_rear->next = (*a);
}
// 第十九题
void delete_min_node(LinkList *L){
    LNode *head = (*L)->next;
    int temp = 0;
    for(LNode * s = head; s->next != (*L); s = s->next){
        for(LNode * r = s->next; r->next != (*L); r = r->next){
            if(s->data>=r->data){
                temp = s->data;
                s->data = r->data;
                r->data = temp;
            }
        }
    }
    // 逆序再递归
    LNode *drop;
    while (head!=(*L)){
        drop = head;
        head = head->next;
        (*L)->next = head;
        free(drop);
    }
}
// 第二十题
typedef struct LDNode{
    struct LDNode * pred;
    struct LDNode * next;
    int data;
    int freq;
}LDNode, *LDlist;
// 尾插法
void LD_tail(LDlist*LD){
    (*LD) = (LDlist)malloc(sizeof(LDNode));
    LDNode * r, *s;
    r = (*LD);
    r->pred = NULL;
    int x = 0;
    printf("请输入插入的数据(输入9999为结束输入:)\n");
    scanf("%d",&x);
    while(x != 9999){
        s = (LDNode*)malloc(sizeof(LDNode));
        s->data = x;
        s->freq = 0;
        r->next = s;
        s->pred = r;
        r = s;
        printf("请输入插入的数据(输入9999为结束输入:)\n");
        scanf("%d",&x);
    }
    r->next = NULL;
}
void LD_output(LDlist LD){
    LDNode * r;
    r = LD->next;
    while(r){
        printf("%d\n",r->data);
        r = r->next;
    }
}
LDNode* Locate(LDlist *LD, int x){
    LDNode *s = (*LD)->next;
    LDNode *r = s->pred;
    int data, freq;
    while(s){
        if (x == s->data){
            s->freq++;
            while(r&&r->pred){
                if (r->freq<s->freq){

                    data = r->data;
                    r->data = s->data;
                    s->data = data;

                    freq = r->freq;
                    r->freq = s->freq;
                    s->freq = freq;
                    s = r;
                    r = r->pred;
                }
                else{
                    r = r->pred;
                }
            }
        }
        s = s->next;
        r = s;
    }
    return (*LD)->next;
}
// 第二十一题
// bool circular(LinkList L){
//     LNode * s = L->next;
//     while()
// }
// 第二十二题

bool returnreciprocalnumber(LinkList L, int k){
    int length = 0;
    int i = 0;
    LNode *s = L->next;
    LNode *r = L->next;
    while(s->next){
        length++;
        s = s->next;
    }
    if (length<k){
        printf("没找到");
        return false;
    }
    else{
        while(i != length-k+1){
            r = r->next;
            i++;
        }
    }
    printf("\n");
    printf("%d\n", r->data);
    return true;
    
}
// 第二十三题
// 与第八题相同
// 第二十四题
// 1.为hash 空间换时间
// 2.为排序
// 最后的顺序不对
void delete_equal_abs(LinkList *L){
    LNode *s = (*L)->next;
    int temp = 0;
    int a,b;
    for(LNode *x = (*L)->next; x != NULL; x = x->next){
        for(LNode * y = x->next; y != NULL; y = y->next){
            a = x->data;
            b = y->data;
            if (a<0){
                a = -a;
            }
            if (b<0){
                b = -b;
            }
            if (a<b){
                temp = x->data;
                x->data = y->data;
                y->data = temp;
            }
        }
    }
    LNode * m = (*L)->next;
    LNode * n = m->next;
    while(n){
        if(m->data == n->data||m->data == -n->data){
            m->next = n->next;
            n = n->next;
        }
        else{
            m = m->next;
            n = n->next;
        }
    }
}
int main(){
    LinkList L;
    tail_insert(&L);
    reverse_stay(&L);
    // returnreciprocalnumber(L, 2);
    // LDlist LD;
    // LD_tail(&LD);
    // LD_output(LD);
    // Locate(&LD, 2);
    // printf("\n");
    // LD_output(LD);
    // LinkList L;
    // loop_tail_insert(&L);
    // loop_output(L);
    // printf("\n");
    // delete_min_node(&L);
    // loop_output(L);
    // LinkList a,b;
    // loop_tail_insert(&a);
    // loop_tail_insert(&b);
    // loop_output(a);
    // printf("\n");
    // loop_output(b);
    // printf("\n");
    // connect_two_loop_Linklist(&a, &b);
    // loop_output(a);
    // DLinklist D;
    // Loop_D_tail_insert(&D);
    // D_output(D);
    // symmetric_dlist(D);
    // LinkList a, b, c;
    // tail_insert(&a);
    // tail_insert(&b);
    // intersection_list(a,b,&c);
    // output(c);
    // LinkList L;
    // tail_insert(&L);
    // delete_same_element(&L);
    // output(L);
    // LinkList L, a, b;
    // tail_insert(&L);
    // spilt_Linklist(L, &a, &b);
    // printf("\n");
    // output(a);
    // printf("\n");
    // output(b);
    // LinkList L, odd, even;
    // tail_insert(&L);
    // output(L);
    // split_to_two_Linklist(L,&odd,&even);
    // printf("\n");
    // output(odd);
    // printf("\n");
    // output(even);
    // tail_insert(&L);
    // output(L);
    // sort_and_free(&L);
    // LinkList L;
    // int a = 0;
    // int b = 0;
    // printf("请输入a,b的值\n");
    // scanf("%d %d",&a,&b);
    // tail_insert(&L);
    // printf("\n");
    // output(L);
    // Delet_between_a_and_b(&L, a,b);
    // printf("\n");
    // output(L);
    // tail_insert(&L);
    // output(L);
    // printf("\n");
    // Delet_min(&L);
    // output(L);
    // LinkList L;
    // tail_insert(&L);
    // output(L);
    // printf("\n");
    // reverse_output(L->next);// 将头指针mute
    // int x = 0;
    // printf("请输入需要释放的元素的值:");
    // scanf("%d", &x);
    // tail_insert(&L);
    // output(L);
    // printf("\n");
    // Delete_x_Node(&L, x);
    // output(L);
    // Free_x_Node(&L, &length, x);
    // LinkList L;
    // LNode * s;
    // // head_insert(&L);
    // tail_insert(&L);
    // output(L);
    // insertLNode(&L,2,3);
    // output(L);
    // DLinklist D;
    // D_tail_insert(&D);
    // D_output(D);
    // insertDNode(&D,2,3);
    // deleteDNode(&D, 2);
    // D_output(D);
    return 0;
}