void Order(LinkList *head,int length){

    head -> next = NULL;

    for(int i = 0; i < length; i++){

        LinkList *p = head -> next;

        LinkList *q;    

        LinkList *min = p;

        while(p -> next){

            if( p-> next -> data < min -> data){

                q = p;

                min = p -> next;

            }

            p = p -> next;

        }

        min -> next = head -> next;

        head -> next = min;

    }

    return head;

}

void sortList(LNode* head){
    LNode *p, *q;
    p = head->next;
    while(p){
        LNode* min = p;
        q = p->next;
        while(q){//找到还未加入有序序列中最小值节点
            if(q->data < min->data){
                min = q;
            }
            
            q = q->next;
        }
        
        if(min->data < p->data){//将当前最小值加入有序序列
            swap(p->data, min->data);
        }
        
        p = p->next;//继续向后比较
    }
}

void sort(Lnode *head)
{
	Lnode *p, *q, *t;
	p = head -> next;
	while(p)
	{
		Lnode *min = p;
		q = min -> next;
		
		while(q)
		{
			if(q -> data < min -> data)
				min = q;
			
			q = q -> next 
		}
		
		if(p -> data != min -> data)
		{
			int t = min -> data;
			min -> data = p -> data;
			p -> data = t;
		}
		
		p = p -> next;
	}
} 

void assending(Lnode *head)

    {Lnode *p,*q , *r, *s;

     p=head->next; q=p->next; p->next=NULL;

     while(q)

{r=q; q=q->next;

if(r->data<=p->data)

{r->next=p; head->next=r; p=r; }

else

{while(!p && r->data>p->data)

{s=p; p=p->next; }

r->next=p; s->next=r;}

p=head->next; }

    }

#include<stdio.h>

#include<stdlib.h>

typedef struct Link {

    int data;

    struct Link *next;

} link;

// 创建单向链表

link *creatlinklist(int a[], int size) {

    link *head = (link*)malloc(sizeof(link));

    head->data = a[0];

    head->next = NULL;

    link *temp = head;

    for(int i = 1; i < size; i++) {

        link *p = (link*)malloc(sizeof(link));

        p->data = a[i];

        p->next = NULL;

        temp->next = p;

        temp = temp->next;

    }

    return head;

}

// 显示链表

void display(link *head) {

    link *temp = head;

    while(temp) {

        printf("%d", temp->data);

        if(temp->next != NULL)

            printf("->");

        temp = temp->next;

    }

    printf("\n");

}

// 链表的冒泡排序

link *paixu(link *head, int size) {

    for(int i = 0; i < size - 1; i++) {

        link *temp = head;

        link *qemp = head->next;

        for(int j = 0; j < size - i - 1; j++) {

            if(temp->data > qemp->data) {

                int n = temp->data;

                temp->data = qemp->data;

                qemp->data = n;

            }

            temp = temp->next;

            qemp = qemp->next;

        }

    }

    return head;

}

int main() {

    int a[] = {5, 2, 9, 3, 7, 1, 8, 6};

    int size = sizeof(a) / sizeof(a[0]);

    link *head = creatlinklist(a, size);

    printf("排序前链表: ");

    display(head);

    head = paixu(head, size);

    printf("排序后链表: ");

    display(head);

    return 0;

}

typedef struct LNode{

    int data;

    LNode *next;

}LNode,*LinkList;

void InsertSort(LinkList &head){

    if(head->next==NULL)

        return;

    LNode *pre,*p,*q,*r;

    p=head->next->next;

    L->next->next=NULL;

    while(p!=NULL){

        pre=head;

        q=pre->next;

        while(q!=NULL&&q->data<p->data){

            pre=q;

            q=q->next;

        }

        r=p->next;//防断链

        pre->next=p;

        p->next=q;

        p=r;

    }

}

Node （Node &L）{

Node* p，q,result,mark;

if(L==NULL){

return NULL;

}

p=L;

result=L;

while(p->next !=NULL){

Node* temp = p;

q=result;

while(p->val>q-val)

{

mark =q;
q=q->next;

}

mark->next = p;

p->next = q;

p=temp;

}

return result;

}

void select_sort(LinkList L){
    Lnode *p=L->next;
    if(p==NULL){
        return ;
    }
    while(p!=NULL){
        q=p->next;
        min=p;
        while(q!=NULL){
            if(q->data<min-data){
                min=q;
            }
            q=q-next;
        }
        if(min!=p){
            ElemType temp=p->data;
            p->data=min->data;
            min->data=min;
        }
        p=p->next;
    }
}

if(head->next==NULL||head->next->next==NULL)return;

Node *p, *tail=NULL;

p=head->next;

while(head->next!=tail)

{

    while(p->next!=tail)

    {

        if(p->data>p->next->data)

        {

            ElemType temp=p->data;

            p->data=p->next->data;

            p->next->data=temp;

        }

        p=p->next;

    }

    tail=p;

}

vbb

typedef struct LNode{

    int data;

    LNode *next;

}LNode,*LinkList;

void InsertSort(LinkList &head){

    if(head->next==NULL)

        return;

    LNode *pre,*p,*q,*r;

    p=head->next->next;

    L->next->next=NULL;

    while(p!=NULL){

        pre=head;

        q=pre->next;

        while(q!=NULL&&q->data<p->data){

            pre=q;

            q=q->next;

        }

        r=p->next;//防断链

        pre->next=p;

        p->next=q;

        p=r;

    }

}

void Paixu(Lnode* head) {
    Lnode* p, * q, * s;
    p = head->next;
    while (p&&*(p->next!=NULL)) {
        q = p->next;
        s = p;
        while (q) {
            if (q->data < s->data)
                s = q;
            q = q->next;
        }
        if (s != p) {
            head->data = p->data;
            p->data = s->data;
            s->data = head->data;
        }
        p = p->next;
    }
}

typedef struct LinkNode{
	int data;
	struct LinkNode *next;
}LinkNode,*LinkList;

void merge(LinkList &head){
	LinkNode *p = head->next;
	while(p != NULL){
		LinkNode *min = p;
		LinkNode *q = min->next;
		while(q != NULL){
			if(min->data > q->data)
				min = q;
			q = q->next;
		}
		
		if(min!= p){
			int temp = p->data;
			p->data = min->data;
			min->data = temp;
		}
		p=p->next;
	}
	
}

// 定义链表节点结构
struct Lnode {
    int data;
    Lnode* next;
};

// 链表排序函数
void sort(Lnode* l) {

    Lnode* p = l->next; // 从头节点开始，而不是l->next
    
    while (p != NULL) {
        Lnode* min = p; // 将变量名从mi_改为min，更具描述性
        Lnode* q = p->next;
        
        // 寻找从p到链表末尾中的最小元素
        while (q != NULL) {
            if (min->data > q->data) {
                min = q;
            }
            q = q->next;
        }
        
        // 如果找到的最小元素不是p，则交换数据
        if (min != p) {
            int temp = p->data; // 使用temp作为临时变量名
            p->data = min->data;
            min->data = temp;
        }
        
        p = p->next; // 移动到下一个节点
    }
}

//数组法

void quicksort(int q[],int l,int r)

{

   if(l >= r) return;

   int i = l-1, j = r +1;

  int x = q[l+r >> 1];

  while(i<j) 

  {

   do i ++ ;while(q[i]<x);

   do j -- ; while(q[j] >x);

}

 if(i<=j)

{

 swap(q[i],q[j]);

}

    quick_sort(q,l,j);
    quick_sort(q,j+1,r);

}

while(p) 的作用等同于 while(NULL != p)

答案第二个while多了个!

我同意南秋的答案，懒得ctrl+C/V了

void Sorted(LinkNode* head)

{

//先将结点存在一个数组里面吧！

LinkNode* p=head->next;

LInkNode* nodes[maxSize];

int i=0;

while(p!=NULL)

{

node[i++] =p;

p=p->next; 

};

//进行排序就随便一个简单选择排序

LinkList* temp;

for(int j=0;j<i;j++){

    temp=nodes[j];

   for(int k=j;k<i;k++){

          if(node[k]->data<temp->data)  temp = node[k];

    } 

node[i]=temp;

}

//再将链表重新搞回去

p=head;

for(int m=0;m<i;m++)

{

p->next=nodes[m];

p=p->next;

}

return;

}

void assending(Lnode *head)
{//加注释帮助理解 
    Lnode *p,*q , *r, *s;

    p=head->next; //第一个元素 
    q=p->next; //第二个元素 
    p->next=NULL; //链表第一个元素之后置空 
    while(q)
    {
        r=q;  
        q=q->next; //q向后指 
        if(r->data <= p->data)
        {
            //当前q指向的结点关键值小于或等于链表第一个结点的关键值
            //则头插法即可 
            r->next=p; 
            head->next=r; 
            p=r;
        }
        else
        {
            //否则向后查找到第一个大于该结点关键值的结点 
            while(!p && r->data>p->data)
            {
                s=p; //指向p的前一个结点 
                p=p->next; 
            }
            //p指向第一个大于r关键值的结点 
            r->next=p; 
            s->next=r;
        }
         p=head->next; //p再更新为链表的第一个结点 
    }

}

void asc(LinkList *L){

      LinkList *pre,*p,*r;

      p=L->next;

      r=p->next;

      p->next=null;

      p=r;

      while(p){

            pre=L;

            r=p->next;

            while(pre->next != null && pre->next->data < p->data){

                    pre=pre->next;

            }

            p->next=pre->next;

            pre->next=p;

            p=r;

      }

}

void ascending(Lnode *head) {
    Lnode *p, *q, *r, *s;

    p = head->next;  // 初始化p为头结点后的第一个节点
    q = p->next;     // 初始化q为p的下一个节点
    p->next = NULL;  // 将头结点之后的节点串成一个新链表

    while (q) {
        r = q;      // r指向当前要插入的节点q
        q = q->next; // q指向下一个待插入的节点

        if (r->data <= p->data) {
            // 如果r的data小于或等于p的data，将r插入到链表头部
            r->next = p;
            head->next = r;
            p = r; // 更新p为新插入的节点r
        } else {
            // 否则，在已排序的链表中找到适当的位置插入r
            while (p && r->data > p->data) {
                s = p;  // s指向当前p的前一个节点
                p = p->next; // 移动p到下一个节点
            }
            r->next = p;
            s->next = r;
            p = head->next; // 重新将p指向链表头部，以便下一次插入
        }
    }
}

不知

void accting(List &head int n)

{

int flag=1;

List p=head;

List q=head;

Lisr tamp=new Lnode;

for(int i=0;i<=n&&flag==1;i++)

flag=0;

p=p->next;

q=p->next;
for(int j=i;j<=n;j++)

{

if(q->data<p->data)
{

flag=1;

tamp->data=q->data;

q->data=p->data;

p->data=tamp->date;

}

}

}

void accting(List &head int n)

{

List p=head;

List q=head;

Lisr tamp=new Lnode;

for(int i=0;i<=n;i++)

p=p->next;

q=p;
for(int j=i;j<=n;j++)

{

q=q->next;

if(q->data<p->data)
{

tamp->data=q->data;

q->data=p->data;

p->data=tamp->date;

}

}

}

void assending(Lnode *head){

    Lnode *p,*q , *r, *s;

    p=head->next; q=p->next; p->next=NULL;

    while(q){

        r=q; q=q->next;

        if(r->data<=p->data){

            r->next=p; head->next=r; p=r;

        }

        else{

            while(!p && r->data > p->data){

                s=p; p=p->next;

            }

            r->next=p; s->next=r;

        }

        p=head->next;

    }

}

void assending(Lnode *head){Lnode *p,*q , *r, *s;p=head->next; q=p->next; p->next=NULL;while(q){r=q; q=q->next;if(r->data<=p->data) {r->next=p; head->next=r; p=r; }else{while(!p && r->data>p->data){     s=p; p=p->next; }r->next=p; s->next=r;}p=head->next; }}

LinkList sort(LinkList &head){

  LNode *p,*q,*r,*temp;

  p=head;//指向第一个有效元素的前驱

  q=p->next;//指向第一个有效元素

  if(q==NULL) return;

  head->next=NULL;

  while(p->next!=NULL){//头插法实现链表重新排序

    while(q!=NULL){//从头到尾遍历一遍单链表，每次遍历筛选出一个值最大结点

      if(q->data>=q->next->data){

         temp=p;

         p=p->next;

         q=q->next;

      }

      else{

        p=p->next;

        q=q->next;

      }

    r=temp->next;//将值最大结点以头插法插入新的链表中

    temp->next=r->next;

    r->next=head->next;

    head->next=r;

  }

void asc(LinkList L)

{

    LinkNode * p = L->next;

    LinkNode * q = p->next;

    p->next = NULL;

    while(q)

    {

        while(p->next && q->data > p->next->data)

        {

            p = p->next ;

        }

        q->next = p->next;

        p->next = q;

        q = q->next;

        p = L->next;

    }

}

void sortLinkedList(struct ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return;
    }

    struct ListNode* curr = head->next;
    struct ListNode* prev = head;
    struct ListNode* temp;

    int swapped;
    do {
        swapped = 0;
        curr = head->next;
        prev = head;

        while (curr->next != NULL) {
            if (curr->data > curr->next->data) {
                temp = curr->next;
                curr->next = curr->next->next;
                temp->next = curr;
                prev->next = temp;
                swapped = 1;
            }
            prev = curr;
            curr = curr->next;
        }
    } while (swapped);
}

void assending(Lnode *head)

    {Lnode *p,*q , *r, *s;

     p=head->next; q=p->next; p->next=NULL;

     while(q)

{r=q; q=q->next;

if(r->data<=p->data)

{r->next=p; head->next=r; p=r; }

else

{while(!p && r->data>p->data)

{s=p; p=p->next; }

r->next=p; s->next=r;}

p=head->next; }

    }

应该是链式归并排序是最优解吧

p=L->next;r=p->next; p-›next=NULL;//断p-r p=r; while(p)｛ pre=L;r=p-›next;//每次都是从首位开始比较 while(pre-›next!=NULL&&pre-›next-›data‹p-›data) pre=pre-›next;//元素递增 p-›next=pre-›next; pre-›next=p; p=r；//切换

void P1075(LinkList head){
    LNode *p = nullptr, *q;
    int temp;
    bool flag;
    while (p != head->next->next){
        q = head->next;
        flag = false;
        while (q->next != p){
            if (q->data > q->next->data){
                temp = q->data;
                q->data = q->next->data;
                q->next->data = temp;
                flag = true;
            }
            q = q->next;
        }
        p = q;
        if (!flag) return;
    }
}

void assending(List *head)

{

    List *p,*q , *r, *s;

    p=head->next; q=p->next; p->next=NULL;

    while(q)

    {

        r=q;

        q=q->next;

        if(r->data<=p->data)

        {

            r->next=p;

            head->next=r;

            p=r;

        }

        else

        {

            while(!p && r->data>p->data)

            {

                s=p;

                p=p->next;

            }

            r->next=p; s->next=r;

        }

        p=head->next;

    }

}

#include<stdio.h>
#include<stdlib.h>
#define M (List)malloc(sizeof(Node))
typedef struct Node{
    int data;
    Node* next;
}*List,Node;

//创建无头结点单链表
List create(int n){
    int i,x;
    List head,tail;
    head=tail=NULL;
    for(i=0;i<n;i++){
        scanf("%d",&x);
        List p=M;
        p->data=x;
        if(head==NULL){
            head=p;
            tail=p;
        }else{
            tail->next=p;
            tail=p;
        }
    }
    tail->next=NULL;
    return head;
}
//使用插入排序
void InsertSort(List head){
    void print(List head);
    List p=head->next,q=head;
    while(p!=NULL){
        if(p->data<q->data){
            List t=head;
            while(1){
                if(t->data<p->data) t=t->next;
                else{
                    List tmp=M;
                    tmp->data=t->data;
                    t->data=p->data; 
                    tmp->next=t->next;
                    t->next=tmp;
                    if(t==q) q=q->next;
                    break;
                }
            }
            q->next=p->next;
            p=q->next; 
        }else{
            q=p;
            p=p->next;
        }
    }
} 
//打印单链表 
void print(List head){
    List p=head;
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int main(){
    int n;
    scanf("%d",&n);
    List L1=create(n);
//    print(L1);
    InsertSort(L1);
    print(L1); 
    return 0;
}

LinkList Sort(LinkList head){

LNode *p,*q;

ElemType temp;

if (head->next == NULL || head->next->next == NULL)         // head为空链表或只有一个元素时直接返回

return head;

for (p=head->next->next; p->next->next!=NULL; p=p->next){            // p为头结点的后继结点，一直循环到倒数第二个结点

for( q=p->next; q->next!=NULL; q=q->next){

if (p->data > q->data){

temp = q->data;

q->data = p->data;

p->data = temp;

}

}

}

return head;

}

Lnode asserting(Lnode *head)

{

    Lnode *p = head;

    int n = length(head), temp;

    if (head == NULL || head->next == NULL)

        return head;

    // 最大的冒泡到最后

    for (int i = 0; i < n; i++)

    {

        p = head;

        for (int j = 0; j < n - i; j++)

        {

            if (p->data > p->next->data)

            {

                temp = p->next->data;

                p->next->data = p->data;

                p->data = temp;

            }

        }

    }

    return head;

}