王道考研--》单链表课后习题C语言代码实现(冲刺)

考研是许多计算机科学专业学生追求高学历、寻求更好就业前景的途径。在考研过程中,数据结构是一个非常重要的科目,而代码实现题更是其中的难点之一。在这篇文章中,我们将探讨如何通过实现数据结构代码问题来提升考研成绩。无论您是否有编程经验,本文将为您提供一些简单但实用的技巧,帮助您应对考研中遇到的数据结构题目。让我们一起踏上这个挑战性的学习旅程吧!

目录

初识单链表

第一题)递归删除不带头节点链表中指定值

第二题)带头节点链表删除指定值

第三题)反向输出链表值

[第四题) 带头节点的单链表删除最小值结点](#第四题) 带头节点的单链表删除最小值结点)

第五题)求两链表交集

第六题)单链表排序

第七题)删除重复结点

第八题)删除绝对值相等的结点


初识单链表

单链表是一种常见的基本数据结构,它由一系列节点组成,每个节点包含两部分:数据(即存储的元素)和指向下一个节点的引用(指针或链接)。单链表中的节点按照其在内存中的位置顺序连接起来,形成一个链式结构。

单链表中的第一个节点称为头节点,最后一个节点的指针部分指向一个空值(通常表示为 null),表示链表的结束。

单链表的特点

1)动态性: 单链表的长度可以动态地增加或减少,不需要预先指定大小。

2)插入与删除高效: 在单链表中,插入或删除元素时只需要修改节点之间的指针,时间复杂度为 O(1)。

3)随机访问效率低: 与数组不同,单链表中的元素并不是在连续的内存空间中存储的,因此难以通过索引进行快速访问,需要从头节点开始按顺序遍历,时间复杂度为 O(n)。

实现单链表通常包括以下步骤(C语言实现):

1)定义节点结构体

首先,需要定义一个结构体来表示链表的节点。这个结构体通常包含两部分:数据成员和指向下一个节点的指针成员。

2)节点的创建与初始化

可以通过动态内存分配(malloc 函数)来创建新的节点,并通过赋值操作对节点中的数据和指针进行初始化。

3)插入与删除节点

可以编写函数来实现在链表中插入新节点或删除现有节点的操作。这些操作通常涉及对节点之间的指针进行调整。

4)遍历与访问

为了能够访问链表中的所有节点,需要使用循环结构或递归来依次访问每个节点,并进行相应的操作。

5)释放内存

在链表不再需要时,需要确保释放所有节点所占用的内存,以避免内存泄漏。

具体代码实现如下

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点的结构体
struct Node {
    int data;
    struct Node* next;
};

// 在链表末尾插入新节点
void appendNode(struct Node** headRef, int newData) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    struct Node* last = *headRef;

    newNode->data = newData;
    newNode->next = NULL;

    if (*headRef == NULL) {
        *headRef = newNode;
        return;
    }

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

    last->next = newNode;
}

// 打印链表中的所有节点数据
void printList(struct Node* node) {
    while (node != NULL) {
        printf("%d -> ", node->data);
        node = node->next;
    }
    printf("NULL\n");
}

int main() {
    // 初始化头节点
    struct Node* head = NULL;

    // 在链表末尾依次插入节点
    appendNode(&head, 1);
    appendNode(&head, 2);
    appendNode(&head, 3);

    // 打印链表
    printf("Linked list: ");
    printList(head);

    return 0;
}

第一题)递归删除不带头节点链表中指定值

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

实现思路如下

首先:代码定义了一个单链表的数据结构,每个节点包含一个整型数据和一个指向下一个节点的指针。
然后:在deleteNodes函数中,首先检查链表是否为空。如果为空,则返回空。否则,递归调用deleteNodes函数,对链表的下一个节点进行删除操作。
接着:在deleteNodes函数中,如果当前节点的数据等于要删除的元素x,那么就删除当前节点。具体操作是,先保存下一个节点的指针,然后释放当前节点的内存,最后返回下一个节点的指针。
最后:在main函数中,首先获取用户输入的单链表长度和元素,然后调用deleteNodes函数删除指定元素,最后打印删除后的单链表结果。

cpp 复制代码
#include <stdio.h>  
#include <stdlib.h>  

struct Node {
    int data;
    struct Node* next;
};

struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("链表为空,请重新创建:\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

void insertNode(struct Node** head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* curr = *head;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
}

struct Node* deleteNodes(struct Node* head, int x) {
    struct Node* prev = NULL;
    struct Node* curr = head;
    while (curr != NULL) {
        if (curr->data == x) {
            if (prev == NULL) {
                head = curr->next;
            }
            else {
                prev->next = curr->next;
            }
            free(curr);
            return head;
        }
        prev = curr;
        curr = curr->next;
    }
    return head;
}

void printList(struct Node* head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = NULL;
    int n, data, x;

    printf("请输入单链表的长度: ");
    if (scanf_s("%d", &n) != 1 || n < 0) {
        printf("输入长度有误!请重新输入:\n");
        return 1;
    }

    printf("请输入单链表的元素: ");
    for (int i = 0; i < n; i++) {
        if (scanf_s("%d", &data) != 1 || data < 0) {
            printf("输入元素有误!请重新输入.\n");
            return 1;
        }
        insertNode(&head, data);
    }

    printf("请输入要删除的元素: ");
    if (scanf_s("%d", &x) != 1 || x < 0) {
        printf("删除元素有误!请重新删除.\n");
        return 1;
    }

    head = deleteNodes(head, x);

    printf("最终的单链表结果为: ");
    printList(head);

    return 0;
}

执行代码结果展示如下:

第二题)带头节点链表删除指定值

在带头节点的单链表 L 中,删除所有值为 x 的结点,并释放其空间,假设值为 x 的结点不唯一,试编写算法以实现上述操作。

实现思路如下

首先:我们定义了单链表的结点结构体,并创建了一个带头节点的单链表。

接着:我们实现了向单链表中插入新结点和删除单链表中所有值为 x 的结点的功能。

然后:在主函数中,我们首先输入单链表的结点个数和值,并将这些值插入到单链表中,输入要删除的结点值,并调用删除结点的函数。

最后:我们打印出删除后的单链表。这样就完成了整体代码的四个步骤。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>

// 定义单链表结点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建带头节点的单链表
Node* createLinkedList() {
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    return head;
}

// 向单链表中插入新结点
void insertNode(Node* head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;

    Node* p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = newNode;
}

// 删除单链表中所有值为 x 的结点
void deleteNodes(Node* head, int x) {
    Node* p = head->next;
    Node* prev = head;

    while (p != NULL) {
        if (p->data == x) {
            Node* temp = p;
            prev->next = p->next;
            p = p->next;
            free(temp);
        }
        else {
            prev = p;
            p = p->next;
        }
    }
}

// 打印单链表
void printLinkedList(Node* head) {
    Node* p = head->next;
    while (p != NULL) {
        printf_s("%d ", p->data);
        p = p->next;
    }
    printf_s("\n");
}

int main() {
    Node* list = createLinkedList();

    // 输入单链表数据
    int n;
    printf_s("请输入单链表的结点个数:");
    scanf_s("%d", &n);

    printf_s("请输入单链表的结点值:\n");
    for (int i = 0; i < n; i++) {
        int value;
        scanf_s("%d", &value);
        insertNode(list, value);
    }

    // 输入要删除的结点值
    int x;
    printf_s("请输入要删除的结点值:");
    scanf_s("%d", &x);

    // 删除值为 x 的结点
    deleteNodes(list, x);

    // 打印删除后的单链表
    printf_s("删除后的单链表:");
    printLinkedList(list);

    return 0;
}

执行代码结果展示如下:

第三题)反向输出链表值

设L为带头节点的单链表,编写算法实现从尾到头反向输出每个结点的值。

实现思路如下

首先:程序定义了一个Link结构体,用于表示链表的节点,每个节点包含一个整数数据和一个指向下一个节点的指针。

接着:在函数reverseOutput中,首先判断传入的链表节点指针是否为空,如果为空,则直接返回。否则,递归地调用reverseOutput函数,并传入该节点的下一个节点指针。这样可以先逆序输出链表后面的节点。

然后:在递归调用之后,打印当前节点的数据,用printf_s函数输出。

最后:在main函数中,首先读取用户输入的创建链表的节点个数。然后定义两个指针变量q和head,其中q用于指向链表的头指针,head用于指向最新的节点。接下来,通过循环创建链表的节点,每次循环创建一个新的节点,让head->next指向新节点,然后将head指向新节点,以保证head始终指向最新的节点。最后,将链表的最后一个节点的next指针置为NULL,将head重新指向q,即将head指向链表头节点。最后,调用reverseOutput函数输出逆序的链表元素。最后,返回0表示程序正常结束。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>

struct Link {
	int data;
	struct Link* next;
};

void reverseOutput(Link* p) {
	if (p == NULL) return;
	else {
		reverseOutput(p->next);
		printf_s("%d ", p->data);
	}
}

int main() {
	int n, data;
	printf_s("请输入创建链表的结点个数:");
	scanf_s("%d", &n);
	struct Link* q;
	struct Link* head = (struct Link*)malloc(sizeof(struct Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++)
	{
		struct Link* newP = (struct Link*)malloc(sizeof(struct Link));
		printf_s("请输入第 %d 个结点的值:",i+1);
		scanf_s("%d", &data);
		newP->data = data;
		newP->next = NULL;
		head->next = newP;
		head = head->next; // head要始终指向最新节点
	}
	head->next = NULL;
	head = q; // 最后head要指向头结点
	reverseOutput(head->next);
	return 0;
}

执行代码结果展示如下:

第四题) 带头节点的单链表删除最小值结点

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

实现思路如下

首先:代码定义了一个链表结点结构体 Node,其中包含数据域 data 和指向下一个结点的指针next。

接着:通过createLinkedList函数创建了一个带头结点的单链表。在函数内部,我们使用malloc函数为头结点分配内存,并将头结点的next指针指向NULL,表示链表为空。

然后:使用insertNode函数向链表中插入新节点。该函数接受一个链表头结点指针head和要插入的值value作为参数。在函数内部,我们首先创建一个新的结点newNode,并为其分配内存。然后,我们遍历链表,找到链表的尾部结点,将新节点插入到尾部结点的next指针处。

最后:通过deleteMinNode函数删除链表中的最小值结点。该函数接受链表头结点指针head作为参数。在函数内部,我们使用两个指针prev和curr来遍历链表,找到最小值结点以及其前一个结点。然后,我们将最小值结点的前一个结点的`next`指针指向最小值结点的下一个结点,并释放最小值结点的内存。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>

// 定义链表结点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建带头结点的单链表
Node* createLinkedList() {
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    return head;
}

// 向链表中插入新节点
void insertNode(Node* head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    Node* curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
}

// 删除最小值结点
void deleteMinNode(Node* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    Node* prev = head;
    Node* curr = head->next;
    Node* minPrev = prev; // 最小值结点的前一个结点
    Node* minNode = curr; // 最小值结点
    while (curr != NULL) {
        if (curr->data < minNode->data) {
            minPrev = prev;
            minNode = curr;
        }
        prev = curr;
        curr = curr->next;
    }
    minPrev->next = minNode->next;
    free(minNode);
}

// 打印链表
void printLinkedList(Node* head) {
    if (head == NULL || head->next == NULL) {
        printf("链表为空\n");
        return;
    }
    Node* curr = head->next;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

int main() {
    Node* L = createLinkedList();

    int n;  // 链表长度
    printf("请输入链表的长度:");
    scanf_s("%d", &n);

    printf("请输入链表的元素:\n");
    for (int i = 0; i < n; i++) {
        int value;
        scanf_s("%d", &value);
        insertNode(L, value);
    }

    printf("原始链表:");
    printLinkedList(L);

    deleteMinNode(L);

    printf("删除最小值结点后的链表:");
    printLinkedList(L);

    return 0;
}

执行代码结果展示如下:

第五题)求两链表交集

已知两个链表A和B分别表示两个集合,其元素递增排序。编制函数,求A与B的交集,并存放于A链表中。

实现思路如下

首先:通过createLinkedList函数创建了两个带头结点的单链表A和B。该函数分配了内存空间,并将头结点的next指针指向NULL,表示链表为空。

接着:使用scanf_s函数获取用户输入的整数n和m,分别表示链表A和B的长度。

然后:调用findIntersection函数,传入A链表和B链表作为参数。该函数用于找到A链表和B链表的交集,并将结果存放在A链表中。

最后:通过printLinkedList函数分别打印出原始的A和B链表以及交集结果。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建带头结点的单链表
Node* createLinkedList() {
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    return head;
}

// 向链表中插入新节点
void insertNode(Node* head, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    Node* curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
}

// 求两个递增排序链表的交集,并将结果存放于A链表中
void findIntersection(Node* A, Node* B) {
    Node* currA = A->next;
    Node* currB = B->next;
    Node* prevA = A;
    Node* temp;

    while (currA != NULL && currB != NULL) {
        if (currA->data < currB->data) {
            prevA->next = currA->next;
            temp = currA;
            currA = currA->next;
            free(temp);
        }
        else if (currA->data > currB->data) {
            currB = currB->next;
        }
        else {
            prevA = currA;
            currA = currA->next;
            currB = currB->next;
        }
    }

    while (currA != NULL) {
        prevA->next = currA->next;
        temp = currA;
        currA = currA->next;
        free(temp);
    }
}

// 打印链表
void printLinkedList(Node* head) {
    if (head == NULL || head->next == NULL) {
        printf("链表为空\n");
        return;
    }
    Node* curr = head->next;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

int main() {
    Node* A = createLinkedList();
    Node* B = createLinkedList();

    int n, m; // A链表长度和B链表长度
    printf("请输入A链表的长度:");
    scanf_s("%d", &n);
    printf("请输入A链表的元素(递增排序):\n");
    for (int i = 0; i < n; i++) {
        int value;
        scanf_s("%d", &value);
        insertNode(A, value);
    }

    printf("请输入B链表的长度:");
    scanf_s("%d", &m);
    printf("请输入B链表的元素(递增排序):\n");
    for (int i = 0; i < m; i++) {
        int value;
        scanf_s("%d", &value);
        insertNode(B, value);
    }

    printf("原始A链表:");
    printLinkedList(A);
    printf("原始B链表:");
    printLinkedList(B);

    findIntersection(A, B);

    printf("A与B的交集结果:");
    printLinkedList(A);

    return 0;
}

执行代码结果展示如下:

第六题)单链表排序

有一个带头结点的单链表L,设计一个算法使其元素递增有序。

实现思路如下

首先:定义了链表节点结构体ListNode,包含数据域和指向下一个节点的指针。

接着:实现了创建新节点的函数createNewNode,用于分配内存并初始化新节点。

然后:实现了将元素插入有序链表的函数insertInOrder,根据元素大小找到合适的位置插入新节点,并保持链表的有序性。

最后:在主函数中,通过用户输入创建带头结点的链表L,并调用insertInOrder将输入的元素按递增顺序插入链表中,最后打印排列后的链表内容。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
typedef struct ListNode {
    int data;
    struct ListNode* next;
} ListNode;

// 创建新节点
ListNode* createNewNode(int data) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 将元素插入有序链表中
void insertInOrder(ListNode** head, int data) {
    ListNode* newNode = createNewNode(data);

    // 如果链表为空或者新节点的值小于头结点的值,则将新节点作为头结点
    if (*head == NULL || data < (*head)->data) {
        newNode->next = *head;
        *head = newNode;
    }
    else {
        ListNode* curr = *head;

        // 找到适当的位置插入新节点
        while (curr->next != NULL && data > curr->next->data) {
            curr = curr->next;
        }

        newNode->next = curr->next;
        curr->next = newNode;
    }
}

// 打印链表的内容
void printLinkedList(ListNode* head) {
    ListNode* curr = head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

// 从键盘读取用户输入的整数
int readInt() {
    int num;
    scanf_s("%d", &num);
    return num;
}

// 主函数
int main() {
    // 创建带头结点的链表L
    ListNode* L = createNewNode(0);
    printf("请输入链表L的元素个数:");
    int n = readInt();
    for (int i = 0; i < n; i++) {
        printf("请输入第%d个元素:", i + 1);
        int data = readInt();
        insertInOrder(&L, data);
    }

    printf("排列后的链表L: ");
    printLinkedList(L->next);

    return 0;
}

执行代码结果展示如下:

第七题)删除重复结点

设计一个算法完成以下功能:在单链表中删除重复结点。

实现思路如下

首先:定义了链表节点的结构体。

接着:实现了创建新节点的函数和打印链表的函数。

然后:实现了删除重复节点的函数。该函数通过遍历链表,对于每一个节点,再次遍历链表来找到并删除与当前节点数据相同的节点。

最后:实现了主函数。在主函数中,首先要求用户输入链表的元素个数和具体数值,然后根据输入创建一个单链表。接着调用删除重复节点的函数,再打印出删除重复节点后的链表。最后,释放链表内存。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
typedef struct ListNode {
    int data;
    struct ListNode* next;
} ListNode;

// 创建新节点
ListNode* createNewNode(int data) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 打印链表
void printList(ListNode* head) {
    ListNode* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 删除重复节点
void removeDuplicates(ListNode* head) {
    if (head == NULL) {
        return;
    }

    ListNode* current = head;
    while (current != NULL) {
        ListNode* runner = current;
        while (runner->next != NULL) {
            if (runner->next->data == current->data) {
                ListNode* duplicate = runner->next;
                runner->next = runner->next->next;
                free(duplicate);
            }
            else {
                runner = runner->next;
            }
        }
        current = current->next;
    }
}

// 释放链表内存
void freeList(ListNode* head) {
    ListNode* current = head;
    while (current != NULL) {
        ListNode* temp = current;
        current = current->next;
        free(temp);
    }
}

// 主函数
int main() {
    int n;
    printf("请输入链表元素个数:");
    scanf_s("%d", &n);

    ListNode* head = NULL;
    ListNode* tail = NULL;

    printf("请输入链表元素值:");
    for (int i = 0; i < n; i++) {
        int data;
        scanf_s("%d", &data);

        ListNode* newNode = createNewNode(data);

        if (head == NULL) {
            head = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
    }

    printf("原链表:");
    printList(head);

    removeDuplicates(head);

    printf("删除重复节点后的链表:");
    printList(head);

    // 释放链表内存
    freeList(head);

    return 0;
}

执行代码结果展示如下:

第八题)删除绝对值相等的结点

设计一个算法完成以下功能:在单链表中删除绝对值相等的元素。

实现思路如下

首先:定义了一个链表节点的结构体,并实现了创建新节点、打印链表、删除绝对值相等节点和释放链表内存的函数。

接着:主函数中要求用户输入链表元素的个数和具体数值,然后根据输入创建一个单链表。

然后:调用removeAbsoluteDuplicates函数来删除链表中绝对值相等的节点。

最后:打印出删除绝对值相等节点后的链表,并释放链表的内存。

cpp 复制代码
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// 定义链表节点结构体
typedef struct ListNode {
    int data;
    struct ListNode* next;
} ListNode;

// 创建新节点
ListNode* createNewNode(int data) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 打印链表
void printList(ListNode* head) {
    ListNode* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 删除绝对值相等节点
void removeAbsoluteDuplicates(ListNode* head) {
    if (head == NULL) {
        return;
    }

    ListNode* current = head;
    while (current != NULL && current->next != NULL) {
        ListNode* runner = current;

        while (runner->next != NULL) {
            if (abs(runner->next->data) == abs(current->data)) {
                ListNode* duplicate = runner->next;
                runner->next = runner->next->next;
                free(duplicate);
            }
            else {
                runner = runner->next;
            }
        }
        current = current->next;
    }
}

// 释放链表内存
void freeList(ListNode* head) {
    ListNode* current = head;
    while (current != NULL) {
        ListNode* temp = current;
        current = current->next;
        free(temp);
    }
}

// 主函数
int main() {
    int n;
    printf("请输入链表元素个数:");
    scanf_s("%d", &n);

    ListNode* head = NULL;
    ListNode* tail = NULL;

    printf("请输入链表元素值:");
    for (int i = 0; i < n; i++) {
        int data;
        scanf_s("%d", &data);

        ListNode* newNode = createNewNode(data);

        if (head == NULL) {
            head = newNode;
            tail = newNode;
        }
        else {
            tail->next = newNode;
            tail = newNode;
        }
    }

    printf("原链表:");
    printList(head);

    removeAbsoluteDuplicates(head);

    printf("删除绝对值相等节点后的链表:");
    printList(head);

    // 释放链表内存
    freeList(head);

    return 0;
}

执行代码结果展示如下:

相关推荐
励志要当大牛的小白菜13 分钟前
ART配对软件使用
开发语言·c++·qt·算法
qq_5139704417 分钟前
力扣 hot100 Day56
算法·leetcode
PAK向日葵1 小时前
【算法导论】如何攻克一道Hard难度的LeetCode题?以「寻找两个正序数组的中位数」为例
c++·算法·面试
爱装代码的小瓶子3 小时前
数据结构之队列(C语言)
c语言·开发语言·数据结构
VB5943 小时前
《考研 考证 各学科 各专业 思维导图汇总》PDF 5.2GB
考研·pdf
爱喝矿泉水的猛男3 小时前
非定长滑动窗口(持续更新)
算法·leetcode·职场和发展
YuTaoShao3 小时前
【LeetCode 热题 100】131. 分割回文串——回溯
java·算法·leetcode·深度优先
YouQian7724 小时前
Traffic Lights set的使用
算法
快乐飒男4 小时前
哈希表(c语言)
c语言·哈希算法·散列表
go54631584655 小时前
基于深度学习的食管癌右喉返神经旁淋巴结预测系统研究
图像处理·人工智能·深度学习·神经网络·算法