在此程序中，函数fun的功能是将带头结点的单向链表结点数据域中的数据从小到大排序。\n\n即若原链表结点数据域从头至尾的数据为:10、 4、2、8、6，排序后链表结点数据域从头至尾的数据为: 2、4、6、8、10。\n\n#include \u003Cstdio.h>\n#include \u003Cstdlib.h>\n#define N 6\ntypedef struct node {\n int data;\n struct node *next;\n} NODE;\nvoid fun(NODE *h)\n{ NODE *p, *q; int t;\n/**********found**********/\n p = __1__ ;\n while (p) {\n/**********found**********/\n q = __2__ ;\n while (q) {\n/**********found**********/\n if (p->data __3__ q->data)\n { t = p->data; p->data = q->data; q->data = t; }\n q = q->next;\n }\n p = p->next;\n }\n}\nNODE *creatlist(int a[])\n{ NODE *h,*p,*q; int i;\n h = (NODE *)malloc(sizeof(NODE));\n h->next = NULL;\n for(i=0; i\u003CN; i++)\n { q=(NODE *)malloc(sizeof(NODE));\n q->data=a[i];\n q->next = NULL;\n if (h->next == NULL) h->next = p = q;\n else { p->next = q; p = q; }\n }\n return h;\n}\nvoid outlist(NODE *h)\n{ NODE *p;\n p = h->next;\n if (p==NULL) printf(\"The list is NULL!\\n\");\n else\n { printf(\"\\nHead \");\n do\n { printf(\"->%d\", p->data); p=p->next; }\n while(p!=NULL);\n printf(\"->End\\n\");\n }\n}\nvoid main()\n{ NODE *head;\n int a[N]= {0, 10, 4, 2, 8, 6 };\n head=creatlist(a);\n printf(\"\\nThe original list:\\n\");\n outlist(head);\n fun(head);\n printf(\"\\nThe list after sorting :\\n\");\n outlist(head);\n}

函数fun的功能是对带头结点的单向链表进行排序，将结点数据域中的数据从小到大排列。例如，如果原链表结点数据域从头至尾的数据为10、4、2、8、6，调用函数fun后，排序后的链表结点数据域从头至尾的数据就会变成2、4、6、8、10。

相关问题

给定程序中，函数的功能是将带头结点的单向链表结点数据域中的数据从小到大排序。用C语言写

以下是一种可能的实现方式：

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

void sortLinkedList(Node* head) {
    Node* p1, * p2;
    int temp;
    for (p1 = head->next; p1 != NULL; p1 = p1->next) {
        for (p2 = p1->next; p2 != NULL; p2 = p2->next) {
            if (p1->data > p2->data) {
                temp = p1->data;
                p1->data = p2->data;
                p2->data = temp;
            }
        }
    }
}

其中，head 为带头结点的单向链表的头结点，p1 和 p2 为链表中的两个结点指针，temp 为临时变量用于交换数据。算法采用冒泡排序的思想，即从第一个结点开始，和后面的结点比较大小，如果前面的大于后面的，则交换数据，一直到链表结尾。时间复杂度为 O(n^2)。

请建立一个带头结点的单向链接表。函数fun的作用是求出单向链表结点（不包括头结点）数据域中的最大值，并且作为函数值返回。

以下是建立带头结点的单向链接表的代码：

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

typedef struct Node {
    int data;
    struct Node *next;
} Node, *LinkedList;

LinkedList createLinkedList() {
    LinkedList head = (LinkedList)malloc(sizeof(Node));
    head->next = NULL;
    return head;
}

void insert(LinkedList head, int data) {
    Node *node = (Node*)malloc(sizeof(Node));
    node->data = data;
    node->next = head->next;
    head->next = node;
}

int fun(LinkedList head) {
    int max = head->next->data;
    Node *p = head->next->next;
    while (p != NULL) {
        if (p->data > max) {
            max = p->data;
        }
        p = p->next;
    }
    return max;
}

int main() {
    LinkedList list = createLinkedList();
    insert(list, 1);
    insert(list, 2);
    insert(list, 3);
    insert(list, 4);
    insert(list, 5);
    printf("Max value in linked list: %d\n", fun(list));
    return 0;
}

输出结果为：

Max value in linked list: 5

这个程序建立了一个带头结点的单向链接表，并且实现了一个函数 `fun`，它可以求出单向链表结点（不包括头结点）数据域中的最大值，并且作为函数值返回。