数据结构(c语言版) 链表(单链表、双链表、循环单链表、循环双链表)

作业一（单链表）

单链表的创建，增加，插入，查找，删除操作, 单链表集合的做差，交集，并集操作

代码

#include 
#include 

//定义结构体类型
struct ListNode{
    int element;
    struct ListNode * next;
};

//初始化结构体
void initList(struct ListNode * head){
    head->next = NULL;
}

/**************************  插入操作  ******************************/
//插入新结点操作，头插法
void insertNode_t(struct ListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }

    struct ListNode* cur = head;

    struct ListNode* NewNode = malloc(sizeof(struct ListNode));
    NewNode->next = cur->next;
    NewNode->element = value;
    cur->next = NewNode;
}

//插入新结点操作,尾插法
void insertNode_w(struct ListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }

    struct ListNode* cur = head;
    while(cur->next != NULL){
        cur = cur->next;
    }

    struct ListNode* NewNode =  malloc(sizeof(struct ListNode));
    NewNode->next = NULL;
    NewNode->element = value;

    cur->next = NewNode;
}

//插入新结点操作，定位后插法
void insertNode_dh(struct ListNode* head, int index, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败\n");
        return;
    }

    if(index<1){
        printf("插入位置非法！\n");
        return;
    }

    while(--index){
        head = head->next;
        if(head == NULL){
            printf("插入失败：插入位置超出链表长度\n");
            return;
        }
    }

    struct ListNode* NewNode = malloc(sizeof(struct ListNode));
    if(NewNode == NULL){
        printf("插入失败：创建新结点失败\n");
    }
    NewNode->next = head->next;
    NewNode->element = value;
    head->next = NewNode;

}

/**************************  查找操作  ******************************/
//按值查询数据位置
void findNode_z(struct ListNode* head, int value){
    int index = 0;
    int flag = 0;

    while(head != NULL){
        if(head->element == value){
            printf("查找成功：数字%d在第 %d 位\n",value, index);
            flag = 1;
        }
        index ++;
        head = head->next;
    }

    if(flag == 0){
        printf("未查找到数据%d", value);
    }
}

//按位置查找数据
void findNode_v(struct ListNode* head, int index){
    if(index < 1){
        printf("查找失败：输入的查询位置非法！\n");
        return;
    }

    int temp = 1;
    int flag = 0;

    while(head->next != NULL){
        if(temp == index){
            printf("查找成功：第%d位的数字为 %d \n",index, head->next->element);
            flag = 1;
        }
        temp ++;
        head = head->next;
    }

    if(flag == 0){
        printf("查找失败：输入的查询位置超过链表长度！\n");
    }
}

/**************************  删除操作  ******************************/
//按位置删除
void deleteNode_w(struct ListNode* head, int index){
    if(index < 1){
        printf("删除失败：删除位置非法！\n");
        return;
    }

    while (--index){
        head = head->next;
        if(head->next == NULL){
            printf("删除失败：删除位置越界！\n");
            return;
        }
    }
    struct ListNode* temp = head->next;
    head->next = head->next->next;
    free(temp);
    printf("删除成功!\n");
}


//按值删除
void deleteNode_z(struct ListNode* head, int value){
    if(head == NULL){
        printf("删除失败：传入的结点不存在！\n");
    }

    while (head->next->element != value){
        head = head->next;
        if(head->next == NULL){
            printf("删除的元素不在该单链表中！\n");
            return;
        }
    }
    struct ListNode* temp = head->next;
    head->next = head->next->next;
    free(temp);
    printf("删除成功!\n");
}

/**************************  显示打印操作  ******************************/
//打印
void printfList(struct ListNode* head){
    int index = 1;
    struct ListNode* L = head->next;
    while(L != NULL){
        printf("第%d个节点上的数据为%d\n",index, L->element);
        index ++;
        L = L->next;
    }
}

/**************************  集合问题操作  ******************************/
//集合做差：LA - LB
void set_deviation(struct ListNode* LA, struct ListNode* LB){
    struct ListNode* La = LA;
    while (La->next != NULL){
        struct ListNode* temp = La->next;
        int Adata = La->next->element;
        int flag=0;
        struct ListNode* Lb =LB;

        while (Lb->next != NULL){
            if(Lb->next->element == Adata){
                flag = 1;
                break;
            }
            Lb = Lb->next;
        }
        if(flag == 1){
            La->next = La->next->next;
            free(temp);
            continue;
        }
        La = La->next;
    }
}

//集合做并集
void set_union(struct ListNode* LA, struct ListNode* LB, struct ListNode* LC){
    while (LA->next != NULL){
        int Adata = LA->next->element;
        int flag = 0;

        struct ListNode* Lb = LB;
        while (Lb->next != NULL){
            if(Lb->next->element == Adata){
                flag = 1;
                break;
            }
            Lb = Lb->next;
        }

        if(flag==0){
            struct ListNode* NewNode = malloc(sizeof(struct ListNode));
            NewNode->element = LA->next->element;
            NewNode->next = NULL;
            LC->next = NewNode;
            LC = LC->next;
        }
        LA = LA->next;
    }

    while(LB->next != NULL){
        struct ListNode* NewNode = malloc(sizeof(struct ListNode));
        NewNode->element = LB->next->element;
        NewNode->next = NULL;
        LC->next = NewNode;
        LC = LC->next;
        LB = LB->next;
    }

}

//集合做交集
void set_intersection(struct ListNode* LA, struct ListNode* LB, struct ListNode* LC){
    while (LA->next != NULL){
        int Adata = LA->next->element;
        int flag = 0;

        struct ListNode* Lb = LB;
        while (Lb->next != NULL){
            if(Lb->next->element == Adata){
                flag = 1;
                break;
            }
            Lb = Lb->next;
        }

        if(flag==1){
            struct ListNode* NewNode = malloc(sizeof(struct ListNode));
            NewNode->element = LA->next->element;
            NewNode->next = NULL;
            LC->next = NewNode;
            LC = LC->next;
        }
        LA = LA->next;
    }
}

int main(){
    //创建头节点
    struct ListNode head;
    //初始化
    initList(&head);

    //头插入数据
    printf("********头插入数据*********\n");
    while (1){
        int value;
        printf("请输入需要插入单链表Lhead的数值（输入666则退出）：");
        scanf("%d",&value);
        if(value == 666){
            break;
        }
        insertNode_t(&head, value);
    }
    printfList(&head);

    //尾插入数据
    printf("\n********尾插入数据*********\n");
    while (1){
        int value;
        printf("请输入需要插入单链表Lhead的数值（输入666则退出）：");
        scanf("%d",&value);
        if(value == 666){
            break;
        }
        insertNode_w(&head, value);
    }
    printfList(&head);

    //定位后插法
    printf("\n********定位后插法*********\n");
    int index_1;
    int value_1;
    printf("请输入需要插入的位置：");
    scanf("%d",&index_1);
    printf("请输入需要插入单链表Lhead的数值：");
    scanf("%d",&value_1);
    insertNode_dh(&head, index_1, value_1);
    printfList(&head);

    //按值查询数据的位置
    printf("\n********按值查询数据的位置*********\n");
    int value_2;
    printf("请输入需要查询的数值：");
    scanf("%d",&value_2);
    findNode_z(&head, value_2);

    //按位置查找数据
    printf("\n********按位置查找数据*********\n");
    int value_3;
    printf("请输入需要查询的位置：");
    scanf("%d",&value_3);
    findNode_v(&head, value_3);

    //按位置删除元素
    printf("\n********按位置删除数据*********\n");
    int value_4;
    printf("请输入需要删除的位置：");
    scanf("%d",&value_4);
    deleteNode_w(&head, value_4);
    printfList(&head);

    //按值删除元素
    printf("\n********按值删除数据*********\n");
    int value_5;
    printf("请输入需要删除的数值：");
    scanf("%d",&value_5);
    deleteNode_z(&head, value_5);
    printfList(&head);

    //集合操作
    printf("\n********集合差操作*********\n");
    //创建头节点
    struct ListNode LA;
    struct ListNode LB;
    struct ListNode LC;
    //初始化
    initList(&LA);
    initList(&LB);
    initList(&LC);
    printf("LA的单链表：\n");
    while (1){
        int value;
        printf("请输入需要插入单链表LA的数据（输入666则结束）：");
        scanf("%d",&value);
        if(value == 666){
            break;
        }
        insertNode_w(&LA,value);
    }
    printfList(&LA);
    printf("\n");


    printf("LB的单链表：\n");
    while (1){
        int value;
        printf("请输入需要插入单链表LB的数据（输入666则结束）：");
        scanf("%d",&value);
        if(value == 666){
            break;
        }
        insertNode_w(&LB,value);
    }
    printfList(&LB);
    printf("\n");


    //集合做差
    printf("集合做差的结果：\n");
    set_deviation(&LA, &LB);
    printfList(&LA);


    //集合做并集
    printf("集合做并集的结果：\n");
    set_union(&LA,&LB,&LC);
    printfList(&LC);


    //集合做交集
    printf("集合做交集的结果：\n");
    set_intersection(&LA,&LB,&LC);
    printfList(&LC);
}

运行结果

********头插入数据*********
请输入需要插入单链表Lhead的数值（输入666则退出）：11
请输入需要插入单链表Lhead的数值（输入666则退出）：22
请输入需要插入单链表Lhead的数值（输入666则退出）：33
请输入需要插入单链表Lhead的数值（输入666则退出）：44
请输入需要插入单链表Lhead的数值（输入666则退出）：55
请输入需要插入单链表Lhead的数值（输入666则退出）：666
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为11

********尾插入数据*********
请输入需要插入单链表Lhead的数值（输入666则退出）：100
请输入需要插入单链表Lhead的数值（输入666则退出）：666
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为11
第6个节点上的数据为100

********定位前插法*********
请输入需要插入的位置：1
请输入需要插入单链表Lhead的数值：200
第1个节点上的数据为200
第2个节点上的数据为55
第3个节点上的数据为44
第4个节点上的数据为33
第5个节点上的数据为22
第6个节点上的数据为11
第7个节点上的数据为100

********按值查询数据的位置*********
请输入需要查询的数值：22
查找成功：数字22在第 5 位

********按位置查找数据*********
请输入需要查询的位置：3
查找成功：第3位的数字为 44

********按位置删除数据*********
请输入需要删除的位置：1
删除成功!
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为11
第6个节点上的数据为100

********按值删除数据*********
请输入需要删除的数值：11
删除成功!
第1个节点上的数据为55
第2个节点上的数据为44
第3个节点上的数据为33
第4个节点上的数据为22
第5个节点上的数据为100

********集合差操作*********
LA的单链表：
请输入需要插入单链表LA的数据（输入666则结束）：1
请输入需要插入单链表LA的数据（输入666则结束）：2
请输入需要插入单链表LA的数据（输入666则结束）：3
请输入需要插入单链表LA的数据（输入666则结束）：4
请输入需要插入单链表LA的数据（输入666则结束）：5
请输入需要插入单链表LA的数据（输入666则结束）：6
请输入需要插入单链表LA的数据（输入666则结束）：7
请输入需要插入单链表LA的数据（输入666则结束）：666
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7

LB的单链表：
请输入需要插入单链表LB的数据（输入666则结束）：10
请输入需要插入单链表LB的数据（输入666则结束）：20
请输入需要插入单链表LB的数
据（输入666则结束）：30
请输入需要插入单链表LB的数据（输入666则结束）：40
请输入需要插入单链表LB的数据（输入666则结束）：50
请输入需要插入单链表LB的数据（输入666则结束）：666
第1个节点上的数据为10
第2个节点上的数据为20
第3个节点上的数据为30
第4个节点上的数据为40
第5个节点上的数据为50

集合做差的结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7

集合做并集的结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为10
第9个节点上的数据为20
第10个节点上的数据为30
第11个节点上的数据为40
第12个节点上的数据为50

集合做交集的结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为10
第9个节点上的数据为20
第10个节点上的数据为30
第11个节点上的数据为40
第12个节点上的数据为50

进程已结束，退出代码为 0

作业二（循环单链表）

两个循环单链表的合并

代码

#include 
#include 


//定义结构体类型
struct ListNode{
    int element;
    struct ListNode * next;
};

//初始化结构体
void initList(struct ListNode * head){
    head->next = head;
}

//插入新结点操作,尾插法
void insertNode_w(struct ListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }

    struct ListNode* cur = head;
    while(cur->next != head){
        cur = cur->next;
    }

    struct ListNode* NewNode =  malloc(sizeof(struct ListNode));
    NewNode->next = head;
    NewNode->element = value;
    cur->next = NewNode;
}

//打印
void printfList(struct ListNode* head){
    int index = 1;
    struct ListNode* L = head->next;
    while(L != head){
        printf("第%d个节点上的数据为%d\n",index, L->element);
        index ++;
        L = L->next;
    }
}

//合并
void merge(struct ListNode* LA, struct ListNode* LB){
    struct ListNode* L1 = LA;

    while (L1->next != LA ){
        L1 = L1->next;
    }

    L1->next = LB->next;
    while (L1->next != LB){
        L1 = L1->next;
    }
    L1->next = LA;
}


int main() {
    //创建头节点
    struct ListNode LA;
    struct ListNode LB;
    //初始化
    initList(&LA);
    initList(&LB);

    //头插入数据
    printf("********头插入数据*********\n");
    for(int i=1; i < 10; i++){
        insertNode_w(&LA, i);
    }
    printf("LA的链表是：\n");
    printfList(&LA);


    for(int i=1; i < 10; i++){
        insertNode_w(&LB, i*10);
    }
    printf("LB的链表是：\n");
    printfList(&LB);

    printf("合并结果：\n");
    merge(&LA, &LB);
    printfList(&LA);
}

运行结果

********头插入数据*********
LA的链表是：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为8
第9个节点上的数据为9
LB的链表是：
第1个节点上的数据为10
第2个节点上的数据为20
第3个节点上的数据为30
第4个节点上的数据为40
第5个节点上的数据为50
第6个节点上的数据为60
第7个节点上的数据为70
第8个节点上的数据为80
第9个节点上的数据为90
合并结果：
第1个节点上的数据为1
第2个节点上的数据为2
第3个节点上的数据为3
第4个节点上的数据为4
第5个节点上的数据为5
第6个节点上的数据为6
第7个节点上的数据为7
第8个节点上的数据为8
第9个节点上的数据为9
第10个节点上的数据为10
第11个节点上的数据为20
第12个节点上的数据为30
第13个节点上的数据为40
第14个节点上的数据为50
第15个节点上的数据为60
第16个节点上的数据为70
第17个节点上的数据为80
第18个节点上的数据为90

作业三（多项式相加）

单链表实现两个多项式相加，并输出为第一个多项式相加减后的结果

代码

#include 
#include 

//定义结构体
struct Polynode{
    int coef;
    int exp;
    struct Polynode * next;
};

//初始化结构体
void initList(struct Polynode * poly){
    poly->next = NULL;
}

//输入
void insertNode(struct Polynode * poly){
    struct Polynode* p = poly;

    while (1){
        int c,e;
        printf("请输入多项式的系数和指数：");
        scanf("%d %d",&c,&e);
        if(c == 0){
            return;
        }
        struct Polynode* NewNode = malloc(sizeof(struct Polynode));
        NewNode->coef = c;
        NewNode->exp = e;
        NewNode->next = NULL;
        p->next = NewNode;
        p = p->next;
    }
}

//两个多项式相加
void addpoly(struct Polynode * polynomial_1, struct Polynode * polynomial_2){
    //第一次循环，找到第一个多项式与第二个多项式中有相同指数的项，并进行系数相加，操作结果改变在第一个多项式链表中
    struct Polynode * p_1 = polynomial_1;
    while (p_1->next != NULL){
        struct Polynode * p_2 = polynomial_2;
        while (p_2->next != NULL){
            if(p_1->next->exp == p_2->next->exp){
                p_1->next->coef = p_1->next->coef + p_2->next->coef;
                break;
            }
            p_2 = p_2->next;
        }
        p_1 = p_1->next;
    }

    //第二次循环，找出第二个多项式与第一个多项式中有不同指数的项，并将该项的指数和系数保存到第一个多项式链表的最后，利用尾插法
    struct Polynode * p_2_again = polynomial_2;
    while (p_2_again->next != NULL){
        int flag = 1;

        struct Polynode * p_1_again = polynomial_1;
        while (p_1_again->next != NULL){
            if(p_2_again->next->exp == p_1_again->next->exp){
                flag = 0;
            }
            p_1_again = p_1_again->next;
        }
        if(flag == 1){
            struct Polynode* NewNode = malloc(sizeof(struct Polynode));
            NewNode->coef = p_2_again->next->coef;
            NewNode->exp = p_2_again->next->exp;
            NewNode->next = NULL;
            p_1_again->next = NewNode;
        }
        p_2_again = p_2_again->next;
    }

}

//整理多项式
void tidypoly(struct Polynode * poly_1, struct Polynode * poly_2){
    struct Polynode* p1 = poly_1;

    while (p1->next != NULL){
        //如果系数为0 就跳过这次循环
        if(p1->next->coef == 0){
            p1 = p1->next;
            continue;
        }

        struct Polynode* p2 = poly_2;
        int flag = 0;
        //头插法，指数大小不是最大
        while (p2->next != NULL){
            if(p1->next->exp < p2->next->exp){
                struct Polynode* NewNode = malloc(sizeof(struct Polynode));
                NewNode->coef = p1->next->coef;
                NewNode->exp = p1->next->exp;

                NewNode->next = p2->next;
                p2->next = NewNode;
                flag = 1;
                break;
            }
            p2 = p2->next;
        }

        if(flag == 1){
            p1 = p1->next;
            continue;
        }

        //尾插法，如果链表中没有节点 或者 比较之后指数最大，都应该排最后
        struct Polynode* NewNode = malloc(sizeof(struct Polynode));
        NewNode->coef = p1->next->coef;
        NewNode->exp = p1->next->exp;
        NewNode->next = NULL;
        p2->next = NewNode;

        p1 = p1->next;
    }
}

//打印
void printfList(struct Polynode* poly){
    int index = 1;
    struct Polynode* p = poly;
    while(p->next != NULL){

        printf("第%d项的系数是 %d 指数是 %d\n",index, p->next->coef, p->next->exp);

        index ++;
        p = p->next;
    }
}

int main(){
    //创建头节点
    struct Polynode polynomial_1;
    struct Polynode polynomial_2;
    struct Polynode polynomial_3;

    //初始化
    initList(&polynomial_1);
    initList(&polynomial_2);
    initList(&polynomial_3);

    //插入数据（尾插法）
    printf("\n*************输入第一个多项式*************\n");
    insertNode(&polynomial_1);

    printf("\n*************输入第二个多项式*************\n");
    insertNode(&polynomial_2);


    //打印
    printf("\n*************输出第一个多项式*************\n");
    printfList(&polynomial_1);
    printf("\n*************输出第二个多项式*************\n");
    printfList(&polynomial_2);

    //多项式相加
    printf("\n*************两个多项式相加结果*************\n");
    addpoly(&polynomial_1,&polynomial_2);
    printfList(&polynomial_1);

    printf("\n*************整理后结果*************\n");
    tidypoly(&polynomial_1,&polynomial_3);
    printfList(&polynomial_3);
}

运行结果

输入0 0是结束输入意思

*************输入第一个多项式*************
请输入多项式的系数和指数：2 3
请输入多项式的系数和指数：4 5
请输入多项式的系数和指数：6 6
请输入多项式的系数和指数：3 7
请输入多项式的系数和指数：0 0

*************输入第二个多项式*************
请输入多项式的系数和指数：2 6
请输入多项式的系数和指数：3 9
请输入多项式的系数和指数：6 1
请输入多项式的系数和指数：7 2
请输入多项式的系数和指数：8 1
请输入多项式的系数和指数：0 0

*************输出第一个多项式*************
第1项的系数是 2 指数是 3
第2项的系数是 4 指数是 5
第3项的系数是 6 指数是 6
第4项的系数是 3 指数是 7

*************输出第二个多项式*************
第1项的系数是 2 指数是 6
第2项的系数是 3 指数是 9
第3项的系数是 6 指数是 1
第4项的系数是 7 指数是 2
第5项的系数是 8 指数是 1

*************两个多项式相加结果*************
第1项的系数是 2 指数是 3
第2项的系数是 4 指数是 5
第3项的系数是 8 指数是 6
第4项的系数是 3 指数是 7
第5项的系数是 3 指数是 9
第6项的系数是 6 指数是 1
第7项的系数是 7 指数是 2

*************整理后结果*************
第1项的系数是 6 指数是 1
第2项的系数是 7 指数是 2
第3项的系数是 2 指数是 3
第4项的系数是 4 指数是 5
第5项的系数是 8 指数是 6
第6项的系数是 3 指数是 7
第7项的系数是 3 指数是 9

进程已结束，退出代码为 0

作业四（双链表）

双链表的创建，增加，查找，插入，删除操作

代码

#include 
#include 

//定义结构体类型
struct DListNode{
    int element;
    struct DListNode * prior;
    struct DListNode * next;
};

//初始化结构体
void initList(struct DListNode * head){
    head->prior = NULL;
    head->next = NULL;
}

/**************************  插入操作  ******************************/
//尾插法
void insertNode_w(struct DListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }
    struct DListNode* cur = head;
    while (cur->next != NULL){
        cur = cur->next;
    }
    struct DListNode* NewNode = malloc(sizeof(struct DListNode));
    if(NewNode){
        NewNode->element = value;
        NewNode->prior = cur;
        NewNode->next = NULL;

        cur->next = NewNode;
    }
}

//头插法
void insertNode_t(struct DListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }
    struct DListNode* cur = head;
    struct DListNode* NewNode = malloc(sizeof(struct DListNode));
    if(NewNode){
        NewNode->element = value;
        NewNode->next = cur->next;
        NewNode->prior = cur;
        if(cur->next != NULL){
            cur->next->prior = NewNode;
        }
        cur->next = NewNode;
    }
}

//定位插入
void insertNode_d(struct DListNode* head, int index, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }
    struct DListNode* cur = head;

    int i = index;
    //找到前一个结点
    while (--index) {
        cur = cur->next;
        if (cur == NULL) {
            printf("\n插入失败：插入位置超出链表长度\n");
            return;
        }
    }
    struct DListNode* NewNode = malloc(sizeof(struct DListNode));
    NewNode->element = value;
    NewNode->next = cur->next;
    NewNode->prior = cur;
    if(cur->next != NULL){
        cur->next->prior = NewNode;
    }
    cur->next = NewNode;
    printf("%d 在第 %d 位插入成功！\n",value, i);
}

/**************************  查询操作  ******************************/
//按值查找
void find_value(struct DListNode* head, int value){
    int index = 1;
    struct DListNode* cur = head;
    while (cur->next != NULL){
        if(cur->next->element == value){
            printf("查找成功：%d 在第 %d 位\n", value, index);
            return;
        }
        index ++;
        cur = cur->next;
    }
    printf("查找失败：查找的值不在链表中\n");
}

//按位序查找
void find_index(struct DListNode* head, int index){
    if(index < 1){
        printf("查找失败：输入查找位序非法\n");
        return;
    }
    int flag = 1;
    struct DListNode* cur = head;
    while (cur->next != NULL){
        if(flag == index){
            printf("查找成功：第 %d 位的值是 %d \n", index, cur->next->element);
            return;
        }
        flag ++;
        cur = cur->next;
    }
    printf("查找失败：查找的位序超过链表长度\n");
}

/**************************  删除操作  ******************************/
//按位序删除
void del_index(struct DListNode* head, int index){
    if(index < 1){
        printf("删除失败：输入删除位序非法\n");
        return;
    }
    int flag = 1;
    struct DListNode* cur = head;
    while (cur->next != NULL){
        if(flag == index){
            int e = cur->next->element;
            struct DListNode* temp = cur->next;
            if(cur->next->next == NULL){
                cur->next = NULL;
                free(temp);
                printf("第 %d 位的 %d 被删除成功\n",index, e);
                return;
            }
            cur->next = cur->next->next;
            cur->next->prior = cur;
            free(temp);
            printf("第 %d 位的 %d 被删除成功\n",index, e);
            return;
        }
        flag ++;
        cur = cur->next;
    }
    printf("删除失败：删除的位序超过链表长度\n");
}

//按值删除
void del_value(struct DListNode* head, int value){
    int index = 1;
    struct DListNode* cur = head;
    while (cur->next){
        if(cur->next->element == value){
            struct DListNode* temp = cur->next;
            if(cur->next->next == NULL){
                cur->next = NULL;
                free(temp);
                printf("\n%d 在第 %d 位被删除成功\n",value, index);
                return;
            }
            cur->next = cur->next->next;
            cur->next->prior = cur;
            free(temp);
            printf("\n%d 在第 %d 位被删除成功\n",value, index);
            return;
        }
        index ++;
        cur = cur->next;
    }
    printf("删除失败：%d 不在链表中\n", value);
}


//打印输出
void printfList(struct DListNode* head){
    struct DListNode* L = head;
    printf("\n顺序打印：");
    while(L->next != NULL){
        printf("%d-->", L->next->element);
        L = L->next;
    }


    printf("\n逆序打印：");
    printf("%d-->",L->element);
    while(L->prior != head){
        printf("%d-->", L->prior->element);
        L = L->prior;
    }

}

int main(){
    //创建头节点
    struct DListNode head;
    //初始化
    initList(&head);

    //头插入数据
    printf("***************头插入数据***************\n");
    int value_1;
    printf("请输入需要插入的数据（输入0则退出）：");
    scanf("%d", &value_1);
    while (value_1 != 0){
        insertNode_t(&head, value_1);
        printf("请输入需要插入的数据（输入0则退出）：");
        scanf("%d", &value_1);
    }
    printf("\n-------头插结果-------");
    printfList(&head);

    //尾插入数据
    printf("\n\n***************尾插入数据***************\n");
    int value_2;
    printf("请输入需要插入的数据（输入0则退出）：");
    scanf("%d", &value_2);
    while (value_2 != 0){
        insertNode_w(&head, value_2);
        printf("请输入需要插入的数据（输入0则退出）：");
        scanf("%d", &value_2);
    }
    printf("\n-------尾插结果-------");
    printfList(&head);

    //定位插入数据
    printf("\n\n***************定位插入数据***************\n");
    int index_1, value_3;
    printf("请输入需要插入的位序和数据（输入0 0则退出）：");
    scanf("%d %d",&index_1, &value_3);
    while (value_3 != 0){
        insertNode_d(&head, index_1, value_3);
        printf("请输入需要插入的位序和数据（输入0 0则退出）：");
        scanf("%d %d",&index_1, &value_3);
    }
    printf("\n-------定位插入结果-------");
    printfList(&head);


    printf("\n\n***************按值查找操作***************\n");
    int value_4;
    printf("请输入需要查找的数据（输入0则退出）：");
    scanf("%d", &value_4);
    while (value_4 != 0){
        find_value(&head, value_4);
        printf("请输入需要查找的数据（输入0则退出）：");
        scanf("%d", &value_4);
    }

    printf("\n***************按位序查找操作***************\n");
    int index_2;
    printf("请输入需要查找的位序（输入0则退出）：");
    scanf("%d", &index_2);
    while (index_2 != 0){
        find_index(&head, index_2);
        printf("请输入需要查找的位序（输入0则退出）：");
        scanf("%d", &index_2);
    }

    printf("\n***************按位序删除操作***************\n");
    int index_3;
    printf("请输入需要删除的位序（输入0则退出）：");
    scanf("%d", &index_3);
    while (index_3 != 0){
        del_index(&head, index_3);
        printfList(&head);
        printf("\n请输入需要删除的位序（输入0则退出）：");
        scanf("%d", &index_3);
    }

    printf("\n***************按值删除操作***************\n");
    int value_5;
    printf("请输入需要删除的值（输入0则退出）：");
    scanf("%d", &value_5);
    while (value_5 != 0){
        del_value(&head, value_5);
        printfList(&head);
        printf("\n请输入需要删除的值（输入0则退出）：");
        scanf("%d", &value_5);
    }
}

运行结果

***************头插入数据***************
请输入需要插入的数据（输入0则退出）：10
请输入需要插入的数据（输入0则退出）：20
请输入需要插入的数据（输入0则退出）：30
请输入需要插入的数据（输入0则退出）：0

-------头插结果-------
顺序打印：30-->20-->10-->
逆序打印：10-->20-->30-->

***************尾插入数据***************
请输入需要插入的数据（输入0则退出）：1111
请输入需要插入的数据（输入0则退出）：0

-------尾插结果-------
顺序打印：30-->20-->10-->1111-->
逆序打印：1111-->10-->20-->30-->

***************定位插入数据***************
请输入需要插入的位序和数据（输入0 0则退出）：2 200
200 在第 2 位插入成功！
请输入需要插入的位序和数据（输入0 0则退出）：0 0

-------定位插入结果-------
顺序打印：30-->200-->20-->10-->1111-->
逆序打印：1111-->10-->20-->200-->30-->

***************按值查找操作***************
请输入需要查找的数据（输入0则退出）：20
查找成功：20 在第 3 位
请输入需要查找的数据（输入0则退出）：0

***************按位序查找操作***************
请输入需要查找的位序（输入0则退出）：4
查找成功：第 4 位的值是 10
请输入需要查找的位序（输入0则退出）：0

***************按位序删除操作***************
请输入需要删除的位序（输入0则退出）：1
第 1 位的 30 被删除成功

顺序打印：200-->20-->10-->1111-->
逆序打印：1111-->10-->20-->200-->
请输入需要删除的位序（输入0则退出）：0

***************按值删除操作***************
请输入需要删除的值（输入0则退出）：1111

1111 在第 4 位被删除成功

顺序打印：200-->20-->10-->
逆序打印：10-->20-->200-->
请输入需要删除的值（输入0则退出）：0

作业五（循环双链表合并）

循环双链表的合并

代码

#include 
#include 

//定义结构体类型
struct DListNode{
    int element;
    struct DListNode * prior;
    struct DListNode * next;
};

//初始化结构体
void initList(struct DListNode * head){
    head->prior = head;
    head->next = head;
}

//尾插法
void insertNode_w(struct DListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }

    struct DListNode* cur = head;
    while (cur->next != head){
        cur = cur->next;
    }

    struct DListNode* NewNode = malloc(sizeof(struct DListNode));
    if(NewNode){
        NewNode->element = value;

        NewNode->prior = cur;
        NewNode->next = head;

        cur->next = NewNode;
    }

}

//合并操作
void mergeDL(struct DListNode* LA, struct DListNode* LB){
    struct DListNode* lb = LB;
    while (lb->next != LB){
        struct DListNode* la = LA;
        int flag = 1;
        while (la->next != LA){
            if(la->next->element == lb->next->element){
                flag = 0;
            }
            la = la->next;
        }
        if(flag == 1){
            struct DListNode* NewNode = malloc(sizeof(struct DListNode));
            if(NewNode){
                NewNode->element = lb->next->element;
                NewNode->prior = la;
                NewNode->next = LA;
                la->next = NewNode;
            }
        }
        lb = lb->next;
    }

}

//打印输出
void printfList(struct DListNode* head){
    struct DListNode* L = head;
    printf("\n顺序打印：");
    while(L->next != head){
        printf("%d-->", L->next->element);
        L = L->next;
    }
    printf("\n逆序打印：");
    printf("%d-->",L->element);
    while(L->prior != head){
        printf("%d-->", L->prior->element);
        L = L->prior;
    }

}

int main(){
    //创建头节点
    struct DListNode LA;
    struct DListNode LB;

    //初始化
    initList(&LA);
    initList(&LB);

    //尾插入数据
    printf("\n***************LA尾插入数据***************\n");
    int value_1;
    printf("请输入需要插入的数据（输入0则退出）：");
    scanf("%d", &value_1);
    while (value_1 != 0){
        insertNode_w(&LA, value_1);
        printf("请输入需要插入的数据（输入0则退出）：");
        scanf("%d", &value_1);
    }
    printf("\n-------LA尾插结果-------");
    printfList(&LA);

    //尾插入数据
    printf("\n***************LB尾插入数据***************\n");
    int value_2;
    printf("请输入需要插入的数据（输入0则退出）：");
    scanf("%d", &value_2);
    while (value_2 != 0){
        insertNode_w(&LB, value_2);
        printf("请输入需要插入的数据（输入0则退出）：");
        scanf("%d", &value_2);
    }
    printf("\n-------LB尾插结果-------");
    printfList(&LB);

    //合并操作
    printf("\n\n***************合并操作结果***************\n");
    mergeDL(&LA,&LB);
    printfList(&LA);

}

运行结果

***************LA尾插入数据***************
请输入需要插入的数据（输入0则退出）：10
请输入需要插入的数据（输入0则退出）：20
请输入需要插入的数据（输入0则退出）：30
请输入需要插入的数据（输入0则退出）：40
请输入需要插入的数据（输入0则退出）：0

-------LA尾插结果-------
顺序打印：10-->20-->30-->40-->
逆序打印：40-->30-->20-->10-->
***************LB尾插入数据***************
请输入需要插入的数据（输入0则退出）：11
请输入需要插入的数据（输入0则退出）：22
请输入需要插入的数据（输入0则退出）：33
请输入需要插入的数据（输入0则退出）：44
请输入需要插入的数据（输入0则退出）：0

-------LB尾插结果-------
顺序打印：11-->22-->33-->44-->
逆序打印：44-->33-->22-->11-->

***************合并操作结果***************

顺序打印：10-->20-->30-->40-->11-->22-->33-->44-->
逆序打印：44-->33-->22-->11-->40-->30-->20-->10-->
进程已结束，退出代码为 0

作业六（循环双链表）

循环双链表的创建，增加，查找，插入，删除操作

代码

#include 
#include 

//定义结构体类型
struct DListNode{
    int element;
    struct DListNode * prior;
    struct DListNode * next;
};

//初始化结构体
void initList(struct DListNode * head){
    head->prior = head;
    head->next = head;
}

/**************************  插入操作  ******************************/
//尾插法
void insertNode_w(struct DListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }
    struct DListNode* cur = head;
    while (cur->next != head){
        cur = cur->next;
    }
    struct DListNode* NewNode = malloc(sizeof(struct DListNode));
    if(NewNode){
        NewNode->element = value;
        NewNode->prior = cur;
        NewNode->next = head;

        cur->next = NewNode;
        head->prior = NewNode;
    }
}

//头插法
void insertNode_t(struct DListNode* head, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }
    struct DListNode* cur = head;
    struct DListNode* NewNode = malloc(sizeof(struct DListNode));
    if(NewNode){
        NewNode->element = value;
        NewNode->next = cur->next;
        NewNode->prior = head;

        if(cur->next != head){
            cur->next->prior = NewNode;
        }
        cur->next = NewNode;
    }
}

//定位插入
void insertNode_d(struct DListNode* head, int index, int value){
    if(head==NULL){
        printf("没有头节点，插入数据失败");
        return;
    }
    struct DListNode* cur = head;

    int i = index;
    //找到前一个结点
    while (--index) {
        cur = cur->next;
        if (cur == head) {
            printf("\n插入失败：插入位置超出链表长度\n");
            return;
        }
    }
    struct DListNode* NewNode = malloc(sizeof(struct DListNode));
    NewNode->element = value;
    NewNode->next = cur->next;
    NewNode->prior = cur;
    if(cur->next != head){
        cur->next->prior = NewNode;
    }
    cur->next = NewNode;
    printf("%d 在第 %d 位插入成功！\n",value, i);
}

/**************************  查询操作  ******************************/
//按值查找
void find_value(struct DListNode* head, int value){
    int index = 1;
    struct DListNode* cur = head;
    while (cur->next != head){
        if(cur->next->element == value){
            printf("查找成功：%d 在第 %d 位\n", value, index);
            return;
        }
        index ++;
        cur = cur->next;
    }
    printf("查找失败：查找的值不在链表中\n");
}

//按位序查找
void find_index(struct DListNode* head, int index){
    if(index < 1){
        printf("查找失败：输入查找位序非法\n");
        return;
    }
    int flag = 1;
    struct DListNode* cur = head;
    while (cur->next != head){
        if(flag == index){
            printf("查找成功：第 %d 位的值是 %d \n", index, cur->next->element);
            return;
        }
        flag ++;
        cur = cur->next;
    }
    printf("查找失败：查找的位序超过链表长度\n");
}

/**************************  删除操作  ******************************/
//按位序删除
void del_index(struct DListNode* head, int index){
    if(index < 1){
        printf("删除失败：输入删除位序非法\n");
        return;
    }
    int flag = 1;
    struct DListNode* cur = head;
    while (cur->next != head){
        if(flag == index){
            int e = cur->next->element;
            struct DListNode* temp = cur->next;
            if(cur->next->next == head){
                cur->next = head;
                free(temp);
                printf("第 %d 位的 %d 被删除成功\n",index, e);
                return;
            }
            cur->next = cur->next->next;
            cur->next->prior = cur;
            free(temp);
            printf("第 %d 位的 %d 被删除成功\n",index, e);
            return;
        }
        flag ++;
        cur = cur->next;
    }
    printf("删除失败：删除的位序超过链表长度\n");
}

//按值删除
void del_value(struct DListNode* head, int value){
    int index = 1;
    struct DListNode* cur = head;
    while (cur->next != head){
        if(cur->next->element == value){
            struct DListNode* temp = cur->next;
            if(cur->next->next == head){
                cur->next = head;
                free(temp);
                printf("\n%d 在第 %d 位被删除成功\n",value, index);
                return;
            }
            cur->next = cur->next->next;
            cur->next->prior = cur;
            free(temp);
            printf("\n%d 在第 %d 位被删除成功\n",value, index);
            return;
        }
        index ++;
        cur = cur->next;
    }
    printf("删除失败：%d 不在链表中\n", value);
}

//打印输出
void printfList(struct DListNode* head){
    struct DListNode* L = head;
    printf("\n顺序打印：");
    while(L->next != head){
        printf("%d-->", L->next->element);
        L = L->next;
    }

    printf("\n逆序打印：");
    printf("%d-->",L->element);
    while(L->prior != head){
        printf("%d-->", L->prior->element);
        L = L->prior;
    }
}

int main(){
    //创建头节点
    struct DListNode head;
    //初始化
    initList(&head);

    //头插入数据
    printf("***************头插入数据***************\n");
    int value_1;
    printf("请输入需要插入的数据（输入0则退出）：");
    scanf("%d", &value_1);
    while (value_1 != 0){
        insertNode_t(&head, value_1);
        printf("请输入需要插入的数据（输入0则退出）：");
        scanf("%d", &value_1);
    }
    printf("\n-------头插结果-------");
    printfList(&head);

    //尾插入数据
    printf("\n\n***************尾插入数据***************\n");
    int value_2;
    printf("请输入需要插入的数据（输入0则退出）：");
    scanf("%d", &value_2);
    while (value_2 != 0){
        insertNode_w(&head, value_2);
        printf("请输入需要插入的数据（输入0则退出）：");
        scanf("%d", &value_2);
    }
    printf("\n-------尾插结果-------");
    printfList(&head);

    //定位插入数据
    printf("\n\n***************定位插入数据***************\n");
    int index_1, value_3;
    printf("请输入需要插入的位序和数据（输入0 0则退出）：");
    scanf("%d %d",&index_1, &value_3);
    while (value_3 != 0){
        insertNode_d(&head, index_1, value_3);
        printf("请输入需要插入的位序和数据（输入0 0则退出）：");
        scanf("%d %d",&index_1, &value_3);
    }
    printf("\n-------定位插入结果-------");
    printfList(&head);


    printf("\n\n***************按值查找操作***************\n");
    int value_4;
    printf("请输入需要查找的数据（输入0则退出）：");
    scanf("%d", &value_4);
    while (value_4 != 0){
        find_value(&head, value_4);
        printf("请输入需要查找的数据（输入0则退出）：");
        scanf("%d", &value_4);
    }

    printf("\n\n***************按位序查找操作***************\n");
    int value_5;
    printf("请输入需要查找的位序（输入0则退出）：");
    scanf("%d", &value_5);
    while (value_5 != 0){
        find_index(&head, value_5);
        printf("请输入需要查找的位序（输入0则退出）：");
        scanf("%d", &value_5);
    }


    printf("\n***************按位序删除操作***************\n");
    int index_3;
    printf("请输入需要删除的位序（输入0则退出）：");
    scanf("%d", &index_3);
    while (index_3 != 0){
        del_index(&head, index_3);
        printfList(&head);
        printf("\n请输入需要删除的位序（输入0则退出）：");
        scanf("%d", &index_3);
    }

    printf("\n***************按值删除操作***************\n");
    int value_6;
    printf("请输入需要删除的值（输入0则退出）：");
    scanf("%d", &value_6);
    while (value_6 != 0){
        del_value(&head, value_6);
        printfList(&head);
        printf("\n请输入需要删除的值（输入0则退出）：");
        scanf("%d", &value_6);
    }
}

运行结果

***************头插入数据***************
请输入需要插入的数据（输入0则退出）：12
请输入需要插入的数据（输入0则退出）：23
请输入需要插入的数据（输入0则退出）：34
请输入需要插入的数据（输入0则退出）：45
请输入需要插入的数据（输入0则退出）：0

-------头插结果-------
顺序打印：45-->34-->23-->12-->
逆序打印：12-->23-->34-->45-->

***************尾插入数据***************
请输入需要插入的数据（输入0则退出）：900
请输入需要插入的数据（输入0则退出）：0

-------尾插结果-------
顺序打印：45-->34-->23-->12-->900-->
逆序打印：900-->12-->23-->34-->45-->

***************定位插入数据***************
请输入需要插入的位序和数据（输入0 0则退出）：1 600
600 在第 1 位插入成功！
请输入需要插入的位序和数据（输入0 0则退出）：0 0

-------定位插入结果-------
顺序打印：600-->45-->34-->23-->12-->900-->
逆序打印：900-->12-->23-->34-->45-->600-->

***************按值查找操作***************
请输入需要查找的数据（输入0则退出）：23
查找成功：23 在第 4 位
请输入需要查找的数据（输入0则退出）：0


***************按位序查找操作***************
请输入需要查找的位序（输入0则退出）：2
查找成功：第 2 位的值是 45
请输入需要查找的位序（输入0则退出）：0

***************按位序删除操作***************
请输入需要删除的位序（输入0则退出）：1
第 1 位的 600 被删除成功

顺序打印：45-->34-->23-->12-->900-->
逆序打印：900-->12-->23-->34-->45-->
请输入需要删除的位序（输入0则退出）：0

***************按值删除操作***************
请输入需要删除的值（输入0则退出）：12

12 在第 4 位被删除成功

顺序打印：45-->34-->23-->900-->
逆序打印：900-->23-->34-->45-->
请输入需要删除的值（输入0则退出）：0