单链表的排序操作

第1关：单链表的冒泡排序算法

任务描述

本关任务：输入N个无序的整数，建立一个无序链表，利用冒泡排序算法将链表中的结点按照数值非降序排列。

测试说明

平台会对你编写的代码进行测试：

测试输入：
10
29 62 73 90 46 43 38 76 52 93

输入说明：
第一行为n，表示n个整数。
第二行为n个整数。

预期输出：
29 62 73 90 46 43 38 76 52 93
29 62 73 46 43 38 76 52 90 93
29 62 46 43 38 73 52 76 90 93
29 46 43 38 62 52 73 76 90 93
29 43 38 46 52 62 73 76 90 93
29 38 43 46 52 62 73 76 90 93
29 38 43 46 52 62 73 76 90 93
29 38 43 46 52 62 73 76 90 93
29 38 43 46 52 62 73 76 90 93

代码如下

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
void swap(ElemType &a,ElemType &b);

/* 单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
void BubbleSort(LinkList  L);

int main()              
{	
    LinkList  head;          //定义一个LinkList 型的变量head
    ElemType  a[100 ];
    int n,i;
    scanf("%d",&n);
    for(i=1; i<=n; i++ )                //输入数组所有元素
    {
        input(a[i]);
    }
    InitList(head);
    for(i=1;i<=n;i++)     //将数组元素插入到单链表head中
    { 
        ListInsert(head, i, a[i]);
    }
    BubbleSort(head);
    return 0;  
}


/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
	cin>>s;
}
void output(ElemType s)
{
	cout<<s<<" ";
}
void swap(ElemType &a,ElemType &b)
{
    ElemType t;
    t=a; a=b;b=t;		
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{ 
	// 操作结果：构造一个空的单链表L
	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
	if(!L) // 存储分配失败
		return ;
	L->next=NULL; // 指针域为空
}
int ListInsert(LinkList &L,int i,int e) 
{	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
	LinkList p,s;
	p = L;   
	int j = 0;
	while (p && j < i-1) 
	{  // 寻找第i-1个结点
		p = p->next;
		++j;
	} 
	if (!p || j > i-1) 
		return 0;                   // i小于1或者大于表长
	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
	s->data = e;  s->next = p->next;      // 插入L中
	p->next = s;
	return 1;
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 	// 初始条件：单链表L已存在。
 	//操作结果：依次对L的每个数据元素调用函数vi()
	LinkList p=L->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");
}


void BubbleSort(LinkList L)   //单链表的冒泡排序算法 
{
	//用冒泡法将带头结点的单链表排成一个有序的单链表
	/********** Begin **********/ 
	int i,count=0,num;
	LinkList p,q,t;
	p=L;
	while(p->next)
	{
		count++;
		p=p->next;
	}
	for(i=0;i<count-1;i++)
	{
		num=count-i-1;
		q=L->next;
		p=q->next;
		t=L;
		while(num--)
		{
			if(q->data>p->data)
			{
				q->next=p->next;
				p->next=q;
				t->next=p;
			}
			t=t->next;
			q=t->next;
			p=q->next;
		}
		ListTraverse(L,output);
	}
	/********** End **********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

第2关：单链表的选择排序算法

任务描述

本关任务：输入N个无序的整数，建立一个无序链表，利用选择排序算法将链表中的结点按照数值非降序排列。

测试说明

平台会对你编写的代码进行测试：

测试输入：
10
88 84 23 85 32 34 80 52 91 77

预期输出：
23 84 88 85 32 34 80 52 91 77
23 32 88 85 84 34 80 52 91 77
23 32 34 85 84 88 80 52 91 77
23 32 34 52 84 88 80 85 91 77
23 32 34 52 77 88 80 85 91 84
23 32 34 52 77 80 88 85 91 84
23 32 34 52 77 80 84 85 91 88
23 32 34 52 77 80 84 85 91 88
23 32 34 52 77 80 84 85 88 91
23 32 34 52 77 80 84 85 88 91

提示：
如果有10个整数，要求输出每趟选择排序共9趟的结果。

代码如下

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;

/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
void swap(ElemType &a,ElemType &b);

/* 单链表类型定义 */
typedef struct LNnode
{	
	ElemType data;
	struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListInsert(LinkList &L,int i,int e) ;
void ListTraverse(LinkList L,void(*vi)(ElemType));
void SelectedSort(LinkList L);  //单链表的选择排序算法

int main()              
{	
    LinkList  head;          //定义一个LinkList 型的变量head
    ElemType  a[100 ];
    int n,i;
    scanf("%d",&n);
    for(i=1; i<=n; i++ )                //输入数组所有元素
    {
        input(a[i]);
    }
    InitList(head);
    for(i=1;i<=n;i++)     //将数组元素插入到单链表head中
    { 
        ListInsert(head, i, a[i]);
    }
    SelectedSort(head);
    return 0;  
}


/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
	cin>>s;
}
void output(ElemType s)
{
	cout<<s<<" ";
}
void swap(ElemType &a,ElemType &b)
{
    ElemType t;
    t=a; a=b;b=t;		
}

/*****单链表的基本操作*****/
void InitList(LinkList &L)
{ 
	// 操作结果：构造一个空的单链表L
	L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
	if(!L) // 存储分配失败
		return ;
	L->next=NULL; // 指针域为空
}
int ListInsert(LinkList &L,int i,int e) 
{	// 在带头结点的单链线性表L的第i个元素之前插入元素e  
	LinkList p,s;
	p = L;   
	int j = 0;
	while (p && j < i-1) 
	{  // 寻找第i-1个结点
		p = p->next;
		++j;
	} 
	if (!p || j > i-1) 
		return 0;                   // i小于1或者大于表长
	s = (LinkList)malloc(sizeof(LNnode));  // 生成新结点
	s->data = e;  s->next = p->next;      // 插入L中
	p->next = s;
	return 1;
}

void ListTraverse(LinkList L,void(*vi)(ElemType))
{ 	// 初始条件：单链表L已存在。
 	//操作结果：依次对L的每个数据元素调用函数vi()
	LinkList p=L->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");
}


void SelectedSort(LinkList L) 
{	//用选择排序算法将带头结点的单链表排成一个有序的单链表
	/********** Begin **********/ 
	LinkList p,q,k;
	ElemType t;
	for(p=L->next;p->next;p=p->next){
		k=p;
		for(q=p->next;q;q=q->next)
			if(q->data<=k->data) k=q;
		if(k!=p){
			t=k->data;
			k->data=p->data;
			p->data=t;
		}
		ListTraverse(L,output);
	}
	ListTraverse(L,output);
	/********** End **********/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116