C语言排序

//总共给你整理了7种排序算法：希尔排序，链式基数排序，归并排序

//起泡排序，简单选择排序，树形选择排序，堆排序,先自己看看吧，

//看不懂可以再问身边的人或者查资料,既然可以上网，我相信你所在的地方信息流通方式应该还行,所有的程序全部在VC++6.0下编译通过

//希尔排序

#include<stdio.h>

typedef int InfoType// 定义其它数据项的类型

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)<(b))

#define LQ(a,b) ((a)<=(b))

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType// 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key// 关键字项

InfoType otherinfo// 其它数据项，具体类型在主程中定义

}

struct SqList // 顺序表类型

{

RedType r[MAXSIZE+1]// r[0]闲置或用作哨兵单元

int length// 顺序表长度

}

void ShellInsert(SqList &L,int dk)

{ // 对顺序高首表L作帆孙一趟希尔插入排序。本算法是和一趟直接插入排序相比，

// 作了以下修改：

// 1.前后记戚轿数录位置的增量是dk,而不是1

// 2.r[0]只是暂存单元,不是哨兵。当j<=0时,插入位置已找到。算法10.4

int i,j

for(i=dk+1i<=L.length++i)

if LT(L.r[i].key,L.r[i-dk].key)

{ // 需将L.r[i]插入有序增量子表

L.r[0]=L.r[i]// 暂存在L.r[0]

for(j=i-dkj>0&&LT(L.r[0].key,L.r[j].key)j-=dk)

L.r[j+dk]=L.r[j]// 记录后移，查找插入位置

L.r[j+dk]=L.r[0]// 插入

}

}

void print(SqList L)

{

int i

for(i=1i<=L.lengthi++)

printf("%d ",L.r[i].key)

printf("\n")

}

void print1(SqList L)

{

int i

for(i=1i<=L.lengthi++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo)

printf("\n")

}

void ShellSort(SqList &L,int dlta[],int t)

{ // 按增量序列dlta[0..t-1]对顺序表L作希尔排序。算法10.5

int k

for(k=0k<t++k)

{

ShellInsert(L,dlta[k])// 一趟增量为dlta[k]的插入排序

printf("第%d趟排序结果: ",k+1)

print(L)

}

}

#define N 10

#define T 3

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8},{55,9},{4,10}}

SqList l

int dt[T]={5,3,1}// 增量序列数组

for(int i=0i<Ni++)

l.r[i+1]=d[i]

l.length=N

printf("排序前: ")

print(l)

ShellSort(l,dt,T)

printf("排序后: ")

print1(l)

}

/*****************************************************************/

//链式基数排序

typedef int InfoType// 定义其它数据项的类型

typedef int KeyType// 定义RedType类型的关键字为整型

struct RedType // 记录类型(同c10-1.h)

{

KeyType key// 关键字项

InfoType otherinfo// 其它数据项

}

typedef char KeysType// 定义关键字类型为字符型

#include<string.h>

#include<ctype.h>

#include<malloc.h>// malloc()等

#include<limits.h>// INT_MAX等

#include<stdio.h>// EOF(=^Z或F6),NULL

#include<stdlib.h>// atoi()

#include<io.h>// eof()

#include<math.h>// floor(),ceil(),abs()

#include<process.h>// exit()

#include<iostream.h>// cout,cin

// 函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status// Status是函数的类型,其值是函数结果状态代码，如OK等

typedef int Boolean// Boolean是布尔类型,其值是TRUE或FALSE

#define MAX_NUM_OF_KEY 8 // 关键字项数的最大值

#define RADIX 10 // 关键字基数，此时是十进制整数的基数

#define MAX_SPACE 1000

struct SLCell // 静态链表的结点类型

{

KeysType keys[MAX_NUM_OF_KEY]// 关键字

InfoType otheritems// 其它数据项

int next

}

struct SLList // 静态链表类型

{

SLCell r[MAX_SPACE]// 静态链表的可利用空间，r[0]为头结点

int keynum// 记录的当前关键字个数

int recnum// 静态链表的当前长度

}

typedef int ArrType[RADIX]

void InitList(SLList &L,RedType D[],int n)

{ // 初始化静态链表L（把数组D中的数据存于L中）

char c[MAX_NUM_OF_KEY],c1[MAX_NUM_OF_KEY]

int i,j,max=D[0].key// max为关键字的最大值

for(i=1i<ni++)

if(max<D[i].key)

max=D[i].key

L.keynum=int(ceil(log10(max)))

L.recnum=n

for(i=1i<=ni++)

{

L.r[i].otheritems=D[i-1].otherinfo

itoa(D[i-1].key,c,10)// 将10进制整型转化为字符型,存入c

for(j=strlen(c)j<L.keynumj++) // 若c的长度<max的位数,在c前补'0'

{

strcpy(c1,"0")

strcat(c1,c)

strcpy(c,c1)

}

for(j=0j<L.keynumj++)

L.r[i].keys[j]=c[L.keynum-1-j]

}

}

int ord(char c)

{ // 返回k的映射(个位整数)

return c-'0'

}

void Distribute(SLCell r[],int i,ArrType f,ArrType e) // 算法10.15

{ // 静态键表L的r域中记录已按(keys[0],…,keys[i-1])有序。本算法按

// 第i个关键字keys[i]建立RADIX个子表,使同一子表中记录的keys[i]相同。

// f[0..RADIX-1]和e[0..RADIX-1]分别指向各子表中第一个和最后一个记录

int j,p

for(j=0j<RADIX++j)

f[j]=0// 各子表初始化为空表

for(p=r[0].nextpp=r[p].next)

{

j=ord(r[p].keys[i])// ord将记录中第i个关键字映射到[0..RADIX-1]

if(!f[j])

f[j]=p

else

r[e[j]].next=p

e[j]=p// 将p所指的结点插入第j个子表中

}

}

int succ(int i)

{ // 求后继函数

return ++i

}

void Collect(SLCell r[],ArrType f,ArrType e)

{ // 本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成

// 一个链表，e[0..RADIX-1]为各子表的尾指针。算法10.16

int j,t

for(j=0!f[j]j=succ(j))// 找第一个非空子表，succ为求后继函数

r[0].next=f[j]

t=e[j]// r[0].next指向第一个非空子表中第一个结点

while(j<RADIX-1)

{

for(j=succ(j)j<RADIX-1&&!f[j]j=succ(j))// 找下一个非空子表

if(f[j])

{ // 链接两个非空子表

r[t].next=f[j]

t=e[j]

}

}

r[t].next=0// t指向最后一个非空子表中的最后一个结点

}

void printl(SLList L)

{ // 按链表输出静态链表

int i=L.r[0].next,j

while(i)

{

for(j=L.keynum-1j>=0j--)

printf("%c",L.r[i].keys[j])

printf(" ")

i=L.r[i].next

}

}

void RadixSort(SLList &L)

{ // L是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字

// 自小到大的有序静态链表，L.r[0]为头结点。算法10.17

int i

ArrType f,e

for(i=0i<L.recnum++i)

L.r[i].next=i+1

L.r[L.recnum].next=0// 将L改造为静态链表

for(i=0i<L.keynum++i)

{ // 按最低位优先依次对各关键字进行分配和收集

Distribute(L.r,i,f,e)// 第i趟分配

Collect(L.r,f,e)// 第i趟收集

printf("第%d趟收集后:\n",i+1)

printl(L)

printf("\n")

}

}

void print(SLList L)

{ // 按数组序号输出静态链表

int i,j

printf("keynum=%d recnum=%d\n",L.keynum,L.recnum)

for(i=1i<=L.recnumi++)

{

printf("keys=")

for(j=L.keynum-1j>=0j--)

printf("%c",L.r[i].keys[j])

printf(" otheritems=%d next=%d\n",L.r[i].otheritems,L.r[i].next)

}

}

void Sort(SLList L,int adr[]) // 改此句(类型)

{ // 求得adr[1..L.length]，adr[i]为静态链表L的第i个最小记录的序号

int i=1,p=L.r[0].next

while(p)

{

adr[i++]=p

p=L.r[p].next

}

}

void Rearrange(SLList &L,int adr[]) // 改此句(类型)

{ // adr给出静态链表L的有序次序，即L.r[adr[i]]是第i小的记录。

// 本算法按adr重排L.r，使其有序。算法10.18(L的类型有变)

int i,j,k

for(i=1i<L.recnum++i) // 改此句(类型)

if(adr[i]!=i)

{

j=i

L.r[0]=L.r[i]// 暂存记录L.r[i]

while(adr[j]!=i)

{ // 调整L.r[adr[j]]的记录到位直到adr[j]=i为止

k=adr[j]

L.r[j]=L.r[k]

adr[j]=j

j=k// 记录按序到位

}

L.r[j]=L.r[0]

adr[j]=j

}

}

#define N 10

void main()

{

RedType d[N]={{278,1},{109,2},{63,3},{930,4},{589,5},{184,6},{505,7},{269,8},{8,9},{83,10}}

SLList l

int *adr

InitList(l,d,N)

printf("排序前(next域还没赋值):\n")

print(l)

RadixSort(l)

printf("排序后(静态链表):\n")

print(l)

adr=(int*)malloc((l.recnum)*sizeof(int))

Sort(l,adr)

Rearrange(l,adr)

printf("排序后(重排记录):\n")

print(l)

}

/*******************************************/

//归并排序

#include<stdio.h>

typedef int InfoType// 定义其它数据项的类型

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)<(b))

#define LQ(a,b) ((a)<=(b))

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType// 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key// 关键字项

InfoType otherinfo// 其它数据项，具体类型在主程中定义

}

struct SqList // 顺序表类型

{

RedType r[MAXSIZE+1]// r[0]闲置或用作哨兵单元

int length// 顺序表长度

}

void Merge(RedType SR[],RedType TR[],int i,int m,int n)

{ // 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] 算法10.12

int j,k,l

for(j=m+1,k=ii<=m&&j<=n++k) // 将SR中记录由小到大地并入TR

if LQ(SR[i].key,SR[j].key)

TR[k]=SR[i++]

else

TR[k]=SR[j++]

if(i<=m)

for(l=0l<=m-il++)

TR[k+l]=SR[i+l]// 将剩余的SR[i..m]复制到TR

if(j<=n)

for(l=0l<=n-jl++)

TR[k+l]=SR[j+l]// 将剩余的SR[j..n]复制到TR

}

void MSort(RedType SR[],RedType TR1[],int s, int t)

{ // 将SR[s..t]归并排序为TR1[s..t]。算法10.13

int m

RedType TR2[MAXSIZE+1]

if(s==t)

TR1[s]=SR[s]

else

{

m=(s+t)/2// 将SR[s..t]平分为SR[s..m]和SR[m+1..t]

MSort(SR,TR2,s,m)// 递归地将SR[s..m]归并为有序的TR2[s..m]

MSort(SR,TR2,m+1,t)// 递归地将SR[m+1..t]归并为有序的TR2[m+1..t]

Merge(TR2,TR1,s,m,t)// 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]

}

}

void MergeSort(SqList &L)

{ // 对顺序表L作归并排序。算法10.14

MSort(L.r,L.r,1,L.length)

}

void print(SqList L)

{

int i

for(i=1i<=L.lengthi++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo)

printf("\n")

}

#define N 7

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7}}

SqList l

int i

for(i=0i<Ni++)

l.r[i+1]=d[i]

l.length=N

printf("排序前:\n")

print(l)

MergeSort(l)

printf("排序后:\n")

print(l)

}

/**********************************************/

//起泡排序

#include<string.h>

#include<ctype.h>

#include<malloc.h>// malloc()等

#include<limits.h>// INT_MAX等

#include<stdio.h>// EOF(=^Z或F6),NULL

#include<stdlib.h>// atoi()

#include<io.h>// eof()

#include<math.h>// floor(),ceil(),abs()

#include<process.h>// exit()

#include<iostream.h>// cout,cin

// 函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status

typedef int Boolean

#define N 8

void bubble_sort(int a[],int n)

{ // 将a中整数序列重新排列成自小至大有序的整数序列(起泡排序)

int i,j,t

Status change

for(i=n-1,change=TRUEi>1&&change--i)

{

change=FALSE

for(j=0j<i++j)

if(a[j]>a[j+1])

{

t=a[j]

a[j]=a[j+1]

a[j+1]=t

change=TRUE

}

}

}

void print(int r[],int n)

{

int i

for(i=0i<ni++)

printf("%d ",r[i])

printf("\n")

}

void main()

{

int d[N]={49,38,65,97,76,13,27,49}

printf("排序前:\n")

print(d,N)

bubble_sort(d,N)

printf("排序后:\n")

print(d,N)

}

/****************************************************/

//简单选择排序

#include<stdio.h>

typedef int InfoType// 定义其它数据项的类型

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType// 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key// 关键字项

InfoType otherinfo// 其它数据项，具体类型在主程中定义

}

struct SqList // 顺序表类型

{

RedType r[MAXSIZE+1]// r[0]闲置或用作哨兵单元

int length// 顺序表长度

}

int SelectMinKey(SqList L,int i)

{ // 返回在L.r[i..L.length]中key最小的记录的序号

KeyType min

int j,k

k=i// 设第i个为最小

min=L.r[i].key

for(j=i+1j<=L.lengthj++)

if(L.r[j].key<min) // 找到更小的

{

k=j

min=L.r[j].key

}

return k

}

void SelectSort(SqList &L)

{ // 对顺序表L作简单选择排序。算法10.9

int i,j

RedType t

for(i=1i<L.length++i)

{ // 选择第i小的记录，并交换到位

j=SelectMinKey(L,i)// 在L.r[i..L.length]中选择key最小的记录

if(i!=j)

{ // 与第i个记录交换

t=L.r[i]

L.r[i]=L.r[j]

L.r[j]=t

}

}

}

void print(SqList L)

{

int i

for(i=1i<=L.lengthi++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo)

printf("\n")

}

#define N 8

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}}

SqList l

int i

for(i=0i<Ni++)

l.r[i+1]=d[i]

l.length=N

printf("排序前:\n")

print(l)

SelectSort(l)

printf("排序后:\n")

print(l)

}

/************************************************/

//树形选择排序

#include<string.h>

#include<ctype.h>

#include<malloc.h>// malloc()等

#include<limits.h>// INT_MAX等

#include<stdio.h>// EOF(=^Z或F6),NULL

#include<stdlib.h>// atoi()

#include<io.h>// eof()

#include<math.h>// floor(),ceil(),abs()

#include<process.h>// exit()

#include<iostream.h>// cout,cin

// 函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status// Status是函数的类型,其值是函数结果状态代码，如OK等

typedef int Boolean// Boolean是布尔类型,其值是TRUE或FALSE

typedef int InfoType// 定义其它数据项的类型

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType// 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key// 关键字项

InfoType otherinfo// 其它数据项，具体类型在主程中定义

}

struct SqList // 顺序表类型

{

RedType r[MAXSIZE+1]// r[0]闲置或用作哨兵单元

int length// 顺序表长度

}

void TreeSort(SqList &L)

{ // 树形选择排序

int i,j,j1,k,k1,l,n=L.length

RedType *t

l=(int)ceil(log(n)/log(2))+1// 完全二叉树的层数

k=(int)pow(2,l)-1// l层完全二叉树的结点总数

k1=(int)pow(2,l-1)-1// l-1层完全二叉树的结点总数

t=(RedType*)malloc(k*sizeof(RedType))// 二叉树采用顺序存储结构

for(i=1i<=ni++) // 将L.r赋给叶子结点

t[k1+i-1]=L.r[i]

for(i=k1+ni<ki++) // 给多余的叶子的关键字赋无穷大

t[i].key=INT_MAX

j1=k1

j=k

while(j1)

{ // 给非叶子结点赋值

for(i=j1i<ji+=2)

t[i].key<t[i+1].key?(t[(i+1)/2-1]=t[i]):(t[(i+1)/2-1]=t[i+1])

j=j1

j1=(j1-1)/2

}

for(i=0i<ni++)

{

L.r[i+1]=t[0]// 将当前最小值赋给L.r[i]

j1=0

for(j=1j<lj++) // 沿树根找结点t[0]在叶子中的序号j1

t[2*j1+1].key==t[j1].key?(j1=2*j1+1):(j1=2*j1+2)

t[j1].key=INT_MAX

while(j1)

{

j1=(j1+1)/2-1// 序号为j1的结点的双亲结点序号

t[2*j1+1].key<=t[2*j1+2].key?(t[j1]=t[2*j1+1]):(t[j1]=t[2*j1+2])

}

}

free(t)

}

void print(SqList L)

{

int i

for(i=1i<=L.lengthi++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo)

printf("\n")

}

#define N 8

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}}

SqList l

int i

for(i=0i<Ni++)

l.r[i+1]=d[i]

l.length=N

printf("排序前:\n")

print(l)

TreeSort(l)

printf("排序后:\n")

print(l)

}

/****************************/

//堆排序

#include<stdio.h>

typedef int InfoType// 定义其它数据项的类型

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)<(b))

#define LQ(a,b) ((a)<=(b))

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType// 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key// 关键字项

InfoType otherinfo// 其它数据项，具体类型在主程中定义

}

struct SqList // 顺序表类型

{

RedType r[MAXSIZE+1]// r[0]闲置或用作哨兵单元

int length// 顺序表长度

}

typedef SqList HeapType// 堆采用顺序表存储表示

void HeapAdjust(HeapType &H,int s,int m) // 算法10.10

{ // 已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数

// 调整H.r[s]的关键字,使H.r[s..m]成为一个大顶堆(对其中记录的关键字而言)

RedType rc

int j

rc=H.r[s]

for(j=2*sj<=mj*=2)

{ // 沿key较大的孩子结点向下筛选

if(j<m&&LT(H.r[j].key,H.r[j+1].key))

++j// j为key较大的记录的下标

if(!LT(rc.key,H.r[j].key))

break// rc应插入在位置s上

H.r[s]=H.r[j]

s=j

}

H.r[s]=rc// 插入

}

void HeapSort(HeapType &H)

{ // 对顺序表H进行堆排序。算法10.11

RedType t

int i

for(i=H.length/2i>0--i) // 把H.r[1..H.length]建成大顶堆

HeapAdjust(H,i,H.length)

for(i=H.lengthi>1--i)

{ // 将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换

t=H.r[1]

H.r[1]=H.r[i]

H.r[i]=t

HeapAdjust(H,1,i-1)// 将H.r[1..i-1]重新调整为大顶堆

}

}

void print(HeapType H)

{

int i

for(i=1i<=H.lengthi++)

printf("(%d,%d)",H.r[i].key,H.r[i].otherinfo)

printf("\n")

}

#define N 8

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}}

HeapType h

int i

for(i=0i<Ni++)

h.r[i+1]=d[i]

h.length=N

printf("排序前:\n")

print(h)

HeapSort(h)

printf("排序后:\n")

print(h)

}

（1）“冒泡法” \x0d\x0a\x0d\x0a冒泡法大家都较熟悉。其原理为从腊亏a[0]开始，依次将其和后面的元素比较,若a[0]>a[i]，则交换它们，一直比较到a[n]。同理对a[1],a[2],...a[n-1]处迹卖理，即完成排序。下面列出其代码：\x0d\x0a\x0d\x0avoid bubble(int *a,int n) /*定义两个参数：数组首地址与数组大小*/ \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,temp\x0d\x0a\x0d\x0afor(i=0ia[j]) { \x0d\x0a\x0d\x0atemp=a[i]\x0d\x0a\x0d\x0aa[i]=a[j]\x0d\x0a\x0d\x0aa[j]=temp\x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a冒泡法原理简单，但其缺点是交换次数多，效率低。 \x0d\x0a\x0d\x0a下面介绍一种源自冒泡法但更有效率的方法“选择法”。 \x0d\x0a\x0d\x0a（2）“选择法” \x0d\x0a\x0d\x0a选择法循环过程与冒泡法一致，它还定义了记号k=i,然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.最后看看k=i是否还成立，不成立则交换a[k],a[i],这样就比冒泡法省下许多无用的交换，提高了效率。\x0d\x0a\x0d\x0avoid choise(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,k,temp\x0d\x0a\x0d\x0afor(i=0ia[j]) k=j/*是k总是指向最小元素*/ \x0d\x0a\x0d\x0aif(i!=k) { /*当k!=i是才交换，否则a[i]即为最小*/ \x0d\x0a\x0d\x0atemp=a[i]\x0d\x0a\x0d\x0aa[i]=a[k]\x0d\x0a\x0d\x0aa[k]=temp\x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。 \x0d\x0a\x0d\x0a（3）“快速法” \x0d\x0a\x0d\x0a快速法定义了三个参数，（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j). 它首先选一个数组元素（一般为a[(i+j)/2],即中间元素）作为参照，把比它小的元素放到它的左边，比它大的放在右边。然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。下面分析其代码：\x0d\x0a\x0d\x0avoid quick(int *a,int i,int j) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint m,n,temp\x0d\x0a\x0d\x0aint k\x0d\x0a\x0d\x0am=i\x0d\x0a\x0d\x0an=j\x0d\x0a\x0d\x0ak=a[(i+j)/2]/*选取的参照*/ \x0d\x0a\x0d\x0ado { \x0d\x0a\x0d\x0awhile(a[m]k&&n>i) n--/* 从右到左找比k小的元素*/ \x0d\x0a\x0d\x0aif(mi) quick(a,i,n)\x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a（4）“姿局逗插入法” \x0d\x0a\x0d\x0a插入法是一种比较直观的排序方法。它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。把数组元素插完也就完成了排序。\x0d\x0a\x0d\x0avoid insert(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,temp\x0d\x0a\x0d\x0afor(i=1i=0&&temp=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。下面让我们来分析其代码：\x0d\x0a\x0d\x0avoid shell(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,k,x\x0d\x0a\x0d\x0ak=n/2/*间距值*/ \x0d\x0a\x0d\x0awhile(k>=1) { \x0d\x0a\x0d\x0afor(i=ki=0&&x \x0d\x0a\x0d\x0a/*别偷懒，下面的"..."代表函数体，自己加上去哦！*/ \x0d\x0a\x0d\x0avoid bubble(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid choise(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid quick(int *a,int i,int j) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid insert(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid shell(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a/*为了打印方便，我们写一个print吧。*/[code]\x0d\x0a\x0d\x0avoid print(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i\x0d\x0a\x0d\x0afor(i=0i 回答于 2022-12-14

---