用c语言写一个双向量双向链表

很高兴为您解答。要用C语言写一个双向量双向链表，首先需要定义一个结构体来存储节点的数据：struct node { int data; struct node *prev; struct node *next; }; 然后，可以使用malloc函数来动态分配节点，并为节点分配数据：struct node *newNode = (struct node*)malloc(sizeof(struct node)); newNode->data = data; newNode->prev = NULL; newNode->next = NULL; 之后，可以使用指针将节点连接在一起：LastNode->next = newNode; newNode->prev = LastNode; 最后，可以使用一些函数来搜索、添加和删除节点：void searchNode(int key) { struct node *temp = head; // start from head while(temp != NULL) { if (temp->data == key) { printf("Found\n"); return; } temp = temp->next; } printf("Not Found\n"); }

相关问题

用c语言写一个双向链表

下面是一个使用 c 语言实现双向链表的简单代码示例：

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

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

struct node *head = NULL;
struct node *tail = NULL;

// 在链表头部插入数据
void insert_at_head(int data) {
  struct node *new_node = (struct node*) malloc(sizeof(struct node));
  new_node->data = data;
  new_node->prev = NULL;
  new_node->next = head;
  if (head != NULL) {
    head->prev = new_node;
  }
  head = new_node;
  if (tail == NULL) {
    tail = new_node;
  }
}

// 在链表尾部插入数据
void insert_at_tail(int data) {
  struct node *new_node = (struct node*) malloc(sizeof(struct node));
  new_node->data = data;
  new_node->next = NULL;
  new_node->prev = tail;
  if (tail != NULL) {
    tail->next = new_node;
  }
  tail = new_node;
  if (head == NULL) {
    head = new_node;
  }
}

// 打印链表中的数据
void print_list() {
  struct node *temp = head;
  while (temp != NULL) {
    printf("%d ", temp->data);
    temp = temp->next;
  }
  printf("\n");
}

int main() {
  insert_at_head(1);
  insert_at_head(2);
  insert_at_tail(3);
  insert_at_tail(4);
  print_list();
  return 0;
}

运行结果：

2 1 3 4

这个示例代码实现了双向链表的常见操作，包括在链表头部和尾部插入数据，以及打印链表中的数据。

用C语言写一个双向链表

以下是一个双向链表的基本实现，包含节点的插入、删除、遍历等操作：

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

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

struct node *head = NULL;

void insert(int value) {
    struct node *new_node = (struct node*) malloc(sizeof(struct node));
    new_node->data = value;
    new_node->prev = NULL;
    new_node->next = head;
    if (head != NULL) {
        head->prev = new_node;
    }
    head = new_node;
}

void delete(int value) {
    struct node *current = head;
    while (current != NULL && current->data != value) {
        current = current->next;
    }
    if (current == NULL) {
        return;
    }
    if (current->prev != NULL) {
        current->prev->next = current->next;
    } else {
        head = current->next;
    }
    if (current->next != NULL) {
        current->next->prev = current->prev;
    }
    free(current);
}

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

int main() {
    insert(3);
    insert(5);
    insert(7);
    insert(9);
    traverse();
    delete(5);
    traverse();
    delete(9);
    traverse();
    return 0;
}

在这个实现中，我们使用了一个结构体 `node` 来表示链表的节点。每个节点包含一个整数值 `data`，以及两个指针 `prev` 和 `next`，分别指向前一个节点和后一个节点。初始时，我们设置 `head` 为 `NULL`，表示链表为空。

在 `insert` 函数中，我们首先创建一个新节点，并将它的 `data` 值设置为传入的参数。然后，我们将新节点的 `prev` 指针设置为 `NULL`，因为新节点是链表的头节点。接着，我们将新节点的 `next` 指针设置为原来的头节点，并将头节点的 `prev` 指针设置为新节点，这样就完成了节点的插入操作。

在 `delete` 函数中，我们首先遍历链表，找到节点的值等于传入参数的节点，如果找到了，我们就将它的前驱节点的 `next` 指针指向它的后继节点，将它的后继节点的 `prev` 指针指向它的前驱节点，这样就完成了节点的删除操作。

在 `traverse` 函数中，我们遍历整个链表，依次输出每个节点的 `data` 值。

在 `main` 函数中，我们插入了四个节点，并调用 `traverse` 函数输出整个链表。然后，我们删除了值为 5 和 9 的节点，并再次调用 `traverse` 函数输出剩余的节点。最后，程序返回 0，表示正常结束。