用c语言写：已知head指向双向链表的第一个结点。链表中每个结点包含数据域（info）、后继元素指针域（next）和前趋元素指针域（pre）。请编写函数printl用来从头到尾输出这一双向链表

以下是用C语言编写的printl函数，可以从头到尾输出双向链表：

void printl(struct node *head) {
    struct node *curr;
    curr = head;
    while(curr != NULL) {
        printf("%d ", curr->info); // 假设数据域为int类型
        curr = curr->next;
    }
}

我们首先将指针curr指向链表头，然后在循环中遍历整个链表。在每个结点处，我们输出该结点的数据域并将指针curr移动到下一个结点。由于这是一个双向链表，我们也可以使用前趋元素指针域pre来从尾到头输出该链表。

相关问题

已知 head 指向一个带头结点的单向链表,链表中每个结点包含数据 long 和指向本结

点的指针 next，现在要在链表尾部插入一个新结点，请问该如何操作？

可以按照以下步骤进行操作：

1. 创建一个新结点，用变量 new_node 指向它，同时将新结点的数据部分设置为需要插入的数据。

2. 将新结点的指针部分设置为 NULL，表示它是链表的最后一个结点。

3. 找到链表的最后一个结点，可以通过循环遍历链表来实现。具体操作是从头结点开始遍历链表，依次访问每个结点的指针 next，直到找到最后一个结点，即指针 next 为 NULL 的结点。

4. 将最后一个结点的指针 next 指向新结点，即可将新结点插入到链表的尾部。

完整代码如下：

struct ListNode {
    long data;
    ListNode* next;
};

void insert_at_tail(ListNode* head, long data) {
    // 创建新结点
    ListNode* new_node = new ListNode;
    new_node->data = data;
    new_node->next = NULL;

    // 找到最后一个结点
    ListNode* curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }

    // 将新结点插入到链表尾部
    curr->next = new_node;
}

用C语言实现已知一个双向链表的头结点DLinkedNode h，写一段程序将其进行翻转。

在C语言中，翻转一个双向链表意味着改变每个节点的前驱和后继指针，使得原本的后继变成前驱，反之亦然。下面是一个简单的递归方法来完成这个任务：

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

typedef struct DLinkedNode {
    int data;
    struct DLinkedNode *prev;
    struct DLinkedNode *next;
} DLinkedNode;

// 创建一个新的双向链表节点
DLinkedNode* createNode(int data) {
    DLinkedNode* newNode = (DLinkedNode*)malloc(sizeof(DLinkedNode));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 双向链表节点的翻转
void reverseList(DLinkedNode **head) {
    if (*head == NULL || (*head)->next == NULL) {
        return;
    }

    // 保存当前节点的后继
    DLinkedNode *nextTemp = (*head)->next;

    // 反转当前节点
    (*head)->next = (*head)->prev;
    (*head)->prev = nextTemp;

    // 递归反转剩余部分
    reverseList(&nextTemp);
}

// 打印链表
void printList(DLinkedNode *node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
    printf("\n");
}

int main() {
    // 初始化一个双向链表
    DLinkedNode *h = createNode(1);
    h->next = createNode(2);
    h->next->prev = h;
    h->next->next = createNode(3);
    h->next->next->prev = h->next;

    printf("Original List:\n");
    printList(h);

    // 翻转链表
    reverseList(&h);

    printf("Reversed List:\n");
    printList(h);

    return 0;
}

上述代码首先定义了一个双向链表节点结构，并创建了两个辅助函数：`createNode`用于生成新节点，`printList`用于打印链表。`reverseList`函数采用了递归策略，每次迭代都将当前节点指向它的后继节点，然后递归地对剩余的部分进行同样的操作。