数据结构之链表详解及示例（C，C#，C++）

文章目录

链表是一种常见的基础数据结构，它由一系列节点（Node）组成，用于存储一连串数据元素。链表中的每个节点至少包含两个部分：数据域（存储数据元素）和指针域（存储下一个节点的地址）。以下是链表的一些基本概念和特性：

链表的基本概念

结点（Node）

链表中的每个元素称为结点，每个结点通常包含两个部分：

数据域（Data）：存储实际的数据。

指针域（Pointer）：存储下一个结点的地址。

头结点（Head）

链表通常有一个头结点，它可以是实际数据的一部分，也可以是一个特殊的空结点，仅用于指向第一个实际数据结点。

尾结点（Tail）

链表的最后一个结点，其指针域通常指向空（NULL）。

链表的基本类型

单向链表：每个节点只包含一个指向下一节点的指针。
双向链表：每个节点包含两个指针，一个指向前一个节点，另一个指向下一个节点。
循环链表：链表中最后一个节点的指针指向第一个节点，形成一个环。
静态链表：使用数组来模拟链表，节点之间的链接通过数组下标来实现。

节点结构：

c 复制代码

typedef struct Node {
    int data;           // 数据域
    struct Node* next;  // 指针域，指向下一个节点
} Node;

链表的基本操作

初始化：创建一个带头节点的链表，头节点的数据域可以不存储有效数据。

插入：在链表的指定位置插入一个新的节点。

删除：删除链表中的指定节点。

查找：在链表中查找具有特定值的节点。

遍历：访问链表中的每一个节点。

销毁：释放链表占用的内存空间。

主要特点

动态内存分配：链表的节点可以在运行时动态分配，因此可以灵活地增加或删除元素，而不需要像数组一样预先分配固定大小的空间。
非连续存储：链表中的节点在内存中不一定是连续存储的，每个节点通过指针指向下一个节点，因此可以充分利用零散的内存空间。
访问元素效率低：与数组相比，链表的访问效率较低。要访问链表中的某个元素，通常需要从头节点开始沿着指针逐个访问，时间复杂度为 O(n)，其中 n 是链表的长度。
插入和删除操作效率高：链表在插入和删除元素时效率较高，可以在 O(1) 时间内完成，只需调整指针的指向即可。

C语言中的链表实现

c 复制代码

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

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

Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        exit(-1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

void insertAtHead(Node** head, int data) {
    Node* newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}

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

void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

int main() {
    Node* head = NULL;

    insertAtHead(&head, 3);
    insertAtHead(&head, 2);
    insertAtHead(&head, 1);

    printList(head);

    freeList(head);
    return 0;
}

C#中的链表实现

csharp 复制代码

using System;

public class Node {
    public int Data { get; set; }
    public Node Next { get; set; }

    public Node(int data) {
        Data = data;
        Next = null;
    }
}

public class LinkedList {
    public Node Head { get; private set; }

    public void InsertAtHead(int data) {
        Node newNode = new Node(data);
        newNode.Next = Head;
        Head = newNode;
    }

    public void PrintList() {
        Node current = Head;
        while (current != null) {
            Console.Write(current.Data + " -> ");
            current = current.Next;
        }
        Console.WriteLine("NULL");
    }
}

class Program {
    static void Main() {
        LinkedList list = new LinkedList();

        list.InsertAtHead(3);
        list.InsertAtHead(2);
        list.InsertAtHead(1);

        list.PrintList();
    }
}

C++中的链表实现

cpp 复制代码

#include <iostream>

struct Node {
    int data;
    Node* next;

    Node(int data) : data(data), next(nullptr) {}
};

class LinkedList {
public:
    Node* head;

    LinkedList() : head(nullptr) {}

    void insertAtHead(int data) {
        Node* newNode = new Node(data);
        newNode->next = head;
        head = newNode;
    }

    void printList() const {
        Node* temp = head;
        while (temp != nullptr) {
            std::cout << temp->data << " -> ";
            temp = temp->next;
        }
        std::cout << "NULL" << std::endl;
    }

    ~LinkedList() {
        Node* current = head;
        while (current != nullptr) {
            Node* next = current->next;
            delete current;
            current = next;
        }
    }
};

int main() {
    LinkedList list;

    list.insertAtHead(3);
    ist.insertAtHead(2);
    list.insertAtHead(1);

    list.printList();

    return 0;
}

链表的优缺点

优点

动态大小：链表的大小不是固定的，可以根据需要动态地增减。
插入和删除操作高效：在链表中插入或删除一个元素不需要移动其他元素，只需改变指针的指向。

缺点

随机访问效率低：链表不支持随机访问，查找一个元素需要从头结点开始遍历。
额外的内存开销：每个结点都需要额外的内存空间来存储指向下一个结点的指针。

总结

链表是一种灵活且强大的数据结构，适用于需要频繁插入和删除操作的场景。本文通过C、C#、C++三种语言展示了链表的基本操作，帮助读者理解链表的工作原理。在实际应用中，应根据具体需求选择合适的链表变种，如单向链表、双向链表或循环链表。掌握链表是成为优秀程序员的必经之路。