设一个带头结点的单向链表的头指针为head，设计算法，将链表的记录，按照data域的值递增排序。_

202233113

2025年6月29日 13:04

int headz(LNode *head){

}

2025年4月3日 11:48

void InsertionSort(LinkList head) {
if (head == NULL || head->next == NULL) return; // 空表或单节点无需排序

LinkList sorted = head->next; // 已排序部分的尾节点（初始为第一个节点）
LinkList unsorted = sorted->next; // 未排序部分的头节点
sorted->next = NULL; // 断开已排序和未排序部分

while (unsorted != NULL) {
LinkList curr = unsorted; // 当前待插入节点
unsorted = unsorted->next; // 移动未排序指针

// 在已排序部分中找到插入位置的前驱节点
LinkList prev = head; // 从头结点的下一个节点开始比较
while (prev->next != NULL && prev->next->data < curr->data) {
prev = prev->next;
}

// 插入节点
curr->next = prev->next;
prev->next = curr;
}
}

吃不饱的七仔

2025年3月16日 12:17

void insertSort(Lnode *head) {
   Lnode* a = head;
   Lnode* p1 = a->next->next; //当前要排序的节点
   a->next->next = NULL; //将排序好的末尾节点设为NULL
   Lnode* p2 = p1->next; //未排节点的首节点
   while(1){
       while(a->next != NULL && a->next->data < p1->data){ //依次比较排序好的区域与待排序的节点
           a = a->next;
       }
       p1->next = a->next;
       a->next = p1;
       a = head;

       p1 = p2;
       if(p2 == NULL) break;
       p2 = p2->next;
   }
}

single

2025年3月13日 16:47

1

plutoczm

2025年3月3日 20:24

// 插入排序函数
void insertionSort(Node* head) {
Node* sorted = NULL; // 排序好的链表的头
Node* current = head->next; // 当前节点，初始为头结点之后的第一个节点

while (current != NULL) {
Node* next = current->next; // 保存下一个节点

// 将 current 插入到 sorted 链表中合适的位置
if (sorted == NULL || sorted->data >= current->data) {
// 将 current 插入到 sorted 的最前面
current->next = sorted;
sorted = current;
} else {
// 寻找合适的位置
Node* temp = sorted;
while (temp->next != NULL && temp->next->data < current->data) {
temp = temp->next;
}
current->next = temp->next;
temp->next = current;
}

// 处理下一个节点
current = next;
}

// 头结点指向排序好的链表
head->next = sorted;
}

KaranoKyoukai

2025年3月3日 14:45

void sort(LinkList head)
{
    if (head == NULL || head->next == NULL || head->next->next == NULL)
    {
        return;
    }

    LNode *p = head->next;
    for (; p->next != NULL; p = p->next)
    {
        int min = p->data;
        LNode *minNode = p;
        for (LNode *q = p; q != NULL; q = q->next)
        {
            if (q->data < min)
            {
                min = q->data;
                minNode = q;
            }
        }
        minNode->data = p->data;
        p->data = min;
    }
}

CaoRui

2025年3月1日 21:38

// 交换两个节点的数据域
void change(londe* l1, londe* l2) {
int temp = l1->data;
l1->data = l2->data;
l2->data = temp;
}

// 对链表进行冒泡排序，使数据域递增
void dataup(londe* l) {
if (l == NULL || l->next == NULL) {
return; // 链表为空或只有一个节点，无需排序
}
int n = 0;
londe* q = l->next;
// 计算链表的长度
while (q != NULL) {
n++;
q = q->next;
}
for (int i = 0; i < n - 1; i++) {
londe* p = l->next;
q = p->next;
for (int j = 0; j < n - i - 1; j++) {
if (p->data > q->data) {
change(p, q);
}
p = q;
q = q->next;
}
}
}

月色真美

2025年2月24日 10:46

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; }

}

muquew

2024年11月11日 21:52

1

void sortDel(LinkList* L){
    LinkList *p,*pre,*minp,*minpre;
    LinkList* temp;
    while(L->next!=NULL){
        p = L->next;
        pre = L;
        minpre = pre;
        minp = p;
        while(p!=NULL){
            if(p->data < minp->data){ //min<当前节点值,修改最小值节点
                minpre = pre;
                minp = p;
            }
            p = p->next;
            pre = pre->next;
        }
        temp = minp;
        //重新连接链表，防断链
        minpre->next = minp->next;
        free(temp);
    }
    //释放头节点
    free(L);
}

wwj0102

2024年11月10日 16:31

void sortLink(LinkList head){

LNode *p = head->next;

LNode *q = p->next;

LNode *temp = NULL;

while(p->next->next != NULL){

q = p->next;

while(q != NULL){

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

temp->data = p->data;

p->data = q->data;

q->data = temp->data;

}

q = q->next;

}

p = p->next;

}

wangcai

2024年10月16日 23:24

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;

}

mhhhx

2024年10月11日 15:26

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;//继续向后比较
}
}

Candour

2024年9月29日 16:18

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;
	}
}

Conan_G

2024年9月12日 14:54

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; }

}

2893385654

2024年9月6日 21:07

#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;

}

步步高

2024年9月3日 20:02

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;

}

adgdsfa

2024年9月3日 15:27

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;

}

折翼的小鸟先生

2024年8月29日 14:16

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;
   }
}

嘤狐

2024年8月29日 13:38

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;

}

现在只想上岸

2024年8月27日 11:33

vbb

缘小遇

2024年8月14日 14:49

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;

}

Mapleman

2024年8月14日 10:14

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;
   }
}

与或非

2024年7月26日 17:37

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;
	}
	
}

Austin00

2024年7月26日 12:11

// 定义链表节点结构
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; // 移动到下一个节点
    }
}

刷题小子

2024年6月13日 21:37

//数组法

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);

}

公交车呢

2024年3月12日 21:31

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

答案第二个while多了个!

公交车呢

2024年3月12日 21:04

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

carrot_huan

2023年11月30日 20:29

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;

}

woaixinzhou

2023年11月19日 22:42

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再更新为链表的第一个结点
   }

}

山药男孩

2023年11月2日 21:13

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;

}

南秋

2023年10月2日 21:34

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指向链表头部，以便下一次插入
        }
    }
}

lightstar

2023年9月6日 22:00

不知

高康

2023年7月31日 15:55

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;

}

高康

2023年7月24日 21:39

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;

}

Syou

2023年7月21日 21:37

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;

}

17563267197

2023年7月21日 07:36

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; }}

Friday

2023年7月11日 15:47

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;

}

WhiteWing

2023年7月7日 22:31

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;

}

Nirvana-T

2023年5月20日 18:49

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);
}

13245372484

2023年4月1日 18:35

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; }

}

逆风

2022年11月15日 11:17

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

MSjJustin

2022年9月28日 12:50

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；//切换

jiangxin1125

2022年8月14日 22:42

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;
    }
}

一只发财鸭

2022年3月11日 15:41

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;

}

冲冲冲123···

2022年2月13日 17:43

#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;
}

hulin

2021年9月7日 11:28

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;

}

chenguangjie

2021年6月11日 15:46

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;

}

[数据结构 P1075] 设一个带头结点的单向链表的头指针为head，设计算法，将链表的记录，按照data域的值递增排序。

登录后提交答案