使用C语言实现双向链表的冒泡排序，由大到小排列

以下是使用C语言实现双向链表的冒泡排序程序，由大到小排列：

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

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

// 创建一个新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 在链表末尾插入新节点
void insertAtEnd(struct Node** head, int data) {
    struct Node* newNode = createNode(data);
    struct Node* curr = *head;
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
    newNode->prev = curr;
}

// 交换相邻两个节点
void swap(struct Node* first, struct Node* second) {
    int temp = first->data;
    first->data = second->data;
    second->data = temp;
}

// 对双向链表进行冒泡排序，由大到小排列
void bubbleSort(struct Node** head) {
    struct Node* curr;
    struct Node* last = NULL;
    int swapped;
    if (*head == NULL) {
        return;
    }
    do {
        swapped = 0;
        curr = *head;
        while (curr->next != last) {
            if (curr->data < curr->next->data) {
                swap(curr, curr->next);
                swapped = 1;
            }
            curr = curr->next;
        }
        last = curr;
    } while (swapped);
}

// 打印双向链表
void printList(struct Node* head) {
    struct Node* curr = head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
}

int main() {
    struct Node* head = NULL;
    insertAtEnd(&head, 5);
    insertAtEnd(&head, 3);
    insertAtEnd(&head, 9);
    insertAtEnd(&head, 1);
    insertAtEnd(&head, 7);
    printf("Original List: ");
    printList(head);
    bubbleSort(&head);
    printf("\nSorted List: ");
    printList(head);
    return 0;
}

输出结果：

Original List: 5 3 9 1 7 
Sorted List: 9 7 5 3 1 

在上面的程序中，我们首先定义了一个双向链表的结构体，并创建了一个新节点的函数。在插入节点时，我们遍历整个链表，找到最后一个节点，并将新节点插入到末尾。

我们还定义了一个交换相邻两个节点的函数，这在冒泡排序中是必须的。在对双向链表进行冒泡排序时，我们使用了一个 do-while 循环，每次循环都会遍历整个链表并比较相邻的两个节点。如果它们的顺序不正确，就交换它们的位置。如果在一次循环中没有进行任何交换，那么表示链表已经排序完成，可以退出循环。

最后，我们使用 printList 函数打印排序后的链表。