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;

}