有几个记录存储在带头结点的双向链表中，现用双向起泡排序法对其按上升序进行排序，请用C语言写出这种排序的算法。（注：双向起泡排序即相邻两趟排序向相反方向起泡）

好的，下面是C语言实现双向起泡排序的算法：

#include<stdio.h>

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

// 双向链表中结点的插入函数
void insert(Node* head, int data) {
    Node* p = head;
    while (p->next && p->next->data < data) {
        p = p->next;
    }
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = data;
    node->prev = p;
    node->next = p->next;
    if (p->next) {
        p->next->prev = node;
    }
    p->next = node;
}

// 双向起泡排序算法
void bubbleSort(Node* head) {
    int len = 0;
    Node* p = head->next;
    while (p) {
        len++;
        p = p->next;
    }
    for (int i = 0; i < len-1; i++) {
        for (int j = 0; j < len-1-i; j++) {
            Node* p = head->next;
            for (int k = 0; k < j; k++) {
                p = p->next;
            }
            if (p->data > p->next->data) {
                int temp = p->data;
                p->data = p->next->data;
                p->next->data = temp;
            }
        }
        for (int j = len-2-i; j > i; j--) {
            Node* p = head->next;
            for (int k = 0; k < j-1; k++) {
                p = p->next;
            }
            if (p->data < p->prev->data) {
                int temp = p->data;
                p->data = p->prev->data;
                p->prev->data = temp;
            }
        }
    }
}

int main() {
    Node* head = (Node*)malloc(sizeof(Node));
    head->prev = NULL;
    head->next = NULL;
    insert(head, 5);
    insert(head, 2);
    insert(head, 9);
    insert(head, 1);
    insert(head, 7);
    printf("排序前的链表：");
    Node* p = head->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
    bubbleSort(head);
    printf("排序后的链表：");
    p = head->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
    return 0;
}

以上代码中，我们首先定义了一个结构体 `Node`，表示双向链表中的结点。然后定义了 `insert()` 函数用于向链表中插入结点，这里使用的是插入排序的思想。最后实现了 `bubbleSort()` 函数，其中使用了双向起泡排序的思想，对链表中的元素进行排序。在 `main()` 函数中，我们创建了一个带头结点的双向链表，并且插入了一些元素，然后进行排序并输出结果。

双向起泡排序算法的时间复杂度为 $O(n^2)$，空间复杂度为 $O(1)$。