c语言数据结构求链式表表长

在C语言中，计算链表（Linked List）的长度通常需要遍历整个列表，因为链表不像数组那样可以直接访问每个元素的位置。下面是一个基本的方法来求解：

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

// 函数声明，用于计算链表长度
int getLinkedListLength(Node* head) {
    if (head == NULL) { // 如果链表为空，返回0
        return 0;
    }
    
    int length = 1; // 初始化长度为1，因为我们已知有一个头节点
    Node* current = head; // 当前节点

    while (current->next != NULL) { // 遍历直到链表结束
        current = current->next; // 移动到下一个节点
        length++; // 长度加一
    }

    return length;
}

在这个函数中，我们从`head`开始，逐个检查每个节点的`next`指针是否为`NULL`，如果不为`NULL`就继续移动并增加计数。当遇到`NULL`时，表示已经到达了链表的末尾。

相关问题

使用c语言假设散列表表长为m，散列函数为H(key)，用链地址法处理冲突。试编写输入一组关键字并建立散列表的算法。

在C语言中，我们可以使用链地址法（也称为开放寻址法）处理哈希表的冲突。首先，我们需要一个结构体表示节点，包含关键字值key和指向下一个节点的指针。下面是创建散列表的基本步骤：

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

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

// 哈希函数示例，这里简单地取模运算
int hash(int key, int m) {
    return key % m; // 返回关键字对表长度取余的结果作为索引
}

// 创建新节点
Node* createNode(int key) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        printf("Memory allocation failed.\n");
        return NULL;
    }
    newNode->key = key;
    newNode->next = NULL;
    return newNode;
}

// 插入键值到散列表
void insertIntoHashTable(int key, int m, Node** table) {
    Node* node = table[hash(key, m)];
    while (node != NULL) {
        if (node->key == key) {
            printf("Key already exists in the hash table.\n");
            return;
        }
        node = node->next;
    }
    node = createNode(key);
    node->next = *table;
    *table = node;
}

// 主函数，输入一组关键字并建立散列表
void buildHashTable(int m) {
    Node** table = (Node**)malloc(m * sizeof(Node*));
    for (int i = 0; i < m; i++) {
        table[i] = NULL;
    }

    int numKeys;
    printf("Enter number of keys: ");
    scanf("%d", &numKeys);

    for (int i = 0; i < numKeys; i++) {
        int key;
        printf("Enter key %d: ", i + 1);
        scanf("%d", &key);
        insertIntoHashTable(key, m, table);
    }

    // 打印散列表内容（仅为了演示，实际应用中不需要）
    for (int i = 0; i < m; i++) {
        Node* current = table[i];
        while (current != NULL) {
            printf("%d -> ", current->key);
            current = current->next;
        }
        printf("\n");
    }

    free(table); // 释放内存
}

int main() {
    int m;
    printf("Enter size of the hash table: ");
    scanf("%d", &m);
    buildHashTable(m);
    return 0;
}

这个程序首先创建一个大小为m的动态数组，然后循环读取用户输入的关键字，并插入到对应的散列表位置。如果遇到冲突，则将新的节点添加到当前节点的链表头部。

求带头节点的单链表表长

求带头节点的单链表的长度，也称为获取链表的大小或元素个数，通常需要遍历整个链表并计数。对于每个节点，你会递归地检查它的下一个节点，直到链表的末尾（也就是null）。以下是步骤：

1. 初始化一个变量，例如`length`，用于存储链表的长度，初始值设为0。
2. 当链表的当前节点不为null时，`length`加一，并将指针移动到当前节点的下一个节点。
3. 继续这个过程，直到遍历完所有的节点，`length`就是链表的实际长度。

下面是一个伪代码示例：

function getLinkedListLength(head):
    if head is null:
        return 0
    else:
        length = 1     # 链表至少有一个头节点
        current = head.next   # 当前节点指向下一个节点
        while current is not null:
            length += 1
            current = current.next
        return length