数据结构编程练习（单链表）

已于 2022-02-19 11:57:46 修改
阅读量2.1k 收藏 29
点赞数 4
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 c语言
于 2022-02-15 09:28:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43686863/article/details/122936126
版权

文章目录


在这里插入图片描述

1.基于链表的两个递增有序序列的合并

描述：给定两个递增整数序列A和B，利用链表表示序列A和B，将A和B合并为一个递增的有序序列C，序列C不允许有重复数据。要求空间复杂度为 O ( 1 ) O(1) O(1)。

输入样例：
5 5
1 3 5 7 9
2 4 6 8 10
3 4
1 5 9
1 2 5 9
0 0

输出样例：
1 2 3 4 5 6 7 8 9 10
1 2 5 9

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_show(LinkList L);

void list_free(LinkList L);

void list_merge(LinkList src1, LinkList src2, LinkList dest);

int main() {
    int m, n, x;
    while (scanf("%d %d", &m, &n)) {
        if (m == 0 && n == 0) {
            break;
        }
        /*初始化*/
        LinkList A = list_init(), B = list_init(), C = list_init();
        /*读取数据*/
        for (int i = 0; i < m; i++) {
            scanf("%d", &x);
            list_insert(x, A);
        }
        for (int i = 0; i < n; i++) {
            scanf("%d", &x);
            list_insert(x, B);
        }
        /*合并*/
        list_merge(A, B, C);
        /*输出结果*/
        list_show(C);
        /*释放已分配的内存*/
        list_free(A);
        list_free(B);
        list_free(C);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *p = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next != NULL) {
        tail = tail->next;
    }
    tail->next = p;
    p->data = e;
    p->next = NULL;
}

void list_show(LinkList L) {
    LNode *p = L->next;
    while (p != NULL) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_free(LinkList L) {
    LNode *p;
    while (L != NULL) {
        p = L;
        L = L->next;
        free(p);
    }
}

void list_merge(LinkList src1, LinkList src2, LinkList dest) {
    LNode *p = src1->next, *q = src2->next, *r = dest;
    while (p != NULL && q != NULL) {
        /*创建新结点*/
        LNode *t = (LNode *) malloc(sizeof(LNode));
        t->next = NULL;
        if (p->data < q->data) {
            t->data = p->data;
            p = p->next;
        } else if (p->data > q->data) {
            t->data = q->data;
            q = q->next;
        } else {
            t->data = p->data;
            p = p->next;
            q = q->next;
        }
        /*链接新结点*/
        r->next = t;
        r = t;
    }
    while (p != NULL) {
        LNode *t = (LNode *) malloc(sizeof(LNode));
        t->next = NULL;
        t->data = p->data;
        p = p->next;

        r->next = t;
        r = t;
    }
    while (q != NULL) {
        LNode *t = (LNode *) malloc(sizeof(LNode));
        t->next = NULL;
        t->data = q->data;
        q = q->next;

        r->next = t;
        r = t;
    }
}

2.基于链表的两个非递减有序序列的合并

描述：给定两个非递减的有序序列A和B，利用链表表示序列A和B，将A和B合并为一个非递增的有序序列C，序列C允许有重复的数据。要求空间复杂度为 O ( 1 ) O(1) O(1)。

输入样例：
5 5
1 3 5 7 9
2 4 6 8 10
5 6
1 2 2 3 5
2 4 6 8 10 12
0 0

输出样例：
10 9 8 7 6 5 4 3 2 1
12 10 8 6 5 4 3 2 2 2 1

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_show(LinkList L);

void list_free(LinkList L);

void list_merge(LinkList src1, LinkList src2, LinkList dest);

int main() {
    int m, n, x;
    while (scanf("%d %d", &m, &n)) {
        if (m == 0 && n == 0) {
            break;
        }
        /*初始化链表*/
        LinkList A = list_init(), B = list_init(), C = list_init();
        /*插入数据*/
        while (m--) {
            scanf("%d", &x);
            list_insert(x, A);
        }
        while (n--) {
            scanf("%d", &x);
            list_insert(x, B);
        }
        /*尾插法实现合并*/
        list_merge(A, B, C);
        /*输出数据*/
        list_show(C);
        /*释放空间*/
        list_free(A);
        list_free(B);
        list_free(C);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *tail = L;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    LNode *p = (LNode *) malloc(sizeof(LNode));
    p->data = e;
    p->next = NULL;
    tail->next = p;
}

void list_show(LinkList L) {
    LNode *p = L->next;
    while (p != NULL) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_free(LinkList L) {
    LNode *t;
    while (L != NULL) {
        t = L;
        L = L->next;
        free(t);
    }
}

void list_merge(LinkList src1, LinkList src2, LinkList dest) {
    LNode *p = src1->next, *q = src2->next, *r = dest;

    while (p != NULL && q != NULL) {
        /*创建新结点*/
        LNode *t = (LNode *) malloc(sizeof(LNode));
        if (p->data <= q->data) {
            t->data = p->data;
            p = p->next;
        } else {
            t->data = q->data;
            q = q->next;
        }
        /*头插法链接新结点*/
        t->next = r->next;
        r->next = t;
    }

    while (p != NULL) {
        LNode *t = (LNode *) malloc(sizeof(LNode));
        t->data = p->data;
        p = p->next;
        t->next = r->next;
        r->next = t;
    }
    while (q != NULL) {
        LNode *t = (LNode *) malloc(sizeof(LNode));
        t->data = q->data;
        q = q->next;
        t->next = r->next;
        r->next = t;
    }
}

3.基于链表的两个集合的交集

描述：给定两个递增的整数集合A和B，分别用链表表示A和B，求出A和B的交集，并存放在A中。要求空间复杂度为 O ( 1 ) O(1) O(1)。

输入样例：
5 5
1 3 5 7 9
1 2 3 4 5
3 4
1 2 5
2 4 5 6
0 0

输出样例：
1 3 5
2 5

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_show(LinkList L);

void list_free(LinkList L);

void list_union(LinkList dest, LinkList src);

int main() {
    int m, n, x;
    while (scanf("%d %d", &m, &n)) {
        if (m == 0 && n == 0) {
            break;
        }
        /*链表初始化*/
        LinkList A = list_init(), B = list_init();
        /*插入数据*/
        while (m--) {
            scanf("%d", &x);
            list_insert(x, A);
        }
        while (n--) {
            scanf("%d", &x);
            list_insert(x, B);
        }
        /*合并*/
        list_union(A, B);
        /*输出数据*/
        list_show(A);
        /*释放内存*/
        list_free(A);
        list_free(B);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *tail = L;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    LNode *p = (LNode *) malloc(sizeof(LNode));
    p->data = e;
    p->next = NULL;

    tail->next = p;
}

void list_show(LinkList L) {
    LNode *p = L->next;
    while (p != NULL) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_free(LinkList L) {
    LNode *t;
    while (L != NULL) {
        t = L;
        L = L->next;
        free(t);
    }
}

void list_union(LinkList A, LinkList B) {
    LNode *p = A->next, *q = B->next;
    LNode *prior = A;/*p结点的前驱*/

    while (p != NULL && q != NULL) {
        if (p->data > q->data) {
            q = q->next;
        } else if (p->data < q->data) {
            prior->next = p->next;
            free(p);
            p = prior->next;
        } else {
            prior = p;
            p = p->next;
            q = q->next;
        }
    }

    if (p != NULL) {
        prior->next = NULL;
        list_free(p);
    }
}

4.基于链表的两个集合差集

描述：给定两个递增的整数集合，分别用链表A和B表示，求出A和B的差集（即由仅在A中出现而不在B中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合的元素个数。要求空间复杂度为 O ( 1 ) O(1) O(1)。

输入样例：
5 5
1 3 5 7 9
1 2 3 4 5
3 4
1 2 6
2 4 5 7
0 0

输出样例：
7 9
2
1 6
2

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_show(LinkList L);

void list_destroy(LinkList *address_head);

int list_difference(LinkList A, LinkList B, LinkList C);

int main() {
    int m, n, x, count;
    while (scanf("%d %d", &m, &n)) {
        if (m == 0 && n == 0) {
            break;
        }
        /*初始化链表*/
        LinkList A = list_init(), B = list_init(), C = list_init();
        /*插入数据*/
        while (m--) {
            scanf("%d", &x);
            list_insert(x, A);
        }
        while (n--) {
            scanf("%d", &x);
            list_insert(x, B);
        }
        /*求A-B*/
        count = list_difference(A, B, C);
        /*输出数据*/
        list_show(C);
        printf("%c%d", 10, count);
        /*释放内存*/
        list_destroy(&A);
        list_destroy(&B);
        list_destroy(&C);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->next = NULL;
    L->data = 0;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *tail = L;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    LNode *p = (LNode *) malloc(sizeof(LNode));
    p->data = e;
    p->next = NULL;

    tail->next = p;
}

void list_show(LinkList L) {
    LNode *p = L->next;
    while (p != NULL) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_destroy(LinkList *address_head) {
    LNode *head = *address_head, *tmp;
    *address_head = NULL;
    while (head != NULL) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

int list_difference(LinkList A, LinkList B, LinkList C) {
    LNode *p = A->next, *q = B->next, *r = C;
    int count = 0;

    while (p != NULL && q != NULL) {
        if (p->data == q->data) {
            p = p->next;
            q = q->next;
        } else if (p->data < q->data) {
            list_insert(p->data, C);
            count++;
            p = p->next;
        } else {
            q = q->next;
        }
    }

    while (p != NULL) {
        list_insert(p->data, C);
        count++;
        p = p->next;
    }

    return count;
}

5.查找链表中的最大值

描述：利用单链表表示一个整数序列，通过一趟遍历在单链表中确定值最大的结点。

输入样例：
5
2 1 3 5 4
6
2 3 10 4 5 1
4
-1 -2 -3 -4
0

输出样例：
5
10
-1

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_destroy(LinkList *address_head);

int list_max(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m)) {
        if (m == 0) {
            break;
        }
        /*初始化链表*/
        LinkList A = list_init();
        /*插入数据*/
        while (m--) {
            scanf("%d", &x);
            list_insert(x, A);
        }
        /*输出最大值*/
        printf("%c%d", 10, list_max(A));
        /*销毁链表*/
        list_destroy(&A);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *tail = L;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    LNode *p = (LNode *) malloc(sizeof(LNode));
    p->data = e;
    p->next = NULL;

    tail->next = p;
}

void list_destroy(LinkList *address_head) {
    LNode *head = *address_head, *tmp;
    *address_head = NULL;
    while (head != NULL) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

int list_max(LinkList L) {
    LNode *p = L->next;
    int max = p->data;

    while (p != NULL) {
        if (p->data > max) {
            max = p->data;
        }
        p = p->next;
    }

    return max;
}

6.链表的逆转

描述：利用单链表表示一个整数序列，通过一趟遍历，将单链表中所有结点的链接方向逆转。要求空间复杂度为 O ( 1 ) O(1) O(1)。

输入样例：
5
1 2 3 4 5
6
3 1 2 5 4 6
0

输出样例：
5 4 3 2 1
6 4 5 2 1 3

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_show(LinkList L);

void list_destroy(LinkList *address_head);

void list_invert(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m)) {
        if (m == 0) {
            break;
        }
        /*链表初始化*/
        LinkList L = list_init();
        /*插入数据*/
        while (m--) {
            scanf("%d", &x);
            list_insert(x, L);
        }
        /*逆置*/
        list_invert(L);
        /*输出数据*/
        list_show(L);
        /*释放内存*/
        list_destroy(&L);
    }
}

LinkList list_init() {
    LinkList L = (LNode *) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *tail = L;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    LNode *p = (LNode *) malloc(sizeof(LNode));
    p->data = e;
    p->next = NULL;

    tail->next = p;
}

void list_show(LinkList L) {
    LNode *p = L->next;
    while (p != NULL) {
        printf("%c%d", (L->next == p) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_destroy(LinkList *address_head) {
    LNode *head = *address_head, *tmp;
    *address_head = NULL;
    while (head != NULL) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

void list_invert(LinkList L) {
    LNode *p = L->next, *t;
    L->next = NULL;
    while (p != NULL) {
        t = p->next;
        p->next = L->next;
        L->next = p;
        p = t;
    }
}

7.删除链表中满足区间值的结点

描述：利用单链表表示一个递增的整数序列，删除链表中值大于等于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同）。

输入样例：
5
1 2 3 4 5
2 4
6
2 4 6 8 10 12
3 5
0

输出样例：
1 5
2 6 8 10 12

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_show(LinkList L);

void list_destroy(LinkList *address_head);

void list_filter(int mink, int maxk, LinkList L);

int main() {
    int m, x, mink, maxk;
    while (scanf("%d", &m)) {
        if (m == 0) {
            break;
        }
        /*初始化头结点*/
        LinkList L = list_init();
        /*插入数据*/
        while (m--) {
            scanf("%d", &x);
            list_insert(x, L);
        }
        scanf("%d %d", &mink, &maxk);
        /*对数据进行过滤*/
        list_filter(mink, maxk, L);
        /*输出单链表*/
        list_show(L);
        /*释放内存*/
        list_destroy(&L);
    }
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *tail = L;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    LNode *p = (LNode *) malloc(sizeof(LNode));
    p->data = e;
    p->next = NULL;

    tail->next = p;
}

void list_show(LinkList L) {
    LNode *p = L->next;
    while (p != NULL) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_destroy(LinkList *address_head) {
    LNode *head = *address_head, *tmp;
    *address_head = NULL;
    while (head != NULL) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

void list_filter(int mink, int maxk, LinkList L) {
    LNode *p = L->next, *prior = L;
    while (p != NULL) {
        if (p->data >= mink && p->data <= maxk) {
            prior->next = p->next;
            free(p);
            p = prior->next;
        } else {
            prior = p;
            p = p->next;
        }
    }
}

8.查找链表中倒数第k个结点

描述：利用单链表表示一个整数序列，请实现一个时间复杂度为 O ( n ) O(n) O(n)，空间复杂度为 O ( 1 ) O(1) O(1)的算法，通过一趟遍历在单链表中确定倒数第k个结点。

输入样例：
7
5 2 3 4 50 100 70
3
5
20 30 10 4 5
5
0

输出样例：
50
20

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

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

LinkList list_init();

void list_insert(int e, LinkList L);

void list_destroy(LinkList *address_head);

int list_find(int loc, LinkList L);

int main() {
    int m, x, k;

    while (scanf("%d", &m)) {
        if (m == 0) {
            break;
        }
        /*初始化*/
        LinkList L = list_init();
        /*插入数据*/
        while (m--) {
            scanf("%d", &x);
            list_insert(x, L);
        }
        scanf("%d", &k);
        /*查找结点*/
        list_find(k, L);
        /*释放内存*/
        list_destroy(&L);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(int e, LinkList L) {
    LNode *tail = L;
    while (tail->next != NULL) {
        tail = tail->next;
    }

    LNode *p = (LNode *) malloc(sizeof(LNode));
    p->data = e;
    p->next = NULL;

    tail->next = p;
}

void list_destroy(LinkList *address_head) {
    LNode *head = *address_head, *tmp;
    *address_head = NULL;
    while (head != NULL) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

int list_find(int loc, LinkList L) {
    LNode *p = L, *q = L;
    while (loc--) {
        q = q->next;
    }

    while (q != NULL) {
        p = p->next;
        q = q->next;
    }

    printf("%c%d", 10, p->data);
}

9.删除链表中倒数第k个结点

描述：利用单链表表示一个整数序列，请设计算法通过一趟遍历，删除链表中的倒数第k个结点。

输入样例：
7
5 2 3 4 50 100 70
3
5
20 30 10 4 5
5
1
1
1
0

输出样例：
5 2 3 4 100 70
30 10 4 5
empty

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

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

LinkList list_init();

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_delete(LinkList L, int position);

int main() {
    int m, x, k;
    while (scanf("%d", &m) && m != 0) {
        LinkList L = list_init();

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        scanf("%d", &k);
        list_delete(L, k);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next != NULL) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;
    while (head) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

void list_show(LinkList L) {
    LNode *p = L->next;

    if (!p) {
        printf("\nempty");
    } else {
        while (p) {
            printf("%c%d", (p == L->next) ? 10 : 32, p->data);
            p = p->next;
        }
    }
}

void list_delete(LinkList L, int position) {
    LNode *p = L, *q = L->next;

    while (position--) {
        q = q->next;
    }
    while (q) {
        p = p->next;
        q = q->next;
    }
    q = p->next;
    p->next = q->next;
    free(q);
}

10.交换链表中相邻的两个结点

描述：利用单链表表示一个整数序列，请设计算法在空间复杂度为 O ( 1 ) O(1) O(1)的前提下，两两交换其中相邻的结点。
说明：需要进行实际的结点交换，不可以仅改变结点内部的值。

输入样例：
4
1 2 3 4
5
5 2 6 3 6
5
2 7 1 4 1
1
2
0

输出样例：
2 1 4 3
2 5 3 6 6
7 2 4 1 1
2

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

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

LinkList list_init();

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_swap(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList L = list_init();

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        list_swap(L);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next != NULL) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;
    while (head) {
        tmp = head->next;
        free(head);
        head = tmp;
    }
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_swap(LinkList L) {
    LNode *p = L, *q = p->next;

    while (q) {
        if (q->next == NULL) {
            break;//the number of remaining nodes less than 2
        }

        p->next = q->next;
        q->next = q->next->next;
        p->next->next = q;

        p = p->next->next;
        q = p->next;
    }
}

11.基于链表的简单选择排序

描述：试以单链表为存储结构，实现简单选择排序。

输入样例：
5
4 5 3 2 9
6
1 3 5 7 9 2
0

输出样例：
2 3 4 5 9
1 2 3 5 7 9

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

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

void list_init(LinkList *L);

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_selection_sort(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList L = NULL;
        list_init(&L);

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        list_selection_sort(L);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

void list_init(LinkList *L) {
    *L = (LNode *) malloc(sizeof(LNode));

    (*L)->data = 0;
    (*L)->next = NULL;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;//avoid wild pointer
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_selection_sort(LinkList L) {
    LNode *p = L, *q, *tmp;
    LNode *min_prior_position;//min_prior_position->next->data == min_value

    while (p->next) {
        min_prior_position = p;
        q = p->next;
        /*find the minimum value*/
        while (q->next) {
            if (q->next->data < min_prior_position->next->data) {
                min_prior_position = q;
            }
            q = q->next;
        }
        /*swap*/
        if (min_prior_position != p) {
            if (p->next == min_prior_position) {//the values to be exchanged are adjacent
                p->next = min_prior_position->next;
                min_prior_position->next = min_prior_position->next->next;
                p->next->next = min_prior_position;
            } else {
                tmp = p->next->next;
                p->next->next = min_prior_position->next->next;
                min_prior_position->next->next = tmp;
                tmp = p->next;
                p->next = min_prior_position->next;
                min_prior_position->next = tmp;
            }
        }

        p = p->next;
    }
}

12.链表的分解

描述：利用单链表A表示一个非零整数序列，把A分解为两个具有相同结构的链表B和C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点。要求空间复杂度为 O ( 1 ) O(1) O(1)，链表B和C均利用链表A的结点空间。

输入样例：
7
3 -6 1 -2 4 -3 8
8
2 5 3 -1 -2 2 6 -1
0

输出样例：
-6 -2 -3
3 1 4 8
-1 -2 -1
2 5 3 2 6

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

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

LinkList list_init();

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_divide(LinkList src, LinkList positive, LinkList negative);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList A = list_init();
        LinkList B = list_init();
        LinkList C = list_init();

        while (m--) {
            scanf("%d", &x);
            list_insert(A, x);
        }
        list_divide(A, C, B);
        list_show(B);
        list_show(C);
        list_destroy(&A);
        list_destroy(&B);
        list_destroy(&C);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    if (L->next == NULL) {
        printf("\nempty");
    } else {
        while (p) {
            printf("%c%d", (p == L->next) ? 10 : 32, p->data);
            p = p->next;
        }
    }
}

void list_divide(LinkList src, LinkList positive, LinkList negative) {
    LNode *cursor = src->next;
    LNode *p_tail = positive, *n_tail = negative;

    while (cursor) {
        if (cursor->data > 0) {
            p_tail->next = cursor;
            p_tail = p_tail->next;
        } else {
            n_tail->next = cursor;
            n_tail = n_tail->next;
        }
        cursor = cursor->next;
    }

    src->next = NULL;
    p_tail->next = NULL;
    n_tail->next = NULL;
}

13.基于链栈的回文字符序列判断

描述：请设计一个算法判定给定的的字符序列是否为回文。

输入样例：
abba
abdba
good
0

输出样例：
YES
YES
NO

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

#define MAX_SIZE 100

typedef struct LNode {
    char data;
    struct LNode *next;
} LNode, *LinkStack;

LinkStack stack_init();

void stack_push(LinkStack *S, char e);

char stack_pop(LinkStack *S);

void stack_destroy(LinkStack *S);

bool is_palindrome(LinkStack *S, char *str);

int main() {
    char str[MAX_SIZE];
    while (scanf("%s", str) && str[0] != 48) {
        LinkStack S = stack_init();
        for (int i = 0; *(str + i) != 0; i++) {
            stack_push(&S, str[i]);
        }
        if (is_palindrome(&S, str)) {
            printf("\nYES");
        } else {
            printf("\nNO");
        }
        stack_destroy(&S);
    }

    return 0;
}

LinkStack stack_init() {
    LinkStack S = NULL;
    return S;
}

void stack_push(LinkStack *S, char e) {
    LNode *new_node = (LNode *)malloc(sizeof(LNode));

    new_node->data = e;
    new_node->next = *S;
    *S = new_node;
}

char stack_pop(LinkStack *S) {
    LNode *p = *S;
    int val = p->data;

    *S = p->next;
    free(p);
    return val;
}

void stack_destroy(LinkStack *S) {
    LNode *p = *S;

    while (*S) {
        *S = p->next;
        free(p);
    }
}

bool is_palindrome(LinkStack *S, char *str) {
    for (int i = 0; *(str + i) != 0; i++) {
        if (stack_pop(S) != *(str + i)) {
            return false;
        }
    }
    return true;
}

14.奇偶链表的分割

描述：给定一个单链表，把所有的奇数结点和偶数结点分别排在一起，重新链成一个新链表。请注意，这里的奇数结点和偶数结点指的是结点编号的奇偶性，而不是结点的值。
说明：空间复杂度为 O ( 1 ) O(1) O(1)，时间复杂度为 O ( n ) O(n) O(n)，n为链表结点总数。

输入样例：
5
1 2 3 4 5
3
1 5 6
4
15 2 3 4
0

输出样例：
1 3 5 2 4
1 6 5
15 3 2 4

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

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

LinkList list_init();

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_divide(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList L = list_init();

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        list_divide(L);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = 0;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_divide(LinkList L) {
    LNode *cursor = L->next;
    LNode *odd_tmp = (LNode *) malloc(sizeof(LNode));//fake head node
    LNode *even_tmp = (LNode *) malloc(sizeof(LNode));//fake head node
    LNode *odd_tail = odd_tmp, *even_tail = even_tmp;

    while (cursor) {
        /*handle odd nodes*/
        odd_tail->next = cursor;
        odd_tail = odd_tail->next;
        /*handle even nodes*/
        if (!cursor->next) break;
        cursor = cursor->next;
        even_tail->next = cursor;
        even_tail = even_tail->next;
        cursor = cursor->next;
    }

    /*sequence: L->odd->even*/
    L->next = odd_tmp->next;
    free(odd_tmp);
    odd_tail->next = even_tmp->next;
    free(even_tmp);
    even_tail->next = NULL;
}

15.基于链表的两数之和

利用头插法创建两个单链表，每个单链表表示一个整数，请设计算法计算出两个整数的和并储存到新的链表中。

输入样例：
3 3
3 2 1
6 5 4
3 3
9 9 4
1 3 2
2 3
8 3
9 2 7

输出样例：
5 7 9
6 2 1 1
0 1 0 1

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

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

LinkList list_create(int len);

LinkList list_init();

void list_insert(LinkList L, int e);

void list_destroy(LinkList *L);

void list_show(LinkList L);

void list_get_sum(LinkList summand, LinkList addend, LinkList sum);

int main() {
    int m, n;
    while (scanf("%d %d", &m, &n) && !(m == 0 && n == 0)) {
        LinkList summand = list_create(m);
        LinkList addend = list_create(n);
        LinkList sum = list_init();

        list_get_sum(summand, addend, sum);
        list_show(sum);
        list_destroy(&summand);
        list_destroy(&addend);
        list_destroy(&sum);
    }

    return 0;
}

LinkList list_create(int len) {
    LinkList L = (LinkList) malloc(sizeof(LNode));
    L->data = 0;
    L->next = NULL;
    while (len--) {
        LNode *new_node = (LNode *)malloc(sizeof(LNode));
        scanf("%d", &(new_node->data));
        new_node->next = L->next;
        L->next = new_node;
    }
    return L;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(LinkList L, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = e;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

void list_get_sum(LinkList summand, LinkList addend, LinkList sum) {
    LNode *p = summand->next;
    LNode *q = addend->next;
    int carry_val = 0;

    while (p && q) {
        list_insert(sum, (p->data + q->data + carry_val) % 10);
        carry_val = (p->data + q->data + carry_val) / 10;
        p = p->next;
        q = q->next;
    }
    while (p) {
        list_insert(sum, (p->data + carry_val) % 10);
        carry_val = (p->data + carry_val) / 10;
        p = p->next;
    }
    while (q) {
        list_insert(sum, (q->data + carry_val) % 10);
        carry_val = (q->data + carry_val) / 10;
        q = q->next;
    }

    if (carry_val != 0) {
        list_insert(sum, carry_val);
    }
}

16.删除链表中绝对值相等的结点

描述：利用单链表表示一个整数序列，实现一个时间复杂度为 O ( n ) O(n) O(n)的算法，对于链表中绝对值相等的结点，仅保留第一次出现的结点而删除其余绝对值相等的结点。

输入样例：
5
21 -15 -15 -7 15
7
90 32 -90 -66 77 66 90
0

输出样例：
21 -15 -7
90 32 -66 77

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

#define MAX_SIZE 100

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

LinkList list_init();

void list_insert(LinkList L, int x);

void list_destroy(LinkList *L);

void list_show(LinkList L);

int get_absolute(int x);

void list_delete(LinkList L);

int main() {
    int m, x;
    while (scanf("%d", &m) && m != 0) {
        LinkList L =list_init();

        while (m--) {
            scanf("%d", &x);
            list_insert(L, x);
        }
        list_delete(L);
        list_show(L);
        list_destroy(&L);
    }

    return 0;
}

LinkList list_init() {
    LinkList L = (LinkList) malloc(sizeof(LNode));

    L->data = 0;
    L->next = NULL;
    return L;
}

void list_insert(LinkList L, int x) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = L;

    while (tail->next) {
        tail = tail->next;
    }
    new_node->data = x;
    new_node->next = NULL;
    tail->next = new_node;
}

void list_destroy(LinkList *L) {
    LNode *head = *L, *tmp;

    *L = NULL;
    while (head->next) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    free(head);
}

void list_show(LinkList L) {
    LNode *p = L->next;

    while (p) {
        printf("%c%d", (p == L->next) ? 10 : 32, p->data);
        p = p->next;
    }
}

int get_absolute(int x) {
    return (x > 0) ? x : -x;
}

void list_delete(LinkList L) {
    LNode *p = L, *tmp;
    int count[MAX_SIZE] = {0};

    while (p->next) {
        if (count[get_absolute(p->next->data)]) {
            tmp = p->next;
            p->next = tmp->next;
            free(tmp);
        } else {
            count[get_absolute(p->next->data)]++;
            p = p->next;
        }
    }
}
呦，又写BUG呢
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用链表实现有序合并集运算
05-30
编程实现将两个有序表合并后仍然有序功能，要求分别采用数组法与链表法，并分析两种方法各自的优缺点。若用表La、Lb分别代表两个已存在的有序表，Lc为算法完成后产生新的有序表。可行的算法之一为：从表La与Lb中各取一个元素进行比较，将小的元素插入到Lc中，并取小元素所在表的下一个元素继续与另一表的元素继续比较操作，直到一个表中元素取尽为止，再将另一表的余下元素直接挂入新表Lc的末尾。
数据结构—链表— 两个有序链表序列的合并
yclzju的博客
03-17 806
02-线性结构1 两个有序链表序列的合并   (15分) 本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口定义： List Merge( List L1, List L2 ); 其中List结构定义如下： typedef struct Node *PtrToNode; struct Node {     ElementType Da
链表应用：第2关：基于链表的两个递增有序序列的合并
qq_74118294的博客
10-25 564
多组数据，每组数据有三行，第一行为序列A和B的长度n和m，第二行为序列A的n个元素，第三行为序列B的m个元素（元素之间用空格分隔）。n=0且m=0时输入结束。本关任务：给定两个递增的整数序列A和B，利用链表表示序列A和B，将A和B合并为一个递增的有序序列C，序列C不允许有重复的数据。要求空间复杂度为O(1)。对于每组数据输出一行，为合并后的序列，每个数据之间用空格分隔。
合并链表两个排序链表（Python）
cuilllinn的博客
03-20 1671
题目：输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 思路：设定一个合并后链表的当前所遍历的节点cur。cur初始值为None，然后从给定链表的头节 点开始判断：当链表1的头节点比链表2的头节点大时，cur连接小的那个，显然就是链表2的 头节点，也就是cur.next=l2，连接完之后...
Python实现合并两个有序链表的方法示例
09-19
主要介绍了Python实现合并两个有序链表的方法,涉及Python操作链表节点的遍历、判断、添加等相关操作技巧,需要的朋友可以参考下
第21关：基于链表的两个递增有序序列的合并
m0_63759457的博客
12-05 1818
基于链表的两个递增有序序列的合并
BJFUOJ：基于链表的两个递增有序序列的合并
houyiming
03-04 554
基于链表的两个递增有序序列的合并 坑点：(1) 注意空间复杂度为o(1) (2) 输出的每一行最后一个数字后面不要有空格，否则会wa #include<bits/stdc++.h> using namespace std; typedef struct Lnode { int num; struct Lnode *next; } Lnode,*Linklist; void InitLinklist(Linklist &l) { l = new Lnode; l->next
两个递增的有序链表的合并
m0_58789064的博客
03-20 5196
两个递增的有序链表合并
链表练习题C++代码实现(四):将两个递增的链表合并为一个顺序递减的链表
qq_43591406的博客
12-02 965
考察知识点： 头插法和尾插法的区别。 两个有序链表的合并。
基于链表的两个递增有序序列的合并
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-16 1115
将两个递增有序序列合并为另一个递增有序序列。
探讨:将两个链表非降序合并为一个链表并依然有序的实现方法
09-05
本篇文章是对将两个链表非降序合并为一个链表并依然有序的实现方法进行了详细的分析介绍，需要的朋友参考下
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
07-03
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
c++ 如何合并两个有序链表
08-18
主要介绍了c++ 如何合并两个有序链表,帮助大家更好的理解和学习C++,感兴趣的朋友可以了解下
基于C++实现两个有序链表序列的交集【100012664】
06-07
已知两个非降序链表序列 S1 和 S2，设计函数构造出 S1 和 S2 的交集新链表 S3。 输入说明：输入分 2 行，分别在每行给出由若干个正整数构成的非降序序列，用-1 表示序列的结尾（-1 不属于这个序列）。数字用空格间隔。 输出说明：在一行中输出两个输入序列的交集序列，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出 NULL。
设计一个基于链表的数据结构
11-18
1. 确定课程目标和内容：本课题的目标是让学生掌握链表数据结构的基本原理和应用，培养学生的编程能力和逻辑思维能力。课程内容包括链表的基本概念、操作和应用，以及学生信息管理系统的设计和实现。 2. 设计教学...
snake_eggs2.rar_Windows编程_snake_单链表_贪吃蛇_贪吃蛇 链表
09-22
经典贪吃蛇小游戏.Windows底层编程，使用C++消息函数接收和响应键盘操作。数据结构为单链表。适合C++学习者练习Windows编程和链表数据结构练习。
Java数据结构和算法中文第二版(1)
04-20
学会如何用面向对象的编程简化数据结构和算法 本书以一种易懂的方式教授如何安排和操纵数据的问题，其中不乏一些难题；了解这些知识以期使计算机的应用获得最好的表现。 不管使用何种语言或平台，掌握了数据结构和...
Java数据结构和算法中文第二版(2)
04-20
学会如何用面向对象的编程简化数据结构和算法 本书以一种易懂的方式教授如何安排和操纵数据的问题，其中不乏一些难题；了解这些知识以期使计算机的应用获得最好的表现。 不管使用何种语言或平台，掌握了数据结构和...
入栈和出栈的基本操作
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-18 3759
入栈和出栈的基本操作，输入-1表示出栈，否则入栈，出栈若失败输出error并退出本轮循环。
c++ 结构编程练习
最新发布
01-09
C结构编程是一种编程方法，它将程序分解成不同的模块或函数，每个模块负责...总的来说，C结构编程练习是提高学习者编程技能的有效方式，通过实践来加深对C语言的理解，掌握模块化编程的方法，培养解决实际问题的能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值