C语言实现双链表的初始化

双链表是一种常见的数据结构，它由多个节点组成，每个节点都包含两个指针，分别指向前一个节点和后一个节点。下面是C语言实现双链表的初始化代码：

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

// 双链表节点结构体
typedef struct node {
    int data;           // 数据域
    struct node *prev;  // 前驱指针
    struct node *next;  // 后继指针
} Node;

// 双链表初始化函数
void initList(Node **head) {
    *head = (Node *) malloc(sizeof(Node));  // 分配头节点空间
    (*head)->prev = NULL;                   // 头节点的前驱指针为NULL
    (*head)->next = NULL;                   // 头节点的后继指针为NULL
}

在这个例子中，我们定义了一个双链表节点结构体，其中包含数据域、前驱指针和后继指针。然后我们定义了一个双链表初始化函数`initList`，该函数接收一个指向头节点指针的指针。在函数内部，我们首先为头节点分配空间，并将头节点的前驱指针和后继指针都设置为NULL，表示该节点没有前驱节点和后继节点。这样就完成了双链表的初始化。

相关问题

使用C语言实现双向链表的全部功能

双向链表（Doubly Linked List）是一种数据结构，它与单向链表相似，但是每个节点除了指向下一个节点的指针之外，还有一个指向上一个节点的指针。这使得在双向链表中可以方便地向前或向后遍历节点。以下是使用C语言实现双向链表的全部功能的代码：

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

// 定义双向链表的节点结构体
typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

// 初始化双向链表
Node* init() {
    Node* head = (Node*)malloc(sizeof(Node));
    head->data = -1;
    head->prev = NULL;
    head->next = NULL;
    return head;
}

// 在双向链表末尾添加节点
void append(Node* head, int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;
    new_node->prev = head;
    new_node->next = NULL;
    Node* p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = new_node;
}

// 在双向链表指定位置插入节点
void insert(Node* head, int pos, int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;
    Node* p = head;
    for (int i = 0; i < pos; i++) {
        p = p->next;
        if (p == NULL) {
            printf("Error: position out of range\n");
            return;
        }
    }
    new_node->prev = p->prev;
    new_node->next = p;
    p->prev->next = new_node;
    p->prev = new_node;
}

// 删除双向链表指定位置的节点
void remove_node(Node* head, int pos) {
    Node* p = head;
    for (int i = 0; i < pos; i++) {
        p = p->next;
        if (p == NULL) {
            printf("Error: position out of range\n");
            return;
        }
    }
    p->prev->next = p->next;
    if (p->next != NULL) {
        p->next->prev = p->prev;
    }
    free(p);
}

// 获取双向链表指定位置的节点的数据
int get(Node* head, int pos) {
    Node* p = head;
    for (int i = 0; i < pos; i++) {
        p = p->next;
        if (p == NULL) {
            printf("Error: position out of range\n");
            return -1;
        }
    }
    return p->data;
}

// 修改双向链表指定位置的节点的数据
void set(Node* head, int pos, int data) {
    Node* p = head;
    for (int i = 0; i < pos; i++) {
        p = p->next;
        if (p == NULL) {
            printf("Error: position out of range\n");
            return;
        }
    }
    p->data = data;
}

// 获取双向链表的长度
int length(Node* head) {
    Node* p = head;
    int len = 0;
    while (p->next != NULL) {
        len++;
        p = p->next;
    }
    return len;
}

// 打印双向链表的所有节点的数据
void print(Node* head) {
    Node* p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 反向打印双向链表的所有节点的数据
void reverse_print(Node* head) {
    Node* p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    while (p->prev != NULL) {
        printf("%d ", p->data);
        p = p->prev;
    }
    printf("\n");
}

// 释放双向链表的所有节点的内存
void destroy(Node* head) {
    Node* p = head->next;
    while (p != NULL) {
        Node* q = p;
        p = p->next;
        free(q);
    }
    free(head);
}

int main() {
    Node* head = init();
    append(head, 1);
    append(head, 2);
    append(head, 3);
    insert(head, 1, 4);
    remove_node(head, 2);
    set(head, 2, 5);
    printf("Length: %d\n", length(head));
    print(head);
    reverse_print(head);
    destroy(head);
    return 0;
}

在上面的代码中，`init`函数用于初始化双向链表，返回一个头节点；`append`函数用于在双向链表末尾添加一个节点；`insert`函数用于在双向链表指定位置插入一个节点；`remove_node`函数用于删除双向链表指定位置的节点；`get`函数用于获取双向链表指定位置的节点的数据；`set`函数用于修改双向链表指定位置的节点的数据；`length`函数用于获取双向链表的长度；`print`函数用于打印双向链表的所有节点的数据；`reverse_print`函数用于反向打印双向链表的所有节点的数据；`destroy`函数用于释放双向链表的所有节点的内存。在`main`函数中，我们对双向链表进行了一些操作，例如添加节点、插入节点、删除节点、修改节点、获取长度、打印节点等等。最后，我们使用`destroy`函数释放了双向链表的内存。

写一个双向链表初始化c语言

双向链表是一种常见的数据结构，每个节点包含了指向前一个节点和后一个节点的指针。以下是一个简单的双向链表的初始化代码示例：

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

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

struct Node* createNode(int data) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = data;
    node->prev = NULL;
    node->next = NULL;
    return node;
}

void insertAtHead(struct Node** head, int data) {
    struct Node* node = createNode(data);
    if (*head == NULL) {
        *head = node;
    }
    else {
        node->next = *head;
        (*head)->prev = node;
        *head = node;
    }
}

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

int main() {
    struct Node* head = NULL;
    insertAtHead(&head, 3);
    insertAtHead(&head, 2);
    insertAtHead(&head, 1);
    printList(head);
    return 0;
}

在这个代码示例中，我们定义了一个 `Node` 结构体，包含了一个整数型数据、一个指向前一个节点的指针 `prev` 和一个指向后一个节点的指针 `next`。然后我们定义了一个 `createNode` 函数，用于创建一个新的节点并返回它的指针。我们还定义了一个 `insertAtHead` 函数，用于在链表的头部插入一个新的节点。最后，我们定义了一个 `printList` 函数，用于打印链表中的所有节点。

在 `main` 函数中，我们首先将头节点初始化为 `NULL`，然后依次插入三个节点，数据分别为 1、2 和 3。最后，我们调用 `printList` 函数打印链表中所有节点的数据。