1. PingCode智库首页
  2. 百科

c语言如何获得一个链表的长度

Edit1 • • 百科

c语言如何获得一个链表的长度

在C语言中，获得一个链表的长度可以通过遍历链表并计数节点的数量来实现。 这种方法涉及从链表的头节点开始，逐个遍历每个节点，直到到达链表的末尾，并在此过程中计数。这种方法直观且易于实现，但需要注意处理空链表的情况。接下来，我们将详细解释如何在C语言中实现这一过程。

一、链表的基本概念

链表是一种数据结构，其中每个元素称为节点。每个节点包含两部分：数据部分和指向下一个节点的指针。链表的第一个节点称为头节点，最后一个节点的指针指向NULL，表示链表的结束。

1、链表节点的定义

在C语言中，链表节点通常定义为一个结构体。结构体包含数据和指向下一个节点的指针。

struct Node {


    int data;


    struct Node* next;


};

2、链表的初始化

链表的初始化涉及创建头节点并将其指针设置为NULL。

struct Node* head = NULL;

二、遍历链表

遍历链表是指从头节点开始，逐个访问每个节点，直到到达链表的末尾。遍历过程中，我们可以执行各种操作，例如计数节点的数量。

1、遍历链表的基本方法

遍历链表的基本方法是使用一个临时指针，从头节点开始，逐步移动到下一个节点，直到指针为NULL。

struct Node* current = head;


while (current != NULL) {


    // 执行操作，例如计数节点


    current = current->next;


}

2、计数节点的实现

在遍历链表的过程中，我们可以计数节点的数量，从而获得链表的长度。

int getLength(struct Node* head) {


    int count = 0;


    struct Node* current = head;


    while (current != NULL) {


        count++;


        current = current->next;


    }


    return count;


}

三、完整代码示例

以下是一个完整的代码示例，展示如何定义链表节点、初始化链表、添加节点以及获取链表的长度。

#include <stdio.h>


#include <stdlib.h>


// 定义链表节点


struct Node {


    int data;


    struct Node* next;


};


// 添加节点到链表


void append(struct Node head_ref, int new_data) {


    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));


    struct Node* last = *head_ref;


    new_node->data = new_data;


    new_node->next = NULL;


    if (*head_ref == NULL) {


        *head_ref = new_node;


        return;


    }


    while (last->next != NULL) {


        last = last->next;


    }


    last->next = new_node;


}


// 获取链表的长度


int getLength(struct Node* head) {


    int count = 0;


    struct Node* current = head;


    while (current != NULL) {


        count++;


        current = current->next;


    }


    return count;


}


// 主函数


int main() {


    struct Node* head = NULL;


    append(&head, 1);


    append(&head, 2);


    append(&head, 3);


    printf("链表的长度是 %dn", getLength(head));


    return 0;


}

四、链表的其他操作

除了获取链表的长度，链表还有其他常见操作，例如插入节点、删除节点和反转链表等。

1、插入节点

插入节点可以在链表的头部、尾部或中间位置插入新节点。

void insertAtHead(struct Node head_ref, int new_data) {


    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));


    new_node->data = new_data;


    new_node->next = *head_ref;


    *head_ref = new_node;


}

2、删除节点

删除节点涉及调整指针以移除指定节点。

void deleteNode(struct Node head_ref, int key) {


    struct Node* temp = *head_ref;


    struct Node* prev = NULL;


    if (temp != NULL && temp->data == key) {


        *head_ref = temp->next;


        free(temp);


        return;


    }


    while (temp != NULL && temp->data != key) {


        prev = temp;


        temp = temp->next;


    }


    if (temp == NULL) return;


    prev->next = temp->next;


    free(temp);


}

3、反转链表

反转链表是将链表中的节点顺序逆转。

void reverse(struct Node head_ref) {


    struct Node* prev = NULL;


    struct Node* current = *head_ref;


    struct Node* next = NULL;


    while (current != NULL) {


        next = current->next;


        current->next = prev;


        prev = current;


        current = next;


    }


    *head_ref = prev;


}

五、链表的应用场景

链表在实际编程中有许多应用场景，例如实现队列、栈和图等数据结构。链表的动态内存分配特性使其在需要频繁插入和删除操作的场景中非常有用。

1、实现队列

队列是一种先进先出（FIFO）的数据结构，可以用链表实现。

struct Queue {


    struct Node* front;


    struct Node* rear;


};


void enqueue(struct Queue* q, int value) {


    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));


    new_node->data = value;


    new_node->next = NULL;


    if (q->rear == NULL) {


        q->front = q->rear = new_node;


        return;


    }


    q->rear->next = new_node;


    q->rear = new_node;


}


int dequeue(struct Queue* q) {


    if (q->front == NULL) return -1;


    struct Node* temp = q->front;


    q->front = q->front->next;


    if (q->front == NULL) q->rear = NULL;


    int value = temp->data;


    free(temp);


    return value;


}

2、实现栈

栈是一种后进先出（LIFO）的数据结构，也可以用链表实现。

struct Stack {


    struct Node* top;


};


void push(struct Stack* stack, int value) {


    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));


    new_node->data = value;


    new_node->next = stack->top;


    stack->top = new_node;


}


int pop(struct Stack* stack) {


    if (stack->top == NULL) return -1;


    struct Node* temp = stack->top;


    stack->top = stack->top->next;


    int value = temp->data;


    free(temp);


    return value;


}

3、实现图

图是一种复杂的数据结构，可以用链表存储图的邻接表。

struct AdjListNode {


    int dest;


    struct AdjListNode* next;


};


struct AdjList {


    struct AdjListNode* head;


};


struct Graph {


    int V;


    struct AdjList* array;


};


struct AdjListNode* newAdjListNode(int dest) {


    struct AdjListNode* newNode = (struct AdjListNode*)malloc(sizeof(struct AdjListNode));


    newNode->dest = dest;


    newNode->next = NULL;


    return newNode;


}


struct Graph* createGraph(int V) {


    struct Graph* graph = (struct Graph*)malloc(sizeof(struct Graph));


    graph->V = V;


    graph->array = (struct AdjList*)malloc(V * sizeof(struct AdjList));


    for (int i = 0; i < V; ++i) {


        graph->array[i].head = NULL;


    }


    return graph;


}


void addEdge(struct Graph* graph, int src, int dest) {


    struct AdjListNode* newNode = newAdjListNode(dest);


    newNode->next = graph->array[src].head;


    graph->array[src].head = newNode;


}

六、链表的优缺点

链表有许多优点，但也有一些缺点。在使用链表时，需要权衡这些优缺点，以选择最适合的场景。

1、优点

  • 动态内存分配：链表的节点在需要时动态分配内存，避免了数组的固定大小限制。
  • 高效的插入和删除操作：在链表中插入和删除节点只需调整指针，而不需要移动其他元素。
  • 灵活性：链表可以轻松实现各种复杂的数据结构，例如队列、栈和图等。

2、缺点

  • 内存开销：链表的每个节点除了存储数据外，还需要额外的指针存储空间。
  • 不支持随机访问：链表不支持通过索引直接访问元素，需要从头节点开始遍历。
  • 缓存性能差：链表的节点在内存中不连续，导致缓存性能较差。

七、链表的改进

为了克服链表的一些缺点，可以使用一些改进技术，例如双向链表和循环链表等。

1、双向链表

双向链表的每个节点包含两个指针，分别指向前一个节点和后一个节点，从而允许在两个方向上遍历链表。

struct DNode {


    int data;


    struct DNode* prev;


    struct DNode* next;


};


void appendDNode(struct DNode head_ref, int new_data) {


    struct DNode* new_node = (struct DNode*)malloc(sizeof(struct DNode));


    struct DNode* last = *head_ref;


    new_node->data = new_data;


    new_node->next = NULL;


    if (*head_ref == NULL) {


        new_node->prev = NULL;


        *head_ref = new_node;


        return;


    }


    while (last->next != NULL) {


        last = last->next;


    }


    last->next = new_node;


    new_node->prev = last;


}

2、循环链表

循环链表的最后一个节点指向头节点，从而形成一个环形结构，适用于某些特定场景，例如循环缓冲区。

struct CNode {


    int data;


    struct CNode* next;


};


void appendCNode(struct CNode head_ref, int new_data) {


    struct CNode* new_node = (struct CNode*)malloc(sizeof(struct CNode));


    struct CNode* last = *head_ref;


    new_node->data = new_data;


    new_node->next = *head_ref;


    if (*head_ref == NULL) {


        *head_ref = new_node;


        new_node->next = *head_ref;


        return;


    }


    while (last->next != *head_ref) {


        last = last->next;


    }


    last->next = new_node;


}

八、总结

在C语言中，通过遍历链表并计数节点数量，可以获得链表的长度。这种方法直观且易于实现。链表是一种灵活且强大的数据结构，适用于多种场景，但也有一些缺点，如内存开销和不支持随机访问。在实际应用中，选择合适的数据结构和改进技术，可以充分发挥链表的优势。

此外，当涉及到项目管理时，推荐使用研发项目管理系统PingCode和通用项目管理软件Worktile，以提高工作效率和项目管理的质量。

相关问答FAQs：

1. 如何在C语言中计算链表的长度？

  • 链表的长度可以通过遍历整个链表并计算节点数量来获得。从链表的头节点开始，依次访问每个节点，并使用一个计数器变量来记录节点的数量。

2. 怎样遍历链表并获得长度？

  • 可以使用一个循环结构来遍历链表，从头节点开始，依次访问每个节点，直到达到链表的尾节点。在每次访问节点时，将计数器变量加1，直到遍历完整个链表，最终得到链表的长度。

3. 是否有现成的函数可以直接获得链表的长度？

  • 在C语言中，没有现成的函数可以直接获取链表的长度。但是，你可以自己实现一个函数来计算链表的长度，如前面提到的遍历链表并计算节点数量的方法。这样，你就可以在需要时调用该函数来获得链表的长度。

文章包含AI辅助创作，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/1089434

赞 (0)
Edit1Edit1
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部