【数据结构】单链表的定义和操作

目录

1.单链表的定义

2.单链表的创建和初始化

3.单链表的插入节点操作

4.单链表的删除节点操作

5.单链表的查找节点操作

6.单链表的更新节点操作

7.完整代码

---

🌈嗨！我是Filotimo__🌈。很高兴与大家相识，希望我的博客能对你有所帮助。

💡本文由Filotimo__??原创，首发于CSDN📚。

📣如需转载，请事先与我联系以获得授权??。

🎁欢迎大家给我点赞👍、收藏??，并在留言区📝与我互动，这些都是我前进的动力！

🌟我的格言：森林草木都有自己认为对的角度🌟。

1.单链表的定义

单链表由一系列节点组成，每个节点包含数据和一个指向下一个节点的指针（通常称为"next"指针）。单链表的最后一个节点指向空值（null）表示链表的结束。

单链表通常包含以下几个要素：

节点（Node）：表示链表中的每个元素，通常包含数据和一个指向下一个节点的指针。
头结点（Head Node）：代表链表的开始，通常不存储数据，它的next指针指向第一个实际节点。
尾节点（Tail Node）：代表链表的最后一个节点，它的next指针指向空值（null）。
链表的长度：即链表中节点的数量。

头节点是第一个节点，尾节点是最后一个节点，它们都不存储数据元素。

单链表的特点是可以实现动态的插入和删除操作，但是访问某个节点时需要从头结点开始依次遍历链表，效率较低。

2.单链表的创建和初始化

创建单链表需要定义一个节点结构，该结构包含一个数据域和一个指向下一个节点的指针。首先创建一个头节点，将其指针设置为NULL，表示链表为空。

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

ListNode* createLinkedList() {
    ListNode* head = new ListNode();
    head->next = NULL;
    return head;
}

先定义名为 ListNode 的结构体。该结构体包含两个成员变量：int data 和 ListNode* next。

int data 用来存储节点的数据值，表示链表中的一个元素。

ListNode* next 是指向下一个节点的指针，表示链表中当前节点的下一个节点。

在函数 createLinkedList中，首先通过 new ListNode() 创建了一个新的节点对象，并将其地址赋值给 head 指针变量。然后，将 head->next 设置为 NULL，表示链表当前只有一个节点，并且没有下一个节点。最后，将 head 返回作为链表的头节点指针。

3.单链表的插入节点操作

在单链表中插入一个新节点需要先找到插入位置的前一个节点，然后将新节点插入到其后面。

void insertNode(ListNode* list, int value) {
    ListNode* newNode = new ListNode();
    newNode->data = value;
    newNode->next = NULL;

    ListNode* p = list;
    while (p->next != NULL) {
        p = p->next;
    }

    p->next = newNode;
}

ListNode* list表示链表的头节点指针

int value表示要插入节点的数值

函数中，先通过 `new ListNode()` 创建了一个新的节点对象，并将其地址赋给 `newNode` 指针变量。然后，将 `value` 的值赋给 `newNode->data`，即将要插入节点的数值存储到节点的 `data` 成员变量中。接着，将 `newNode->next` 设置为 `NULL`，表示新节点的下一个节点暂时为空。

再通过创建一个指针变量 `p`，将其初始化为 `list`，即将其指向链表的头节点。使用循环遍历链表，直到找到最后一个节点（即 `p->next = NULL`）。在每次循环迭代中，通过 `p = p->next` 将指针 `p` 移动到下一个节点。

在循环结束后，将新节点 `newNode` 插入到链表的最后一个节点的后面，即将最后一个节点的 `next` 指针指向 `newNode`。

4.单链表的删除节点操作

删除单链表中的一个节点也需要找到待删除节点的前一个节点，将其指针指向待删除节点的下一个节点，然后释放待删除节点的内存。

void deleteNode(ListNode* list, int value) {
    ListNode* p = list;
    while (p->next != NULL) {
        if (p->next->data == value) {
            ListNode* temp = p->next;
            p->next = temp->next;
            delete temp;
            break;
        }
        p = p->next;
    }
}

函数中，首先创建一个指针变量p，将其初始化为list，即将其指向链表的头节点。然后，使用循环遍历链表，直到找到节点数值等于value的节点，或者遍历到链表的最后一个节点。

在每次循环迭代中，通过判断p->next->data是否等于value，确定是否找到了需要删除的节点。如果找到了目标节点，则创建一个临时指针变量 `temp`，将其指向待删除节点的地址。通过 `p->next = temp->next` 更新前一个节点的 `next` 指针，跳过待删除节点。使用 `delete temp` 释放内存，删除待删除节点，并通过 `break` 语句跳出循环。

5.单链表的查找节点操作

查找单链表中某个特定值的节点，需要遍历链表，逐个比较节点的数据域。

ListNode* findNode(ListNode* list, int value) {
    ListNode* p = list;
    while (p->next != NULL) {
        if (p->next->data == value) {
            return p->next;
        }
        p = p->next;
    }
    return NULL;  // 未找到返回NULL
}

这个函数，使用循环遍历链表，直到找到节点数值等于value的节点，或者遍历到链表的最后一个节点。在每次循环迭代中，通过判断p->next->data是否等于value，确定是否找到了需要查找的节点。如果找到了目标节点，则直接返回该节点的指针p->next。

6.单链表的更新节点操作

更新单链表中某个节点的值，需要先找到该节点，然后修改其数据域的值。

void updateNode(ListNode* list, int oldValue, int newValue) {
    ListNode* p = findNode(list, oldValue);
    if (p != NULL) {
        p->data = newValue;
    }
}

函数的参数：

ListNode* list表示链表的头节点指针

oldValue表示待更新节点的旧数值

newValue表示待更新节点的新数值

在函数中，首先通过调用indNode函数来查找链表中数值为oldValue的节点，将返回的节点指针赋值给p。

接着，通过判断p是否为NULL，即是否找到了待更新的节点。如果p != NULL，则说明找到了需要更新的节点，将该节点的data成员变量的值更新为newValue，即p->data = newValue。

7.完整代码

#include <iostream>

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

ListNode* createLinkedList() {
    ListNode* head = new ListNode();
    head->next = NULL;
    return head;
}

void insertNode(ListNode* list, int value) {
    ListNode* newNode = new ListNode();
    newNode->data = value;
    newNode->next = NULL;

    ListNode* p = list;
    while (p->next != NULL) {
        p = p->next;
    }

    p->next = newNode;
}

void deleteNode(ListNode* list, int value) {
    ListNode* p = list;
    while (p->next != NULL) {
        if (p->next->data == value) {
            ListNode* temp = p->next;
            p->next = temp->next;
            delete temp;
            break;
        }
        p = p->next;
    }
}

ListNode* findNode(ListNode* list, int value) {
    ListNode* p = list;
    while (p->next != NULL) {
        if (p->next->data == value) {
            return p->next;
        }
        p = p->next;
    }
    return NULL;
}

void updateNode(ListNode* list, int oldValue, int newValue) {
    ListNode* p = findNode(list, oldValue);
    if (p != NULL) {
        p->data = newValue;
    }
}

void printLinkedList(ListNode* list) {
    ListNode* p = list->next;
    while (p != NULL) {
        std::cout << p->data << " ";
        p = p->next;
    }
    std::cout << std::endl;
}

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

    // 插入节点
    insertNode(list, 1);
    insertNode(list, 2);
    insertNode(list, 3);
    insertNode(list, 4);
    std::cout << "链表：";
    printLinkedList(list);

    // 删除节点
    deleteNode(list, 2);
    std::cout << "删除节点2后的链表：";
    printLinkedList(list);

    // 查找节点
    ListNode* node = findNode(list, 3);
    if (node != NULL) {
        std::cout << "找到节点3" << std::endl;
    } else {
        std::cout << "未找到节点3" << std::endl;
    }

    // 更新节点
    updateNode(list, 3, 5);
    std::cout << "更新节点3的值为5后的链表：";
    printLinkedList(list);

    return 0;
}

输出结果如下：