举一个链表排序实例从大向小排用C语言写不能用头结点而且两节点包含很多内容需要将这些内容都换过来

好的，这是一个简单的链表排序的 C 语言实现，从大到小排序，不使用头结点，且节点包含多个数据成员需要全部交换：

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

// 定义链表节点结构体
typedef struct node {
    int data1;
    float data2;
    char data3;
    struct node *next;
} Node;

// 交换节点数据
void swap(Node *a, Node *b) {
    int temp1;
    float temp2;
    char temp3;
    // 交换 data1
    temp1 = a->data1;
    a->data1 = b->data1;
    b->data1 = temp1;
    // 交换 data2
    temp2 = a->data2;
    a->data2 = b->data2;
    b->data2 = temp2;
    // 交换 data3
    temp3 = a->data3;
    a->data3 = b->data3;
    b->data3 = temp3;
}

// 对链表进行冒泡排序
void bubbleSort(Node *head) {
    Node *p, *q;
    int changed;
    // 当链表为空或只有一个节点时，无需排序
    if (head == NULL || head->next == NULL) {
        return;
    }
    // 外层循环控制排序轮数
    for (p = head; p->next != NULL; p = p->next) {
        changed = 0;
        // 内层循环进行一轮冒泡排序
        for (q = head; q->next != NULL; q = q->next) {
            // 如果前一个节点的数据小于后一个节点的数据，交换节点数据
            if (q->data1 < q->next->data1) {
                swap(q, q->next);
                changed = 1;
            }
        }
        // 如果一轮冒泡排序中没有进行任何数据交换，说明已经排好序，退出循环
        if (changed == 0) {
            break;
        }
    }
}

// 输出链表
void printList(Node *head) {
    Node *p;
    for (p = head; p != NULL; p = p->next) {
        printf("%d %.2f %c\n", p->data1, p->data2, p->data3);
    }
}

int main() {
    // 创建链表
    Node *head = NULL;
    Node *p1 = (Node *)malloc(sizeof(Node));
    p1->data1 = 5;
    p1->data2 = 3.14;
    p1->data3 = 'A';
    head = p1;
    Node *p2 = (Node *)malloc(sizeof(Node));
    p2->data1 = 2;
    p2->data2 = 1.23;
    p2->data3 = 'B';
    p1->next = p2;
    Node *p3 = (Node *)malloc(sizeof(Node));
    p3->data1 = 8;
    p3->data2 = 4.56;
    p3->data3 = 'C';
    p2->next = p3;
    p3->next = NULL;

    // 输出原始链表
    printf("Original list:\n");
    printList(head);

    // 对链表进行排序
    bubbleSort(head);

    // 输出排序后的链表
    printf("Sorted list:\n");
    printList(head);

    // 释放链表节点内存
    Node *p, *q;
    for (p = head; p != NULL; p = q) {
        q = p->next;
        free(p);
    }

    return 0;
}

注意，这里使用了冒泡排序算法，时间复杂度为 O(n^2)，对于大规模链表可能不太适用，可以考虑使用其他排序算法。同时，对于节点包含多个数据成员需要全部交换的情况，可以定义一个 `swap` 函数来进行节点数据的交换。