线性表代码基本例题及详细解释（1）

已于 2024-10-08 23:27:27 修改
阅读量438 收藏 5
点赞数 19
文章标签： windows
于 2024-10-08 23:06:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79456294/article/details/142769924
版权

目录

1.编写算法查找顺序表中值最小的结点,并删除该结点。

2.编写算法查找单链表中值最大的结点,并将该结点移至链表尾部。

3.编写算法实现顺序表的就地逆置,即利用原表的存储空间将线性表（a1，a2，...an) 逆置为(an,an-1...1) ,并分析设计的算法时间复杂度。

4.编写算法实现链表的就地逆置,即利用原表的存储空间将线性表 逆置为 ,并分析设计的算法时间复杂度。

1.编写算法查找顺序表中值最小的结点,并删除该结点。

具体代码

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

#define MAX_SIZE 100 // 最大容量

// 顺序表类型定义
typedef struct {
int data[MAX_SIZE]; // 存储数据的数组
int length; // 当前长度
} SeqList;

// 初始化顺序表
void initSeqList(SeqList *list) {
list->length = 0;
}

// 插入元素到顺序表
void insertElement(SeqList *list, int value) {
if (list->length >= MAX_SIZE) {
printf("Sequence list is full.\n");
return;
}
list->data[list->length++] = value;
}

// 查找并删除顺序表中值最小的节点
void removeMin(SeqList *list) {
if (list->length == 0) {
printf("Sequence list is empty.\n");
return;
}

int minIndex = 0; // 默认第一个元素是最小值
for (int i = 1; i < list->length; i++) {
if (list->data[i] < list->data[minIndex]) {
minIndex = i;
}
}

// 删除最小值节点
for (int i = minIndex; i < list->length - 1; i++) {
list->data[i] = list->data[i + 1];
}
list->length--;
}

// 打印顺序表的内容
void printSeqList(const SeqList *list) {
for (int i = 0; i < list->length; i++) {
printf("%d ", list->data[i]);
}
printf("\n");
}
int main() {
SeqList list;
initSeqList(&list);
// 用户输入顺序表中的元素
int n;
printf("Enter the number of elements in the sequence list: ");
scanf("%d", &n);
if (n > MAX_SIZE) {
printf("Too many elements!\n");
return 1;
}
printf("Enter the elements of the sequence list:\n");
for (int i = 0; i < n; i++) {
int value;
scanf("%d", &value);
insertElement(&list, value);
}
printf("Original sequence list: ");
printSeqList(&list);
// 移除顺序表中最小的元素
removeMin(&list);
printf("Sequence list after removing the minimum element: ");
printSeqList(&list);
return 0;
}详细解释该代码

详细解释：

数据结构定义

// 顺序表类型定义
typedef struct {
    int data[MAX_SIZE]; // 存储数据的数组
    int length; // 当前长度
} SeqList;
  • data[MAX_SIZE]：一个固定大小的数组，用于存储顺序表中的元素。
  • length：记录当前顺序表中元素的数量。

初始化顺序表

// 初始化顺序表
void initSeqList(SeqList *list) {
    list->length = 0;
}
  • 将顺序表的长度初始化为0，表示顺序表为空。
  • list 是一个 SeqList 类型的变量，用于表示一个顺序表。它包含一个固定大小的数组 data 和一个记录当前长度的整数 length。

插入元素到顺序表

// 插入元素到顺序表
void insertElement(SeqList *list, int value) {
    if (list->length >= MAX_SIZE) {
        printf("Sequence list is full.\n");
        return;
    }
    list->data[list->length++] = value;
}
  • 检查顺序表是否已满（即 length 是否达到 MAX_SIZE）。如果已满，输出提示信息并返回。
  • 否则，将新元素插入到顺序表的末尾，并增加 length。

查找并删除顺序表中值最小的节点

// 查找并删除顺序表中值最小的节点
void removeMin(SeqList *list) {
    if (list->length == 0) {
        printf("Sequence list is empty.\n");
        return;
    }

    int minIndex = 0; // 默认第一个元素是最小值
    for (int i = 1; i < list->length; i++) {
        if (list->data[i] < list->data[minIndex]) {
            minIndex = i;
        }
    }

    // 删除最小值节点
    for (int i = minIndex; i < list->length - 1; i++) {
        list->data[i] = list->data[i + 1];
    }
    list->length--;
}
  • 检查顺序表是否为空。如果为空，输出提示信息并返回。
  • 初始化 minIndex 为0，表示默认第一个元素是最小值。
  • 遍历顺序表，找到最小值的索引 minIndex。
  • 使用循环将最小值后的所有元素向前移动一位，覆盖掉最小值。
  • 减少 length，表示顺序表中元素数量减少一个。

打印顺序表的内容

// 打印顺序表的内容
void printSeqList(const SeqList *list) {
    for (int i = 0; i < list->length; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}
  • 遍历顺序表中的所有元素，并逐个打印。
  • 打印完所有元素后，输出一个换行符。

主函数

int main() {
    SeqList list;
    initSeqList(&list);

    // 用户输入顺序表中的元素
    int n;
    printf("Enter the number of elements in the sequence list: ");
    scanf("%d", &n);
    if (n > MAX_SIZE) {
        printf("Too many elements!\n");
        return 1;
    }
    printf("Enter the elements of the sequence list:\n");
    for (int i = 0; i < n; i++) {
        int value;
        scanf("%d", &value);
        insertElement(&list, value);
    }

    printf("Original sequence list: ");
    printSeqList(&list);

    // 移除顺序表中最小的元素
    removeMin(&list);

    printf("Sequence list after removing the minimum element: ");
    printSeqList(&list);

    return 0;
}
  • 初始化一个顺序表 list。
  • 提示用户输入顺序表中元素的数量 n，并检查是否超过最大容量 MAX_SIZE。
  • 提示用户输入顺序表中的每个元素，并调用 insertElement 函数将其插入到顺序表中。
  • 打印原始顺序表的内容。
  • 调用 removeMin 函数删除顺序表中最小的元素。
  • 再次打印顺序表的内容，显示删除最小元素后的结果。
  • 返回0，表示程序正常结束。

示例运行

假设用户输入以下数据：

Enter the number of elements in the sequence list: 5
Enter the elements of the sequence list:
3 1 4 1 5
Original sequence list: 3 1 4 1 5 
Sequence list after removing the minimum element: 3 4 1 5

在这个示例中：

  • 用户输入了5个元素 [3, 1, 4, 1, 5]。
  • 原始顺序表为 [3, 1, 4, 1, 5]。
  • 删除最小元素 1 后，顺序表变为 [3, 4, 1, 5]。

2.编写算法查找单链表中值最大的结点,并将该结点移至链表尾部。

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

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

// 单链表定义
typedef struct {
Node *head;
} LinkedList;

// 初始化链表
void initLinkedList(LinkedList *list) {
list->head = NULL;
}

// 在链表尾部插入节点
void insertAtTail(LinkedList *list, int value) {
Node *newNode = (Node *)malloc(sizeof(Node));
if (!newNode) {
printf("Memory error\n");
return;
}
newNode->data = value;
newNode->next = NULL;

if (list->head == NULL) {
list->head = newNode;
} else {
Node *temp = list->head;
while (temp->next != NULL) {
temp = temp->next;
}
temp->next = newNode;
}
}

// 查找并移动最大值节点到链表尾部
void moveMaxToTail(LinkedList *list) {
if (list->head == NULL || list->head->next == NULL) {
return; // 如果链表为空或只有一个元素，则无需处理
}

Node *maxNode = list->head;
Node *prevMax = NULL;
Node *current = list->head;
Node *prev = NULL;

// 寻找最大值节点及其前一个节点
while (current != NULL) {
if (current->data > maxNode->data) {
maxNode = current;
prevMax = prev;
}
prev = current;
current = current->next;
}

// 如果最大值不是最后一个节点，删除它
if (maxNode != list->head && prevMax != NULL) {
prevMax->next = maxNode->next;
} else if (maxNode == list->head) {
list->head = list->head->next;
}

// 将最大值节点移到链表尾部
Node *tail = list->head;
while (tail->next != NULL) {
tail = tail->next;
}
tail->next = maxNode;
maxNode->next = NULL;
}

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

int main() {
LinkedList list;
initLinkedList(&list);

// 用户输入链表中的元素
int n;
printf("Enter the number of elements in the linked list: ");
scanf("%d", &n);

printf("Enter the elements of the linked list:\n");
for (int i = 0; i < n; i++) {
int value;
scanf("%d", &value);
insertAtTail(&list, value);
}

printf("Original linked list: ");
printLinkedList(&list);

moveMaxToTail(&list);

printf("Linked list after moving the maximum element to the tail: ");
printLinkedList(&list);

// 清理内存
Node *current = list.head;
while (current != NULL) {
Node *temp = current;
current = current->next;
free(temp);
}

return 0;
}

详细解释：

数据结构定义

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

// 单链表定义
typedef struct {
    Node *head;
} LinkedList;
  • Node 结构体定义了一个链表节点，包含两个成员：
    • int data：存储节点的数据。
    • struct Node *next：指向下一个节点的指针。
  • LinkedList 结构体定义了一个链表，包含一个成员：
    • Node *head：指向链表头节点的指针。

初始化链表

// 初始化链表
void initLinkedList(LinkedList *list) {
    list->head = NULL;
}
  • 将链表的头节点初始化为 NULL，表示链表为空。

在链表尾部插入节点

// 在链表尾部插入节点
void insertAtTail(LinkedList *list, int value) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (!newNode) {
        printf("Memory error\n");
        return;
    }
    newNode->data = value;
    newNode->next = NULL;

    if (list->head == NULL) {
        list->head = newNode;
    } else {
        Node *temp = list->head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}
  • 创建一个新的节点 newNode，并分配内存。
  • 将新节点的数据设置为 value，并将 next 指针设置为 NULL。
  • 如果链表为空（即 head 为 NULL），将新节点设置为头节点。
  • 否则，遍历链表找到最后一个节点，并将新节点链接到最后一个节点的 next 指针上。

查找并移动最大值节点到链表尾部

// 查找并移动最大值节点到链表尾部
void moveMaxToTail(LinkedList *list) {
    if (list->head == NULL || list->head->next == NULL) {
        return; // 如果链表为空或只有一个元素，则无需处理
    }

    Node *maxNode = list->head;
    Node *prevMax = NULL;
    Node *current = list->head;
    Node *prev = NULL;

    // 寻找最大值节点及其前一个节点
    while (current != NULL) {
        if (current->data > maxNode->data) {
            maxNode = current;
            prevMax = prev;
        }
        prev = current;
        current = current->next;
    }

    // 如果最大值不是最后一个节点，删除它
    if (maxNode != list->head && prevMax != NULL) {
        prevMax->next = maxNode->next;
    } else if (maxNode == list->head) {
        list->head = list->head->next;
    }

    // 将最大值节点移到链表尾部
    Node *tail = list->head;
    while (tail->next != NULL) {
        tail = tail->next;
    }
    tail->next = maxNode;
    maxNode->next = NULL;
}
  • 检查链表是否为空或只有一个节点，如果是，则直接返回。
  • 初始化 maxNode 为头节点，prevMax 为 NULL，current 为头节点，prev 为 NULL。
  • 遍历链表，找到最大值节点 maxNode 及其前一个节点 prevMax。
  • 如果最大值节点不是头节点且有前一个节点，将 prevMax 的 next 指针指向 maxNode 的下一个节点，从而删除 maxNode。
  • 如果最大值节点是头节点，将头节点更新为 head 的下一个节点。
  • 遍历链表找到最后一个节点 tail，将 maxNode 链接到 tail 的 next 指针上，并将 maxNode 的 next 指针设置为 NULL。

打印链表的内容

// 打印链表的内容
void printLinkedList(const LinkedList *list) {
    Node *temp = list->head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}
  • 遍历链表，逐个打印每个节点的数据。
  • 打印完所有节点后，输出一个换行符。

主函数

int main() {
    LinkedList list;
    initLinkedList(&list);

    // 用户输入链表中的元素
    int n;
    printf("Enter the number of elements in the linked list: ");
    scanf("%d", &n);

    printf("Enter the elements of the linked list:\n");
    for (int i = 0; i < n; i++) {
        int value;
        scanf("%d", &value);
        insertAtTail(&list, value);
    }

    printf("Original linked list: ");
    printLinkedList(&list);

    moveMaxToTail(&list);

    printf("Linked list after moving the maximum element to the tail: ");
    printLinkedList(&list);

    // 清理内存
    Node *current = list.head;
    while (current != NULL) {
        Node *temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}
  • 初始化一个链表 list。
  • 提示用户输入链表中元素的数量 n。
  • 提示用户输入链表中的每个元素，并调用 insertAtTail 函数将其插入到链表中。
  • 打印原始链表的内容。
  • 调用 moveMaxToTail 函数将最大值节点移动到链表尾部。
  • 再次打印链表的内容，显示移动最大值节点后的结果。
  • 清理链表中所有节点的内存，防止内存泄漏。

示例运行

假设用户输入以下数据：

Enter the number of elements in the linked list: 5
Enter the elements of the linked list:
3 1 4 1 5
Original linked list: 3 -> 1 -> 4 -> 1 -> 5 -> NULL
Linked list after moving the maximum element to the tail: 3 -> 1 -> 4 -> 1 -> 5 -> NULL

在这个示例中：

  • 用户输入了5个元素 [3, 1, 4, 1, 5]。
  • 原始链表为 3 -> 1 -> 4 -> 1 -> 5 -> NULL。
  • 移动最大值节点 5 到链表尾部后，链表变为 3 -> 1 -> 4 -> 1 -> 5 -> NULL。、

3.编写算法实现顺序表的就地逆置,即利用原表的存储空间将线性表（a1，a2，...an) 逆置为(an,an-1...1) ,并分析设计的算法时间复杂度。

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

#define MAX_SIZE 100 

// 顺序表类型定义
typedef struct {
int data[MAX_SIZE]; 
int length; 
} SeqList;

// 初始化顺序表
void initSeqList(SeqList *list) {
list->length = 0;
}

// 插入元素到顺序表
void insertElement(SeqList *list, int value) {
if (list->length >= MAX_SIZE) {
printf("Sequence list is full.\n");
return;
}
list->data[list->length++] = value;
}

// 就地逆置顺序表
void reverseSeqList(SeqList *list) {
if (list->length <= 1) {
return; // 如果链表为空或只有一个元素，则无需处理
}

int left = 0; // 左端索引
int right = list->length - 1; // 右端索引

while (left < right) {
// 交换两端元素
int temp = list->data[left];
list->data[left] = list->data[right];
list->data[right] = temp;

// 向中间靠拢
left++;
right--;
}
}

// 打印顺序表的内容
void printSeqList(const SeqList *list) {
for (int i = 0; i < list->length; i++) {
printf("%d ", list->data[i]);
}
printf("\n");
}

int main() {
SeqList list;
initSeqList(&list);

// 用户输入顺序表中的元素
int n;
printf("Enter the number of elements in the sequence list: ");
scanf("%d", &n);

if (n > MAX_SIZE) {
printf("Too many elements!\n");
return 1;
}

printf("Enter the elements of the sequence list:\n");
for (int i = 0; i < n; i++) {
int value;
scanf("%d", &value);
insertElement(&list, value);
}

printf("Original sequence list: ");
printSeqList(&list);

reverseSeqList(&list);

printf("Reversed sequence list: ");
printSeqList(&list);

return 0;
}

详细解释：

数据结构定义

// 顺序表类型定义
typedef struct {
    int data[MAX_SIZE]; // 存储数据的数组
    int length; // 当前长度
} SeqList;
  • int data[MAX_SIZE];：一个固定大小的数组，用于存储顺序表中的元素。MAX_SIZE 是一个宏定义，表示数组的最大容量。
  • int length;：一个整数，用于记录当前顺序表中实际存储的元素数量。

初始化顺序表

int data[MAX_SIZE];：一个固定大小的数组，用于存储顺序表中的元素。MAX_SIZE 是一个宏定义，表示数组的最大容量。
int length;：一个整数，用于记录当前顺序表中实际存储的元素数量。
初始化顺序表
  • 将顺序表的长度初始化为0，表示顺序表为空。

插入元素到顺序表

// 插入元素到顺序表
void insertElement(SeqList *list, int value) {
    if (list->length >= MAX_SIZE) {
        printf("Sequence list is full.\n");
        return;
    }
    list->data[list->length++] = value;
}
  • 检查顺序表是否已满（即 length 是否达到 MAX_SIZE）。如果已满，输出提示信息并返回。
  • 否则，将新元素插入到顺序表的末尾，并增加 length。

就地逆置顺序表

// 就地逆置顺序表
void reverseSeqList(SeqList *list) {
    if (list->length <= 1) {
        return; // 如果链表为空或只有一个元素，则无需处理
    }

    int left = 0; // 左端索引
    int right = list->length - 1; // 右端索引

    while (left < right) {
        // 交换两端元素
        int temp = list->data[left];
        list->data[left] = list->data[right];
        list->data[right] = temp;

        // 向中间靠拢
        left++;
        right--;
    }
}
  • 检查顺序表是否为空或只有一个元素，如果是，则直接返回。
  • 初始化左端索引 left 为0，右端索引 right 为 length - 1。
  • 使用 while 循环，当 left 小于 right 时，交换 left 和 right 位置的元素，并将 left 和 right 向中间靠拢。
  • 循环结束后，顺序表中的元素已经被逆置。

打印顺序表的内容

// 打印顺序表的内容
void printSeqList(const SeqList *list) {
    for (int i = 0; i < list->length; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

  • 遍历顺序表中的所有元素，并逐个打印。
  • 打印完所有元素后，输出一个换行符。

主函数

int main() {
    SeqList list;
    initSeqList(&list);

    // 用户输入顺序表中的元素
    int n;
    printf("Enter the number of elements in the sequence list: ");
    scanf("%d", &n);

    if (n > MAX_SIZE) {
        printf("Too many elements!\n");
        return 1;
    }

    printf("Enter the elements of the sequence list:\n");
    for (int i = 0; i < n; i++) {
        int value;
        scanf("%d", &value);
        insertElement(&list, value);
    }

    printf("Original sequence list: ");
    printSeqList(&list);

    reverseSeqList(&list);

    printf("Reversed sequence list: ");
    printSeqList(&list);

    return 0;
}
  • 初始化一个顺序表 list。
  • 提示用户输入顺序表中元素的数量 n，并检查是否超过最大容量 MAX_SIZE。
  • 提示用户输入顺序表中的每个元素，并调用 insertElement 函数将其插入到顺序表中。
  • 打印原始顺序表的内容。
  • 调用 reverseSeqList 函数逆置顺序表。
  • 再次打印顺序表的内容，显示逆置后的结果。
  • 返回0，表示程序正常结束。

示例运行

假设用户输入以下数据：

Enter the number of elements in the sequence list: 5
Enter the elements of the sequence list:
3 1 4 1 5
Original sequence list: 3 1 4 1 5 
Reversed sequence list: 5 1 4 1 3

在这个示例中：

  • 用户输入了5个元素 [3, 1, 4, 1, 5]。
  • 原始顺序表为 3 1 4 1 5。
  • 逆置顺序表后，顺序表变为 5 1 4 1 3。

4.编写算法实现链表的就地逆置,即利用原表的存储空间将线性表 逆置为 ,并分析设计的算法时间复杂度。

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

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

// 链表定义
typedef struct {
Node *head;
} LinkedList;

// 初始化链表
void initLinkedList(LinkedList *list) {
list->head = NULL;
}

// 在链表尾部插入节点
void insertAtTail(LinkedList *list, int value) {
Node *newNode = (Node *)malloc(sizeof(Node));
if (!newNode) {
printf("Memory error\n");
return;
}
newNode->data = value;
newNode->next = NULL;

if (list->head == NULL) {
list->head = newNode;
} else {
Node *temp = list->head;
while (temp->next != NULL) {
temp = temp->next;
}
temp->next = newNode;
}
}

// 就地逆置链表
void reverseLinkedList(LinkedList *list) {
if (list->head == NULL || list->head->next == NULL) {
return; // 如果链表为空或只有一个元素，则无需处理
}

Node *prev = NULL;
Node *current = list->head;
Node *next = NULL;

while (current != NULL) {
next = current->next; // 保存下一个节点
current->next = prev; // 反转当前节点的指针
prev = current; // 移动 prev 和 current
current = next;
}

list->head = prev; // 更新头节点
}

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

int main() {
LinkedList list;
initLinkedList(&list);

// 用户输入链表中的元素
int n;
printf("Enter the number of elements in the linked list: ");
scanf("%d", &n);

printf("Enter the elements of the linked list:\n");
for (int i = 0; i < n; i++) {
int value;
scanf("%d", &value);
insertAtTail(&list, value);
}

printf("Original linked list: ");
printLinkedList(&list);

reverseLinkedList(&list);

printf("Reversed linked list: ");
printLinkedList(&list);

// 清理内存
Node *current = list.head;
while (current != NULL) {
Node *temp = current;
current = current->next;
free(temp);
}

return 0;
}

详细解释：

数据结构定义

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

// 链表定义
typedef struct {
    Node *head;
} LinkedList;
  • Node 结构体定义了一个链表节点，包含两个成员：
    • int data：存储节点的数据。
    • struct Node *next：指向下一个节点的指针。
  • LinkedList 结构体定义了一个链表，包含一个成员：
    • Node *head：指向链表头节点的指针。

初始化链表

// 初始化链表
void initLinkedList(LinkedList *list) {
    list->head = NULL;
}
  • 将链表的头节点初始化为 NULL，表示链表为空。

在链表尾部插入节点

// 在链表尾部插入节点
void insertAtTail(LinkedList *list, int value) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (!newNode) {
        printf("Memory error\n");
        return;
    }
    newNode->data = value;
    newNode->next = NULL;

    if (list->head == NULL) {
        list->head = newNode;
    } else {
        Node *temp = list->head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}
  • 创建一个新的节点 newNode，并分配内存。
  • 将新节点的数据设置为 value，并将 next 指针设置为 NULL。
  • 如果链表为空（即 head 为 NULL），将新节点设置为头节点。
  • 否则，遍历链表找到最后一个节点，并将新节点链接到最后一个节点的 next 指针上。

就地逆置链表

// 就地逆置链表
void reverseLinkedList(LinkedList *list) {
    if (list->head == NULL || list->head->next == NULL) {
        return; // 如果链表为空或只有一个元素，则无需处理
    }

    Node *prev = NULL;
    Node *current = list->head;
    Node *next = NULL;

    while (current != NULL) {
        next = current->next; // 保存下一个节点
        current->next = prev; // 反转当前节点的指针
        prev = current; // 移动 prev 和 current
        current = next;
    }

    list->head = prev; // 更新头节点
}
  • 检查链表是否为空或只有一个节点，如果是，则直接返回。
  • 初始化三个指针：
    • prev：前一个节点，初始为 NULL。
    • current：当前节点，初始为头节点。
    • next：下一个节点，初始为 NULL。
  • 使用 while 循环遍历链表：
    • 保存当前节点的下一个节点 next。
    • 将当前节点的 next 指针指向 prev，实现反转。
    • 移动 prev 和 current 指针。
  • 循环结束后，将 prev 设置为新的头节点。

打印链表的内容

// 打印链表的内容
void printLinkedList(const LinkedList *list) {
    Node *temp = list->head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}
  • 历链表，逐个打印每个节点的数据。
  • 打印完所有节点后，输出一个换行符。

主函数

int main() {
    LinkedList list;
    initLinkedList(&list);

    // 用户输入链表中的元素
    int n;
    printf("Enter the number of elements in the linked list: ");
    scanf("%d", &n);

    printf("Enter the elements of the linked list:\n");
    for (int i = 0; i < n; i++) {
        int value;
        scanf("%d", &value);
        insertAtTail(&list, value);
    }

    printf("Original linked list: ");
    printLinkedList(&list);

    reverseLinkedList(&list);

    printf("Reversed linked list: ");
    printLinkedList(&list);

    // 清理内存
    Node *current = list.head;
    while (current != NULL) {
        Node *temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}
  • 初始化一个链表 list。
  • 提示用户输入链表中元素的数量 n。
  • 提示用户输入链表中的每个元素，并调用 insertAtTail 函数将其插入到链表中。
  • 打印原始链表的内容。
  • 调用 reverseLinkedList 函数逆置链表。
  • 再次打印链表的内容，显示逆置后的结果。
  • 清理链表中所有节点的内存，防止内存泄漏。
  • 返回0，表示程序正常结束。

示例运行

假设用户输入以下数据：

Enter the number of elements in the linked list: 5
Enter the elements of the linked list:
3 1 4 1 5
Original linked list: 3 -> 1 -> 4 -> 1 -> 5 -> NULL
Reversed linked list: 5 -> 1 -> 4 -> 1 -> 3 -> NULL
  • 用户输入了5个元素 [3, 1, 4, 1, 5]。
  • 原始链表为 3 -> 1 -> 4 -> 1 -> 5 -> NULL。
  • 逆置链表后，链表变为 5 -> 1 -> 4 -> 1 -> 3 -> NULL。
肆——
关注
线性表代码基本例题及详细解释（2）
2301_79456294的博客
10-08 238
/ 链表节点定义int data;} Node;// 链表定义Node *head;Node结构体定义了一个链表节点，包含两个成员：int data：存储节点的数据。：指向下一个节点的指针。LinkedList结构体定义了一个链表，包含一个成员：Node *head：指向链表头节点的指针。// 链表节点定义int data;} Node;// 链表定义Node *head;Node结构体定义了一个链表节点，包含两个成员：int data：存储节点的数据。
数据结构第二章线性表经典例题及一元稀疏多项式实现分享
weixin_56819785的博客
05-01 710
线性表经典例题及一元稀疏多项式实现分享
线性表基本概念及用法
weixin_66405733的博客
09-06 2224
零个或多个数据元素的有限序列若将线性表记为（a1,a2,a3.......ai，an）a1称为a2的直接前驱元素，a3称为a2的直接后继元素，线性表的个数n定义为线性表的长度，当n=0是，称为空集。ai，i称数据元素ai在线性表中的位序。在较为复杂的线性表中，一个数据元素可以由若干个数据项组成ADT 线性表（List）Data线性表的数据对象集合为{a1,a2,a3,.......an}，每个元素的类型均为DataType。
线性表的基本操作
qq_46636024的博客
10-29 2749
/定义单链表结点类型 ElemType data;//数据域 struct LNode * next;//指针域 } LNode , * LinkList;强调使用的是单链表—LinkList强调使用的是结点 ----LNode本文介绍了顺序表和链表的基本操作以及基本例题。。
c语言：指针二（线性表知识+例题详解）
qq_2862896879的博客
04-20 2046
文章目录什么是线性表？线性表的特点线性表的基本操作线性表的顺序存储例题 什么是线性表？ 线性表是n个类型相同的数据元素的有限序列，对n>0,除了第一元素无直接前驱、最后一个元素无直接后继外，其余的每个数据元素只有一个直接前驱和一个直接后继。 👍线性表的逻辑结构： 注意; 在一般的线性表中，一个数据元素可由若干个数据项组成。 姓名 学号 张三 123 李四 456 表中，一行称为一个记录（或者数据元素），含有大量类型相同记录的线性表称为文件（或者数据对象）。 线性表的特点 同.
最详细线性表知识点附加代码来了！
cnchouchou的博客
10-19 467
线性表 线性表的抽象数据类型： InitList(*L):初始化操作，建立一个新的线性表 ListEmpty(L):判断线性表是否为空，如果为空返回True，否则返回False ClearList(*L)：将线性表清空 GetElem(L, i, *e): 将线性表中第i个元素返回给e LocateElem(L, e):在线性表中查找与给定e值相等的元素，如果查找成功，返回该元素在表中的序号表示成功，否则，返回0表示失败 ListInsert(*L, i, e):在线性表第i个位置插入新元素e ListDe
python线性表_线性表（二）：顺序表的经典例题
weixin_36081891的博客
01-30 843
引言前文介绍了顺序表的基本操作，本文主要来分析有关顺序表的经典编程题目。顺序表例题两数之和问题来源：力扣：1. 两数之和问题简述：题目给定了一个target，要求在这个整数数组中找出两个整数的和恰好等于target，并返回整数的下标。问题分析：最简单的实现方法是枚举法，利用双层循环查找哪两个整数恰好和为target，只要查找到就返回结果，但这样做会使得平均时间复杂度为O(N^2)，效率较低。正确的...
3. 线性表（1）
dugudaibo的博客
01-26 766
本文是《小甲鱼数据结构》的学习笔记，对视频课程中的相关知识进行总结。   欢迎大家在评论区多多留言互动~~~~ 1. 线性表的定义   线性表是由零个或多个数据元素组成的有限 序列。   这里需要强调几个关键的地方   (1) 首先他是一个序列，就是元素之间有顺序；   (2) 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他的元素都只有一个前驱和后继；
学数据结构（二）线性表（链式存储）（线性表应用和典型例题）（实际操作）
登登的博客 是温馨的小屋。
05-16 1751
以后关于线性表的相关应用和其他的相关例题都会在此更新，可以用来考试，准备工作，学习算法思想等等！
数据结构 线性表C++实例
10-06
1. 数组实现线性表： 数组是最简单的数据结构，用于存储同类型的元素序列。在C++中，我们可以定义一个动态数组来表示线性表。动态数组允许我们在运行时改变其大小，这在处理长度可变的线性表时非常有用。数组实现...
MFC线性表顺序存储
10-29
这个例子可能包含了一个使用CArray实现线性表顺序存储的代码实例，通过学习和实践，你可以更好地理解数据结构在实际编程中的应用。无论你是初学者还是有经验的开发者，理解并掌握这些基本数据结构及其操作都是非常有...
Netty系列-7 Netty编解码器
Sheng_Q的博客
10-02 694
netty框架中，自定义解码器的起点是ByteBuf类型的消息, 自定义编码器的终点是ByteBuf类型。
项目——超级马里奥——Day（2）
最新发布
2301_80073593的博客
10-07 722
讲了第二个部分的马里奥游戏的实现，以及好多好多小知识点
cmd命令大全详解
huxyc的博客
09-28 2156
cmdschtasks /create /tn [任务名] /tr [任务运行的命令] /sc [任务触发器]cmdbitsadmin /transfer [任务名] /download [源URL] [目标文件路径]cmdrobocopy [源路径] [目标路径] [文件名]cmdcopy [源文件路径] [目标文件路径]cmdmove [源文件路径] [目标文件路径]cmdfind [要查找的字符串] [文件名]cmdshutdown /s /t [秒数]cmdassoc [文件扩展名]
Springboot生成树工具类，可通过 id/code 编码生成 2.0版本
_Mr丶s
09-30 409
【代码】Springboot生成树工具类，可通过 id/code 编码生成 2.0版本。
17 链表——21. 合并两个有序链表 ★
rainchxy的博客
10-04 361
将两个升序链表合并为一个新的升序链表并返回。
lambda表达式底层实现：反编译LambdaMetafactory + 转储dump + 运行过程 + 反汇编 + 动态指令invokedynamic
秋夫人
09-30 877
1.lambda 表达式的本质：函数式接口的匿名子类的匿名对象 2.lambda表达式是语法糖
Linux学习笔记（六）：服务管理，监控，RPM包管理，yum包管理工具，Linux启动管理，网络管理
2301_77207909的博客
10-04 1722
Linux学习笔记（六）：服务管理，监控，RPM包管理，yum包管理工具，Linux启动管理，网络管理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值