呦，又写BUG呢
呦，又写BUG呢

王道数据结构编程题（链式存储线性表）

文章目录

  • 1.设计一个递归算法，删除不带头结点的单链表中的所有值为x的结点。
  • 2.在带头结点的单链表中，删除所有值为x的结点，并释放其空间。
  • 3.给定一个带头结点单链表，反向输出每个结点的值。
  • 4.在带头结点的单链表中删除一个最小值结点（假设最小值结点是唯一的）。
  • 5.将带头结点的单表逆置，要求空间复杂度为 O ( n ) O(n) O(n)。
  • 6.使一个带头结点的单链表所有元素递增有序。
  • 7.设在一个带表头结点的单链表中所有元素结点的数据值无序，删除表中所有介于给定的两个值之间的元素。
  • 8.给定两个单链表，编写算法找出两个链表的公共结点。
  • 9.给定一个带头结点的单链表，按递增次序输出各结点中的数据并释放结点所占存储空间。
  • 10.将一个带头结点单链表分解为两个带头结点单链表A和B，其中A含有原表中序号为奇数的元素，B含有序号为偶数的元素。
  • 11.将线性表 ( a 1 , b 1 , a 2 , b 2 , … , a n , b n ) (a_1, b_1, a_2, b_2, \dots, a_n, b_n) (a1​,b1​,a2​,b2​,…,an​,bn​)就地分解为 ( a 1 , a 2 , … , a n ) (a_1, a_2, \dots, a_n) (a1​,a2​,…,an​)和 ( b n , … , b 2 , b 1 ) (b_n, \dots, b_2, b_1) (bn​,…,b2​,b1​)。
  • 12.删除递增有序单链表中的重复元素。
  • 13.将两个递增有序的单链表归并为一个递减有序的单链表，除了头结点不能新建结点。
  • 14.给定两个递增有序的单链表，通过二者公共元素新建一个单链表。
  • 15.给定两个单链表，求二者元素对应集合的交集并存放在第一个单链表中。
  • 16.给定两个单链表，判断其中一个单链表是否是另一个的连续子序列。
  • 17.判断带头结点的循环双链表是否对称。
  • 18.给定两个循环双链表，将其中一个单链表链接到另一个单链表后面。
  • 19.给定一个带头结点循环双链表，从小到大依次输出链表中的值并将结点删除，直到链表为空。
  • 20.给定一个带表头结点的非循环双链表，每个结点除了值域和指针域，还有一个访问频度域。每次执行访问函数`Locate(L, x)`都会将频度加一，且每次访问结束Locate函数会按照频度非递增将结点排序，并将最近访问的结点放在同频次其他结点前面，实现Locate函数。
  • 21.给定一个带表头结点的单链表，查找其倒数第k个元素的值 。
  • 22.假定采用带头结点单链表保存单词，当两个单词有相同后缀时可共享存储空间，要求找出两个共享存储空间的单词的共同后缀起始位置。
  • 23.给定一个单链表，表中元素绝对值大小均小于正整数n，设计算法仅保留第一次出现的结点删除其余绝对值相等的结点。
  • 24.判断一个链表是否有环，若有环输出入口元素。
  • 25.将线性表 ( a 1 , a 2 , a 3 , … , a n − 1 , a n ) (a_1, a_2, a_3, \dots, a_{n-1}, a_n) (a1​,a2​,a3​,…,an−1​,an​)重新排列为 ( a 1 , a n , a 2 , a n − 1 , …   ) (a_1, a_n, a_2, a_{n-1}, \dots) (a1​,an​,a2​,an−1​,…)，要求空间复杂度为 O ( 1 ) O(1) O(1)。
  • 附：list.h与list.c

在这里插入图片描述

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

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

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


#include 
#include 
#include 

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

LinkList ListInit();
void ListTailInsert(LinkList *head, int e);
void ListDestroy(LinkList *head);
void ListShow(LinkList head);

LinkList ListDelete(LinkList *head, int x) {
    LNode *next_node = (*head)->next;

    if ((*head)->next) {
        (*head)->next = ListDelete(&((*head)->next), x);
    }
    if ((*head)->data == x) {
        free(*head);
        return next_node;
    } else {
        return *head;
    }
}

void ListDelete_(LinkList *head, int x) {
    LNode *tmp = *head;

    if (*head == NULL) {
        return;
    } else if ((*head)->data == x) {
        *head = (*head)->next;
        free(tmp);
        ListDelete_(&((*head)->next), x);
    } else {
        ListDelete_(&((*head)->next), x);
    }
}

int main() {
    int m;

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

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(&L, e);
        }
        scanf("%d", &x);
        L = ListDelete(&L, x);
        /*ListDelete_(&L, x);*/
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

LinkList ListInit() {
    LinkList head = NULL;

    return head;
}

void ListTailInsert(LinkList *head, int e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));

    new_node->data = e;
    new_node->next = NULL;
    if (!*head) {
        *head = new_node;
    } else {
        LNode *tail = *head;

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

void ListDestroy(LinkList *head) {
    LNode *tmp;

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

void ListShow(LinkList head) {
    LNode *p = head;

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

2.在带头结点的单链表中，删除所有值为x的结点，并释放其空间。

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

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


#include 
#include "list.h"

void ListDelete(LinkList head, int x) {
    LNode *p = head, *tmp;

    while (p->next) {
        if (p->next->data == x) {
            tmp = p->next;
            p->next = p->next->next;
            free(tmp);
        }
        p = p->next;
    }
}

void ListDelete_(LinkList head, int x) {
    LNode *tmp = head->next;

    if (!head->next) {
        return;
    } else if (head->next->data == x) {
        head->next = head->next->next;
        free(tmp);
        ListDelete_(head->next, x);
    } else {
        ListDelete_(head->next, x);
    }
}

int main() {
    int m;

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

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        scanf("%d", &x);
        ListDelete(L, x);
        /*ListDelete_(L, x);*/
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

3.给定一个带头结点单链表，反向输出每个结点的值。

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

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


#include 
#include "list.h"

void ListInvertShow(LinkList head, int out) {
    if (head->next) ListInvertShow(head->next, 32);
    printf("%d%c", head->data, out);
}

void ListInvert(LinkList head) {
    LNode *cur = head->next, *tmp;

    head->next = NULL;
    while (cur) {
        tmp = cur->next;
        cur->next = head->next;
        head->next = cur;
        cur = tmp;
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        if (L) ListInvertShow(L->next, 10);
        /*ListInvert(L);
        ListShow(L);*/
        ListDestroy(&L);
    }
    return 0;
}

4.在带头结点的单链表中删除一个最小值结点（假设最小值结点是唯一的）。

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

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


#include 
#include "list.h"

void ListDeleteMin(LinkList head) {
    LNode *cur = head, *min_pos = head, *tmp;

    if (!head->next) return;//空链表
    while (cur->next) {
        if (cur->next->data < min_pos->next->data) {
            min_pos = cur;
        }
        cur = cur->next;
    }
    tmp = min_pos->next;
    min_pos->next = tmp->next;
    free(tmp);
}

int ListDeleteMin_(LinkList head, int min) {
    LNode *tmp;

    if (!head->next) return min;//head为倒数第一个结点 直接返回

    min = ListDeleteMin_(head->next, (head->next->data < min) ? head->next->data : min);
    if (head->next->data == min) {
        tmp = head->next;
        head->next = tmp->next;
        free(tmp);
    }
    return min;
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        ListDeleteMin(L);
        /*int min = ListDeleteMin_(L, INT_MAX);*/
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

5.将带头结点的单表逆置，要求空间复杂度为 O ( n ) O(n) O(n)。

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

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


#include 
#include "list.h"

void ListInvert(LinkList head) {
    LNode *cur = head->next, *tmp;

    head->next = NULL;
    while (cur) {
        tmp = cur->next;
        cur->next = head->next;
        head->next = cur;
        cur = tmp;
    }
}

void ListInvert_(LinkList head, LNode *now) {
    LNode *tmp = now->next;//now结点的下一个结点

    if (now == head) {
        head->next = NULL;
    } else {
        now->next = head->next;
        head->next = now;
    }
    if (tmp) ListInvert_(head, tmp);
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        /*ListInvert(L);*/
        ListInvert_(L, L);
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

6.使一个带头结点的单链表所有元素递增有序。

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

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


#include 
#include "list.h"

void ListSort(LinkList head) {
    LNode *left, *right = head->next, *l_tmp, *r_tmp;

    if (!head->next) return;

    while (right->next) {
        left = head;
        while (left->next->data < right->next->data) {
            left = left->next;
        }
        if (left != right) {
            l_tmp = left->next;
            r_tmp = right->next->next;
            left->next = right->next;
            left->next->next = l_tmp;
            right->next = r_tmp;
        } else {
            right = right->next;
        }
    }
}

void ListSort_(LinkList head) {
    if (!head->next) return;//空链表

    LNode *left, *right = head->next->next, *tmp;

    head->next->next = NULL;
    while (right) {
        left = head;
        while (left->next && left->next->data < right->data) {
            left = left->next;
        }
        tmp = right->next;
        right->next = left->next;
        left->next = right;
        right = tmp;
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
		/*ListSort(L);*/
        ListSort_(L);
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

7.设在一个带表头结点的单链表中所有元素结点的数据值无序，删除表中所有介于给定的两个值之间的元素。

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

输出样例：
3 4
1


#include 
#include "list.h"

void ListDelete(LinkList head, int min, int max) {
    LNode *cursor = head, *tmp;

    if (!cursor) return;//empty

    while (cursor->next) {
        if (cursor->next->data > min && cursor->next->data < max) {
            /*delete*/
            tmp = cursor->next;
            cursor->next = cursor->next->next;
            free(tmp);
        } else {
            cursor = cursor->next;
        }
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e, min, max;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        scanf("%d %d", &min, &max);
        ListDelete(L, min, max);
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

8.给定两个单链表，编写算法找出两个链表的公共结点。

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

输出样例：
6
7


#include 
#include "list.h"

int ListFind(LinkList head_a, LinkList head_b) {
    int len_a = 0, len_b = 0;
    LNode *cur_a = head_a, *cur_b = head_b;
    /*get length*/
    while (cur_a) {
        len_a++;
        cur_a = cur_a->next;
    }
    while (cur_b) {
        len_b++;
        cur_b = cur_b->next;
    }
    
    cur_a = head_a;
    cur_b = head_b;
    if (len_a > len_b) {
        for (int i = 0; i < len_a - len_b; i++) cur_a = cur_a->next;
    } else {
        for (int i = 0; i < len_b - len_a; i++) cur_b = cur_b->next;
    }
    while (cur_a->data != cur_b->data) {
        cur_a = cur_a->next;
        cur_b = cur_b->next;
    }
    return cur_a->data;
}

void ListLink(LinkList A, LinkList B, LinkList *C);

void ListFree(LinkList *A, LinkList *B, int node_a);

int main() {
    int len_a, len_b, len_c;

    while (scanf("%d %d %d", &len_a, &len_b, &len_c)) {
        if (len_a == 0 || len_b == 0 || len_c == 0) break;

        LinkList A = ListInit();
        LinkList B = ListInit();
        LinkList C = ListInit();
        int e, node_a = len_a + 1;

        while (len_a--) {
            scanf("%d", &e);
            ListTailInsert(A, e);
        }
        while (len_b--) {
            scanf("%d", &e);
            ListTailInsert(B, e);
        }
        while (len_c--) {
            scanf("%d", &e);
            ListTailInsert(C, e);
        }
        ListLink(A, B, &C);
        printf("%d\n", ListFind(A, B));
        ListFree(&A, &B, node_a);
    }
    return 0;
}

void ListLink(LinkList A, LinkList B, LinkList *C) {
    LNode *tail_a = A, *tail_b = B;

    while (tail_a->next) tail_a = tail_a->next;
    tail_a->next = (*C)->next;//link A and C
    while (tail_b->next) tail_b = tail_b->next;
    tail_b->next = (*C)->next;//link B and C
    free(*C);//free the head of C
    *C = NULL;
}

void ListFree(LinkList *A, LinkList *B, int node_a) {
    LNode *tmp;

    while (*B) {
        tmp = *B;
        *B = (*B)->next;
        free(tmp);
    }
    while (node_a--) {
        tmp = *A;
        *A = (*A)->next;
        free(tmp);
    }
}

9.给定一个带头结点的单链表，按递增次序输出各结点中的数据并释放结点所占存储空间。

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

输出样例：
1 2 3
0 1 4 6 9


#include 
#include "list.h"

void ListShowFree(LinkList head) {
    LNode *cursor, *min, *tmp;

    while (head->next) {
        cursor = min = head;
        while (cursor->next) {
            if (cursor->next->data < min->next->data) min = cursor;
            cursor = cursor->next;
        }
        printf("%d%c", min->next->data, (head == min && min->next->next == NULL) ? 10 : 32);
        /*delete node min->next*/
        tmp = min->next;
        min->next = tmp->next;
        free(tmp);
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        ListShowFree(L);
    }
    return 0;
}

10.将一个带头结点单链表分解为两个带头结点单链表A和B，其中A含有原表中序号为奇数的元素，B含有序号为偶数的元素。

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

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


#include 
#include "list.h"

void ListDisconnect(LinkList L, LinkList A, LinkList B) {
    LNode *tail_a = A, *tail_b = B;

    while (L->next) {
        /*insert into list A*/
        tail_a->next = L->next;
        L->next = L->next->next;
        tail_a->next->next = NULL;
        tail_a = tail_a->next;

        if (!L->next) break;
        /*insert into list B*/
        tail_b->next = L->next;
        L->next = L->next->next;
        tail_b->next->next = NULL;
        tail_b = tail_b->next;
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        LinkList A = ListInit();
        LinkList B = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        ListDisconnect(L, A, B);
        ListShow(A);
        ListShow(B);
        ListDestroy(&L);
        ListDestroy(&A);
        ListDestroy(&B);
    }
    return 0;
}

11.将线性表 ( a 1 , b 1 , a 2 , b 2 , … , a n , b n ) (a_1, b_1, a_2, b_2, \dots, a_n, b_n) (a1​,b1​,a2​,b2​,…,an​,bn​)就地分解为 ( a 1 , a 2 , … , a n ) (a_1, a_2, \dots, a_n) (a1​,a2​,…,an​)和 ( b n , … , b 2 , b 1 ) (b_n, \dots, b_2, b_1) (bn​,…,b2​,b1​)。

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

输出样例：
1 3 5
4 2


#include 
#include "list.h"

void ListDisconnect(LinkList L, LinkList A, LinkList B) {
    LNode *tail_a = A, *tmp;

    while (L->next) {
        /*tail insert*/
        tail_a->next = L->next;
        L->next = L->next->next;
        tail_a = tail_a->next;
        tail_a->next = NULL;

        if (!L->next) break;
        /*head insert*/
        tmp = L->next->next;
        L->next->next = B->next;
        B->next = L->next;
        L->next = tmp;
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        LinkList A = ListInit();
        LinkList B = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        ListDisconnect(L, A, B);
        ListShow(A);
        ListShow(B);
        ListDestroy(&L);
        ListDestroy(&A);
        ListDestroy(&B);
    }
    return 0;
}

12.删除递增有序单链表中的重复元素。

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

输出样例：
1 2 3
1 2 3


#include 
#include "list.h"

void ListDelete(LinkList L) {
    LNode *left = L, *right = L->next, *tmp;

    if (!right) return;

    while (right->next) {
        if (left->next->data == right->next->data) {
            tmp = right->next;
            right->next = right->next->next;
            free(tmp);
        } else {
            left = left->next;
            right = right->next;
        }
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        ListDelete(L);
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

13.将两个递增有序的单链表归并为一个递减有序的单链表，除了头结点不能新建结点。

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

输出样例：
6 5 4 3 2 1


#include 
#include "list.h"

void ListMerge(LinkList L, LinkList A, LinkList B) {
    LNode *tmp;

    while (A->next && B->next) {
        if (A->next->data < B->next->data) {
            tmp = A->next->next;
            A->next->next = L->next;
            L->next = A->next;
            A->next = tmp;
        } else {
            tmp = B->next->next;
            B->next->next = L->next;
            L->next = B->next;
            B->next = tmp;
        }
    }

    while (A->next) {
        tmp = A->next->next;
        A->next->next = L->next;
        L->next = A->next;
        A->next = tmp;
    }

    while (B->next) {
        tmp = B->next->next;
        B->next->next = L->next;
        L->next = B->next;
        B->next = tmp;
    }
}

int main() {
    int m, n;

    while (scanf("%d %d", &m, &n) && m != 0 && n != 0) {
        LinkList L = ListInit();
        LinkList A = ListInit();
        LinkList B = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(A, e);
        }
        while (n--) {
            scanf("%d", &e);
            ListTailInsert(B, e);
        }
        ListMerge(L, A, B);
        ListShow(L);
        ListDestroy(&L);
        ListDestroy(&A);
        ListDestroy(&B);
    }
    return 0;
}

14.给定两个递增有序的单链表，通过二者公共元素新建一个单链表。

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

输出样例：
1 3 5


#include 
#include "list.h"

void ListCreat(LinkList L, LinkList A, LinkList B) {
    LNode *cur_a = A->next, *cur_b = B->next;

    while (cur_a && cur_b) {
        if (cur_a->data < cur_b->data) {
            cur_a = cur_a->next;
        } else if (cur_a->data > cur_b->data) {
            cur_b = cur_b->next;
        } else {
            ListTailInsert(L, cur_a->data);
            cur_a = cur_a->next;
            cur_b = cur_b->next;
        }
    }
}

int main() {
    int m, n;

    while (scanf("%d %d", &m, &n) && m != 0 && n != 0) {
        LinkList L = ListInit();
        LinkList A = ListInit();
        LinkList B = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(A, e);
        }
        while (n--) {
            scanf("%d", &e);
            ListTailInsert(B, e);
        }
        ListCreat(L, A, B);
        ListShow(L);
        ListDestroy(&L);
        ListDestroy(&A);
        ListDestroy(&B);
    }
    return 0;
}

15.给定两个单链表，求二者元素对应集合的交集并存放在第一个单链表中。

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

输出样例：
1 3 5


#include 
#include "list.h"

void ListIntersection(LinkList A, LinkList B) {
    LNode *cur_a = A, *cur_b, *tmp;

    while (cur_a->next) {
        cur_b = B->next;
        while (cur_b) {
            if (cur_b->data == cur_a->next->data) break;
            cur_b = cur_b->next;
        }
        if (!cur_b) {
            /*cur_a->next->data doesn't appear in B*/
            tmp = cur_a->next;
            cur_a->next = cur_a->next->next;
            free(tmp);
        } else {
            cur_a = cur_a->next;
        }
    }
}

int main() {
    int m, n;

    while (scanf("%d %d", &m, &n) && m != 0 && n != 0) {
        LinkList A = ListInit();
        LinkList B = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(A, e);
        }
        while (n--) {
            scanf("%d", &e);
            ListTailInsert(B, e);
        }
        ListIntersection(A, B);
        ListShow(A);
        ListDestroy(&A);
        ListDestroy(&B);
    }
    return 0;
}

16.给定两个单链表，判断其中一个单链表是否是另一个的连续子序列。

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

输出样例：
YES
NO


#include 
#include 
#include "list.h"

bool IsSub(LinkList A, LinkList B) {
    LNode *cur_a = A->next, *cur_b, *tmp;

    while (cur_a) {
        tmp = cur_a;
        cur_b = B->next;
        while (cur_b && tmp) {
            if (tmp->data == cur_b->data) {
                tmp = tmp->next;
                cur_b = cur_b->next;
            }
            else {
                break;
            }
        }
        if (!cur_b) return true;
        cur_a = cur_a->next;
    }
    return false;
}

int main() {
    int m, n;

    while (scanf("%d %d", &m, &n) && m != 0 && n != 0) {
        LinkList A = ListInit();
        LinkList B = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(A, e);
        }
        while (n--) {
            scanf("%d", &e);
            ListTailInsert(B, e);
        }
        printf("%s\n", IsSub(A, B) ? "YES" : "NO");
        ListDestroy(&A);
        ListDestroy(&B);
    }
    return 0;
}

17.判断带头结点的循环双链表是否对称。

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

输出样例：
YES
NO


#include 
#include 
#include 

typedef struct DLNode {
    int data;
    struct DLNode *left, *right;
} DLNode, *DLinkList;

DLinkList ListInit();
void ListRightInsert(DLinkList L, int e);
void ListDestroy(DLinkList *L);
void ListShow(DLinkList L);

bool IsSymmetric(DLinkList L) {
    DLNode *r_cur = L->right, *l_cur = L->left;

    while (r_cur != L && l_cur != L) {
        if (r_cur -> data == l_cur->data) {
            r_cur = r_cur->right;
            l_cur = l_cur->left;
        } else {
            break;
        }
    }
    return (r_cur == L && l_cur == L);
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        DLinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListRightInsert(L, e);
        }
        printf("%s\n", IsSymmetric(L) ? "YES" : "NO");
        ListDestroy(&L);
    }
    return 0;
}

DLinkList ListInit() {
    DLinkList L = (DLinkList) malloc(sizeof(DLNode));

    L->data = 0;
    L->left = L->right = L;
    return L;
}

void ListRightInsert(DLinkList L, int e) {
    DLNode *new_node = (DLNode *) malloc(sizeof(DLNode));
    DLNode *tail = L;

    while (tail->right != L) tail = tail->right;
    tail->right = L->left = new_node;
    new_node->data = e;
    new_node->left = tail;
    new_node->right = L;
}

void ListDestroy(DLinkList *L) {
    DLNode *tmp;

    while ((*L)->right != *L) {
        tmp = (*L)->right;
        (*L)->right = tmp->right;
        tmp->right->left = *L;
        free(tmp);
    }
}

void ListShow(DLinkList L) {
    DLNode *cursor = L->right;

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

18.给定两个循环双链表，将其中一个单链表链接到另一个单链表后面。

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

输出样例：
1 2 3 4 5 6


#include 
#include 
#include 

typedef struct DLNode {
    int data;
    struct DLNode *left, *right;
} DLNode, *DLinkList;

DLinkList ListInit();
void ListRightInsert(DLinkList L, int e);
void ListDestroy(DLinkList *L);
void ListShow(DLinkList L);

bool ListLink(DLinkList A, DLinkList *B) {
    DLNode *tail_a = A, *tail_b = *B;

    while (tail_a->right != A) tail_a = tail_a->right;
    while (tail_b->right != *B) tail_b = tail_b->right;
    tail_a->right = (*B)->right;
    tail_b->right = A;
    A->left = tail_b;
    (*B)->left = tail_a;
    *B = NULL;
}

int main() {
    int m, n;

    while (scanf("%d %d", &m, &n) && m != 0 && n != 0) {
        DLinkList A = ListInit();
        DLinkList B = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListRightInsert(A, e);
        }
        while (n--) {
            scanf("%d", &e);
            ListRightInsert(B, e);
        }
        ListLink(A, &B);
        ListShow(A);
        ListDestroy(&A);
    }
    return 0;
}

DLinkList ListInit() {
    DLinkList L = (DLinkList) malloc(sizeof(DLNode));

    L->data = 0;
    L->left = L->right = L;
    return L;
}

void ListRightInsert(DLinkList L, int e) {
    DLNode *new_node = (DLNode *) malloc(sizeof(DLNode));
    DLNode *tail = L;

    while (tail->right != L) tail = tail->right;
    tail->right = L->left = new_node;
    new_node->data = e;
    new_node->left = tail;
    new_node->right = L;
}

void ListDestroy(DLinkList *L) {
    DLNode *tmp;

    while ((*L)->right != *L) {
        tmp = (*L)->right;
        (*L)->right = tmp->right;
        tmp->right->left = *L;
        free(tmp);
    }
}

void ListShow(DLinkList L) {
    DLNode *cursor = L->right;

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

19.给定一个带头结点循环双链表，从小到大依次输出链表中的值并将结点删除，直到链表为空。

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

输出样例：
1 2 3 4 5


#include 
#include 
#include 

typedef struct DLNode {
    int data;
    struct DLNode *left, *right;
} DLNode, *DLinkList;

DLinkList ListInit();
void ListRightInsert(DLinkList L, int e);
void ListDestroy(DLinkList *L);
void ListShow(DLinkList L);

bool ListShowMin(DLinkList L) {
    DLNode *min = L, *cursor, *tmp;

    while (L->right != L) {
        cursor = L;
        while (cursor->right->right != L) {
            if (cursor->right->data < min->right->data) min = cursor;
            cursor = cursor->right;
        }
        printf("%d%c", min->right->data, (L->right == L) ? 10 : 32);
        tmp = min->right;
        min->right = tmp->right;
        tmp->right->left = min;
        free(tmp);
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        DLinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListRightInsert(L, e);
        }
        ListShowMin(L);
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

DLinkList ListInit() {
    DLinkList L = (DLinkList) malloc(sizeof(DLNode));

    L->data = 0;
    L->left = L->right = L;
    return L;
}

void ListRightInsert(DLinkList L, int e) {
    DLNode *new_node = (DLNode *) malloc(sizeof(DLNode));
    DLNode *tail = L;

    while (tail->right != L) tail = tail->right;
    tail->right = L->left = new_node;
    new_node->data = e;
    new_node->left = tail;
    new_node->right = L;
}

void ListDestroy(DLinkList *L) {
    DLNode *tmp;

    while ((*L)->right != *L) {
        tmp = (*L)->right;
        (*L)->right = tmp->right;
        tmp->right->left = *L;
        free(tmp);
    }
}

void ListShow(DLinkList L) {
    DLNode *cursor = L->right;

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

20.给定一个带表头结点的非循环双链表，每个结点除了值域和指针域，还有一个访问频度域。每次执行访问函数Locate(L, x)都会将频度加一，且每次访问结束Locate函数会按照频度非递增将结点排序，并将最近访问的结点放在同频次其他结点前面，实现Locate函数。

输入样例（访问次序）：
3
2
4
3
0


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


#include 
#include 
#include 

typedef struct DLNode {
    int data;
    int freq;
    struct DLNode *prev, *next;
} DLNode, *DLinkList;

DLinkList ListInit();
void ListTailInsert(DLinkList L, int e);
void ListDestroy(DLinkList *L);
void ListShow(DLinkList L);

bool Locate(DLinkList L, int e) {
    DLNode *cursor = L->next;

    while (cursor) {
        if (cursor->data == e) {
            cursor->freq++;
            while (cursor->freq >= cursor->prev->freq) {
                cursor->prev->next = cursor->next;
                cursor->next->prev = cursor->prev;
                cursor->prev->prev->next = cursor;
                cursor->next = cursor->prev;
                cursor->prev = cursor->prev->prev;
                cursor->next->prev = cursor;
            }
            return true;
        }
        cursor = cursor->next;
    }
    return false;
}

int main() {
    int x;
    DLinkList L = ListInit();

    ListTailInsert(L, 1);
    ListTailInsert(L, 2);
    ListTailInsert(L, 3);
    ListTailInsert(L, 4);
    ListTailInsert(L, 5);
    while (scanf("%d", &x) && x != 0) {
        Locate(L, x);
        ListShow(L);
    }
    ListDestroy(&L);
    return 0;
}

DLinkList ListInit() {
    DLinkList L = (DLinkList) malloc(sizeof(DLNode));

    L->data = L->freq = INT_MAX;
    L->prev = L->next = NULL;
    return L;
}

void ListTailInsert(DLinkList L, int e) {
    DLNode *new_node = (DLNode *) malloc(sizeof(DLNode));
    DLNode *tail = L;

    while (tail->next) tail = tail->next;
    tail->next = new_node;
    new_node->data = e;
    new_node->freq = 0;
    new_node->prev = tail;
    new_node->next = NULL;
}

void ListDestroy(DLinkList *L) {
    DLNode *tmp;

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

void ListShow(DLinkList L) {
    DLNode *cursor = L->next;

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

21.给定一个带表头结点的单链表，查找其倒数第k个元素的值 。

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

输出样例：
3
error


#include 
#include 
#include "list.h"

bool ListFind(LinkList head, int k, int *num) {
    LNode *fast = head, *slow = head;

    if (k <= 0) return false;
    while (k--) {
        if (fast->next) {
            fast = fast->next;
        } else {
            return false;
        }
    }
    while (fast) {
        fast = fast->next;
        slow = slow->next;
    }
    *num = slow->data;
    return true;
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e, k, num;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        scanf("%d", &k);
        if (ListFind(L, k, &num)) {
            printf("%d\n", num);
        } else {
            printf("error\n");
        };
        ListDestroy(&L);
    }
    return 0;
}

22.假定采用带头结点单链表保存单词，当两个单词有相同后缀时可共享存储空间，要求找出两个共享存储空间的单词的共同后缀起始位置。

输入样例：
4 2 3
l o a d
b e
i n g
0 0 0

输出样例：
i


#include 
#include 

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

int ListFind(LinkList head_a, LinkList head_b) {
    int len_a = 0, len_b = 0;
    LNode *cur_a = head_a, *cur_b = head_b;
    /*get length*/
    while (cur_a) {
        len_a++;
        cur_a = cur_a->next;
    }
    while (cur_b) {
        len_b++;
        cur_b = cur_b->next;
    }

    cur_a = head_a;
    cur_b = head_b;
    if (len_a > len_b) {
        for (int i = 0; i < len_a - len_b; i++) cur_a = cur_a->next;
    } else {
        for (int i = 0; i < len_b - len_a; i++) cur_b = cur_b->next;
    }
    while (cur_a->data != cur_b->data) {
        cur_a = cur_a->next;
        cur_b = cur_b->next;
    }
    return cur_a->data;
}

LinkList ListInit();

void ListTailInsert(LinkList head, char e);

void ListLink(LinkList A, LinkList B, LinkList *C);

void ListFree(LinkList *A, LinkList *B, int node_a);

int main() {
    int len_a, len_b, len_c;

    while (scanf("%d %d %d", &len_a, &len_b, &len_c)) {
        if (len_a == 0 || len_b == 0 || len_c == 0) break;
        getchar();

        LinkList A = ListInit();
        LinkList B = ListInit();
        LinkList C = ListInit();
        int e, node_a = len_a + 1;

        while (len_a--) {
            scanf("%c", &e);
            getchar();
            ListTailInsert(A, e);
        }
        while (len_b--) {
            scanf("%c", &e);
            getchar();
            ListTailInsert(B, e);
        }
        while (len_c--) {
            scanf("%c", &e);
            getchar();
            ListTailInsert(C, e);
        }
        ListLink(A, B, &C);
        printf("%c\n", ListFind(A, B));
        ListFree(&A, &B, node_a);
    }
    return 0;
}

LinkList ListInit() {
    LinkList head = (LNode *) malloc(sizeof(LNode));

    head->data = 48;
    head->next = NULL;
    return head;
}

void ListTailInsert(LinkList head, char e) {
    LNode *new_node = (LNode *) malloc(sizeof(LNode));
    LNode *tail = head;

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

void ListLink(LinkList A, LinkList B, LinkList *C) {
    LNode *tail_a = A, *tail_b = B;

    while (tail_a->next) tail_a = tail_a->next;
    tail_a->next = (*C)->next;//link A and C
    while (tail_b->next) tail_b = tail_b->next;
    tail_b->next = (*C)->next;//link B and C
    free(*C);//free the head of C
    *C = NULL;
}

void ListFree(LinkList *A, LinkList *B, int node_a) {
    LNode *tmp;

    while (*B) {
        tmp = *B;
        *B = (*B)->next;
        free(tmp);
    }
    while (node_a--) {
        tmp = *A;
        *A = (*A)->next;
        free(tmp);
    }
}

23.给定一个单链表，表中元素绝对值大小均小于正整数n，设计算法仅保留第一次出现的结点删除其余绝对值相等的结点。

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

输出样例：
1 2 3
1 2 3


#include 
#include "list.h"

void ListDelete(LinkList head) {
    LNode *left = head->next, *right, *tmp;

    while (left) {
        right = left;
        while (right->next) {
            if (right->next->data == left->data) {
                tmp = right->next;
                right->next = right->next->next;
                free(tmp);
            } else {
                right = right->next;
            }
        }
        left = left->next;
    }
}

void ListDelete_(LinkList head, int n) {
    int *arr = (int *)calloc(n, sizeof(int));
    LNode *cursor = head, *tmp;

    while (cursor->next) {
        if (arr[cursor->next->data] == 1) {
            tmp = cursor->next;
            cursor->next = cursor->next->next;
            free(tmp);
        } else {
            arr[cursor->next->data]++;
            cursor = cursor->next;
        }
    }
    free(arr);
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e, n = m;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        /*ListDelete(L);*/
        ListDelete_(L, n);
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

24.判断一个链表是否有环，若有环输出入口元素。

输入样例（3表示将末尾链接到第三个元素处构成环）：
5
21 22 23 24 25
3
5
21 22 23 24 25
-1
0

输出样例：
23
error


#include 
#include 
#include "list.h"

bool RingFind(LinkList head, int *begin) {
    LNode *fast = head, *slow = head;
    int len = 0;

    while (1) {
        /*slow step one*/
        slow = slow->next;
        /*fast step two*/
        fast = fast->next;
        if (!fast) return false;//no ring
        fast = fast->next;
        if (!fast) return false;//no ring
        len++;//count the length of this ring
        if (fast == slow) break;//meet
    }

    slow = fast = head;//initialize
    while (len--) fast = fast->next;
    while (fast != slow) {
        slow = slow->next;
        fast = fast->next;
    }
    *begin = slow->data;
    return true;
}

void CreateRing(LinkList head, int n);

void DestroyRing(LinkList L, int m);

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e, n, t = m, begin;

        while (t--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        scanf("%d", &n);
        if (n != -1) CreateRing(L, n);//-1 mean don't create ring
        if (RingFind(L, &begin)) {
            printf("%d\n", begin);
        } else {
            printf("error\n");
        };
        if (n != -1) DestroyRing(L, m);
        ListDestroy(&L);
    }
    return 0;
}

void CreateRing(LinkList head, int n) {
    LNode *cursor = head, *tail = head;

    while (tail->next) tail = tail->next;
    while (n--) cursor = cursor->next;
    tail->next = cursor;
}

void DestroyRing(LinkList L, int m) {
    LNode *tail = L;

    while (m--) tail = tail->next;
    tail->next = NULL;
}

25.将线性表 ( a 1 , a 2 , a 3 , … , a n − 1 , a n ) (a_1, a_2, a_3, \dots, a_{n-1}, a_n) (a1​,a2​,a3​,…,an−1​,an​)重新排列为 ( a 1 , a n , a 2 , a n − 1 , …   ) (a_1, a_n, a_2, a_{n-1}, \dots) (a1​,an​,a2​,an−1​,…)，要求空间复杂度为 O ( 1 ) O(1) O(1)。

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

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


#include 
#include "list.h"

void ListReorder(LinkList head) {
    LNode *new_list = head, *cursor = head, *tmp;
    /*get middle position*/
    while (cursor->next) {
        new_list = new_list->next;
        cursor = cursor->next;
        if (cursor->next) cursor = cursor->next;
    }
    /*invert this new linklist*/
    cursor = new_list->next;
    new_list->next = NULL;
    while (cursor) {
        tmp = cursor->next;
        cursor->next = new_list->next;
        new_list->next = cursor;
        cursor = tmp;
    }
    /*merge*/
    cursor = new_list->next;
    new_list->next = NULL;
    new_list = cursor;
    cursor = head->next;
    while (new_list) {
        tmp = new_list->next;
        new_list->next = cursor->next;
        cursor->next = new_list;
        new_list = tmp;
        cursor = cursor->next->next;
    }
}

int main() {
    int m;

    while (scanf("%d", &m) && m != 0) {
        LinkList L = ListInit();
        int e;

        while (m--) {
            scanf("%d", &e);
            ListTailInsert(L, e);
        }
        ListReorder(L);
        ListShow(L);
        ListDestroy(&L);
    }
    return 0;
}

附：list.h与list.c

list.h

#ifndef CODE_LIST_H
#define CODE_LIST_H

#include 
#include 

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

LinkList ListInit();

void ListTailInsert(LinkList head, int e);

void ListDestroy(LinkList *head);

void ListShow(LinkList head);

#endif

list.c

#include "list.h"

LinkList ListInit() {
    LinkList head = (LNode *) malloc(sizeof(LNode));

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

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

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

void ListDestroy(LinkList *head) {
    LNode *tmp;

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

void ListShow(LinkList head) {
    LNode *p = head->next;

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

你可能感兴趣的:(数据结构与算法,后端,c语言,链表)

  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • Low Power概念介绍-Voltage Area 飞奔的大虎
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
  • C语言 判断回文数 Y雨何时停T c语言学习
    一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
  • 2024.8.22 Python，链表两数之和，链表快速反转，二叉树的深度，二叉树前中后序遍历，N叉树递归遍历，翻转二叉树 RaidenQ python链表开发语言
    1.链表两数之和输入：l1=[2,4,3],l2=[5,6,4]输出：[7,0,8]解释：342+465=807.示例2：输入：l1=[0],l2=[0]输出：[0]示例3：输入：l1=[9,9,9,9,9,9,9],l2=[9,9,9,9]输出：[8,9,9,9,0,0,0,1]昨天的这个题，用自己的办法写的麻烦的要死，然后刚才一看chat归类的办法，感觉自己像个智障。classListNode
  • C语言代码练习（第十九天） 小小框架 C语言C语言重点练习c语言
    今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • uniapp map组件自定义markers标记点 以对_ uni-app学习记录uni-appjavascript前端
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php课程设计vue.js
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
  • 自定义队列 junjun2018
    队列：像排队吃饭一样，先到的先点菜，后来的后点菜。以下代码展示使用单向列表实现的队列。//链表是以节点为单位的，对于单向链表，每个节点中包含一个值和指向下一个对象的引用publicclassNode{Objectvalue;Nodenext;publicNode(Objectvalue){this.value=value;}publicObjectgetValue(){returnvalue;}p
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南C++修炼全景指南c++list链表stl
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
  • 微信小程序开发注意事项 jun778895 微信小程序小程序
    微信小程序开发是一个融合了前端开发、用户体验设计、后端服务（可选）以及微信小程序平台特性的综合性项目。这里，我将详细介绍一个典型的小程序开发项目的全过程，包括项目规划、设计、开发、测试及部署上线等各个环节，并尽量使内容达到或超过2000字的要求。一、项目规划1.1项目背景与目标假设我们要开发一个名为“智慧校园助手”的微信小程序，旨在为学生提供一站式校园生活服务，包括课程表查询、图书馆座位预约、食堂
  • c++ 内存处理函数 heeheeai c++开发语言
    在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
  • C语言---程序设计练习题目及学习方法1 Wanyu677 C语言c语言学习方法算法
    学习方法要多练习在这些题目中的代码和题目自己动手去敲练习也是在熟悉语法，写代码第一步就是熟悉语法练习是在锻炼编程思维，把实际问题转换为代码的能力学会画图画图去理解内存，理解指针这些比较难懂的知识画图可以更好的理清思路辅助理解，强化理解学会调试借助调试，更好的理解代码和感知代码找出代码中的bug和程序逻辑（1）自增自减运算符inta=5,b,c,i=10;b=a++;c=++b;printf("a=
  • VUE3 + xterm + nestjs实现web远程终端 或 连接开启SSH登录的路由器和交换机。 焚木灵 node.jsvue
    可远程连接系统终端或开启SSH登录的路由器和交换机。相关资料：xtermjs/xterm.js:Aterminalfortheweb(github.com)后端实现(NestJS)：1、安装依赖：npminstallnode-ssh@nestjs/websockets@nestjs/platform-socket.io2、我们将创建一个名为RemoteControlModule的NestJS模块，
  • 【C语言】- 自定义类型：结构体、枚举、联合 Cavalier_01 C语言
    【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
  • uniapp实现动态标记效果详细步骤【前端开发】 2401_85123349 uni-app
    第二个点在于实现将已经被用户标记的内容在下一次获取后刷新它的状态为已标记。这是什么意思呢？比如说上面gif图中的这些人物对象，有一些已被该用户添加为关心，那么当用户下一次进入该页面时，这些已经被添加关心的对象需要以“红心”状态显现出来。这个点的难度还不算大，只需要在每一次获取后端的内容后对标记对象进行状态更新即可。II.动态标记效果实现思路和步骤首先，整体的思路是利用动态类名对不同的元素进行选择。
  • leetcode021-合并两个有序链表 陆阳226
    问题描述将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例：输入：1->2->4,1->3->4输出：1->1->2->3->4->4解答递归法：每一层减去一个较小的节点，直到某个链表为null递归结束。publicstaticListNodesolution(ListNodel1,ListNodel2){if(l1==null){returnl2;}
  • MySQL事务隔离级别和MVCC 简书徐小耳
    MySQL事务隔离级别和MVCC参考：https://mp.weixin.qq.com/s/Jeg8656gGtkPteYWrG5_Nw1.MVCC只对读已提交和可重复的读有效果，而未提交读和串行则无意义。2.每条记录都会有trx_id(事务修改记录的id）和roll_pointer是一个指针指向旧版本的undo日志链表（row_id不是必必要的，如果有主键存在就不需要了）3.版本链的头结点就是记
  • 后端开发刷题 | 把数字翻译成字符串（动态规划） jingling555 笔试题目动态规划java算法数据结构后端
    描述有一种将字母编码成数字的方式：'a'->1,'b->2',...,'z->26'。现在给一串数字，返回有多少种可能的译码结果数据范围：字符串长度满足0=10&&num<=26){if(i==1){dp[i]+=1;}else{dp[i]+=dp[i-2];}}}returndp[nums.length()-1];}}
  • 第三十一节:Vue路由:前端路由vs后端路由的了解 曹老师
    1.认识前端路由和后端路由前端路由相对于后端路由而言的,在理解前端路由之前先对于路由有一个基本的了解路由:简而言之,就是把信息从原地址传输到目的地的活动对于我们来说路由就是:根据不同的url地址展示不同的页面内容1.1后端路由以前咱们接触比较多的后端路由,当改变url地址时,浏览器会向服务器发送请求,服务器根据这个url,返回不同的资源内容后端路由的特点就是前端每次跳转到不同url地址,都会重新访
  • 如何建设数据中台（五）——数据汇集—打破企业数据孤岛 weixin_47088026 学习记录和总结中台数据中台程序人生经验分享
    数据汇集——打破企业数据孤岛要构建企业级数据中台，第一步就是将企业内部各个业务系统的数据实现互通互联，打破数据孤岛，主要通过数据汇聚和交换来实现。企业采集的数据可以是线上采集、线下数据采集、互联网数据采集、内部数据采集等。线上数据采集主要载体分为互联网和移动互联网两种，对应有系统平台、网页、H5、小程序、App等，可以采用前端或后端埋点方式采集数据。线下数据采集主要是通过硬件来采集，例如：WiFi
  • HQL之投影查询 归来朝歌 HQLHibernate查询语句投影查询
            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？ 针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
  • Spring整合redis bylijinnan redis
    pom.xml <dependencies> <!-- Spring Data - Redis Library --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
    参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2         在项目中出现了org.hiber
  • android动画效果 不懂事的小屁孩 android动画
    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。 第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
  • js delete 删除机理以及它的内存泄露问题的解决方案 换个号韩国红果果 JavaScript
    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除） 举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
  • Oracle将零干预分析加入网络即服务计划 蓝儿唯美 oracle
    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
  • spring学习——springmvc（二） a-john springMVC
    Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
  • POJ-2828-Buy Tickets aijuans ACM_POJ
    POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
  • Java Ant build.xml详解 asia007 build.xml
    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
  • android按钮监听器的四种技术 百合不是茶 androidxml配置监听器实现接口
    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;    1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似   创建监听器的实例 myLis lis = new myLis();   使用add方法给按钮添加监听器  
  • 软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。         如今很多的公司
  • TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForgeHow doAttachementAnchorWiki Syntax
    the CollabNet user information center http://help.collab.net/   How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
  • 【Redis四】Redis数据类型 bit1129 redis
    概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
  • SSH2整合-附源码 白糖_ eclipsespringtomcatHibernateGoogle
    今天用eclipse终于整合出了struts2+hibernate+spring框架。 我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。     补充1：项目中部分jar包不是最新版的，可能导
  • [转]开源项目代码的学习方法 braveCS 学习方法
    转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html   1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
  • 编程之美-子数组的最大和（二维） bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美 子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
  • 读书笔记-3 chengxuyuancsdn jquery笔记resultMap配置ibatis一对多配置
    1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置 当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
  • [物理与天文]物理学新进展 comsci
          如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境       怎么办呢?  
  • Oracle 11g新特性:Automatic Diagnostic Repository daizj oracleADR
    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。 在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。 这两份log文
  • 简单排序:选择排序 dieslrae 选择排序
    public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
  • C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
  • php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
    php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php  -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
  • 线程同步工具类 shuizhaosi888 同步工具类
    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）   闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
  • bleeding edge是什么意思 haojinghua DI
    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。  我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。   In computer science, bleeding edge is a term that
  • c中实现utf8和gbk的互转 jimmee ciconvutf8&gbk编码
    #include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
  • 大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
    1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。 应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
  • 在代码中获取Android theme中的attr属性值 OliveExcel androidtheme
    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西.   在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
  • 基于Zookeeper的分布式共享锁 roadrunners zookeeper分布式共享锁
    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。   共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。   官
  • 两个容易被忽略的MySQL知识 tomcat_oracle mysql
    1、varchar(5)可以存储多少个汉字，多少个字母数字？ 　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。 　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
  • zoj 3827 Information Entropy(水题) 阿尔萨斯 format
    题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。 解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他