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

2023-12-16 16:31:41

目录

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;
}

输出结果如下:

文章来源:https://blog.csdn.net/m0_71369515/article/details/135032278
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。