c语言排序算法代码（C语言实现七种排序算法的演示代码是什么）

本文目录

• C语言实现七种排序算法的演示代码是什么
• c语言排序和查找
• 数据结构C语言——实现各种排序算法
• 求C语言排序算法代码，要求排序完以后能够返回原来数值所在的位置不能返回位置的排序代码就不要复制了
• C语言中选择排序法和冒泡排序法代码
• C语言，5个数按从大到小排序，冒泡法

C语言实现七种排序算法的演示代码是什么

（1）“冒泡法”
冒泡法大家都较熟悉。其原理为从a开始，依次将其和后面的元素比较,若a》a[i]，则交换它们，一直比较到a[n]。同理对a,a,...a[n-1]处理，即完成排序。下面列出其代码：
void
bubble(int
*a,int
n)
/*定义两个参数：数组首地址与数组大小*/
{
int
i,j,temp;
for(i=0;i《n-1;i++)
for(j=i+1;j《n;j++)
/*注意循环的上下限*/
if(a[i]》a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
冒泡法原理简单，但其缺点是交换次数多，效率低。
下面介绍一种源自冒泡法但更有效率的方法“选择法”。
（2）“选择法”
选择法循环过程与冒泡法一致，它还定义了记号k=i,然后依次把a[k]同后面元素比较，若a[k]》a[j],则使k=j.最后看看k=i是否还成立，不成立则交换a[k],a[i],这样就比冒泡法省下许多无用的交换，提高了效率。
void
choise(int
*a,int
n)
{
int
i,j,k,temp;
for(i=0;i《n-1;i++)
{
k=i;
/*给记号赋值*/
for(j=i+1;j《n;j++)
if(a[k]》a[j])
k=j;
/*是k总是指向最小元素*/
if(i!=k)
{
/*当k!=i是才交换，否则a[i]即为最小*/
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
}
选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。
（3）“快速法”
快速法定义了三个参数，（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j).
它首先选一个数组元素（一般为a[(i+j)/2],即中间元素）作为参照，把比它小的元素放到它的左边，比它大的放在右边。然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。下面分析其代码：
void
quick(int
*a,int
i,int
j)
{
int
m,n,temp;
int
k;
m=i;
n=j;
k=a[(i+j)/2];
/*选取的参照*/
do
{
while(a[m]《k&&m《j)
m++;
/*
从左到右找比k大的元素*/
while(a[n]》k&&n》i)
n--;
/*
从右到左找比k小的元素*/
if(m《=n)
{
/*若找到且满足条件，则交换*/
temp=a[m];
a[m]=a[n];
a[n]=temp;
m++;
n--;
}
}while(m《=n);
if(m《j)
quick(a,m,j);
/*运用递归*/
if(n》i)
quick(a,i,n);
}
（4）“插入法”
插入法是一种比较直观的排序方法。它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。把数组元素插完也就完成了排序。
void
insert(int
*a,int
n)
{
int
i,j,temp;
for(i=1;i《n;i++)
{
temp=a[i];
/*temp为要插入的元素*/
j=i-1;
while(j》=0&&temp《a[j])
{
/*从a[i-1]开始找比a[i]小的数，同时把数组元素向后移*/
a[j+1]=a[j];
j--;
}
a[j+1]=temp;
/*插入*/
}
}
（5）“shell法”
shell法是一个叫
shell
的美国人与1969年发明的。它首先把相距k(k》=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。下面让我们来分析其代码：
void
shell(int
*a,int
n)
{
int
i,j,k,x;
k=n/2;
/*间距值*/
while(k》=1)
{
for(i=k;i《n;i++)
{
x=a[i];
j=i-k;
while(j》=0&&x《a[j])
{
a[j+k]=a[j];
j-=k;
}
a[j+k]=x;
}
k/=2;
/*缩小间距值*/
}
}
上面我们已经对几种排序法作了介绍，现在让我们写个主函数检验一下。
#include《stdio.h》
/*别偷懒，下面的“...“代表函数体，自己加上去哦！*/
void
bubble(int
*a,int
n)
{
...
}
void
choise(int
*a,int
n)
{
...
}
void
quick(int
*a,int
i,int
j)
{
...
}
void
insert(int
*a,int
n)
{
...
}
void
shell(int
*a,int
n)
{
...
}
/*为了打印方便，我们写一个print吧。*/[code]
void
print(int
*a,int
n)
{
int
i;
for(i=0;i《n;i++)
printf(“%5d“,a[i]);
printf(“\n“);
}
main()
{
/*为了公平，我们给每个函数定义一个相同数组*/
int
a1={13,0,5,8,1,7,21,50,9,2};
int
a2={13,0,5,8,1,7,21,50,9,2};
int
a3={13,0,5,8,1,7,21,50,9,2};
int
a4={13,0,5,8,1,7,21,50,9,2};
int
a5={13,0,5,8,1,7,21,50,9,2};
printf(“the
original
list:“);
print(a1,10);
printf(“according
to
bubble:“);
bubble(a1,10);
print(a1,10);
printf(“according
to
choise:“);
choise(a2,10);
print(a2,10);
printf(“according
to
quick:“);
quick(a3,0,9);
print(a3,10);
printf(“according
to
insert:“);
insert(a4,10);
print(a4,10);
printf(“according
to
shell:“);
shell(a5,10);
print(a5,10);
}

c语言排序和查找

1）利用readData()函数从data1.txt中读入不同规模的数据存入数组，
编写基于数组的顺序查找算法，测试数据量为1万、5万、10万、20万、
30万、40万和50万时的数据查询时间。
算法代码如下：

1 int seqsearch(int a,int n,int key)
2 {
3 int k=n-1;
4 while(k》=0&&a[k]!=key)
5 k--;
6 return (k);
7 }

2）利用readData()函数从data2.txt中读入不同规模的有序数据存入数组，
编写基于数组的二分查找算法，测试数据量为1万、5万、10万、20万、30万、
40万和50万时的数据查询时间。
算法代码如下：

1 int binSearch(int a,int n,int key)
2 {
3 int low=0;
4 int high=n-1;
5 int mid;
6 while(low《=high)
7 {
8 mid=(low+high)/2;
9 if(a[mid]==key) return mid;
10 if(a[mid]》key)
11 high=mid-1;
12 else
13 low=mid+1;
14 }
15 return -1;
16 }

3）请设计冒泡排序算法函数void bubbleSort(int a,int n)，对a..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
算法代码如下：


1 void bubbleSort(int a,int n)
2 {
3 int i=1,j,flag=1;
4 while(i《=n-1&&flag)
5 {
6 flag=0;
7 for(j=1;j《=n-1-i;j++)
8 if(a[j+1]《a[j])
9 {
10 a=a[j];
11 a[j]=a[j+1];
12 a[j+1]=a;
13 flag=1;
14 }
15 i++;
16 }
17 }


数据结构C语言——实现各种排序算法

刚做完的
#include 《iostream》
using namespace std;

void BiInsertsort(int r, int n) //插入排序（折半）
{
for(int i=2;i《=n;i++)
{
if (r[i]《r[i-1])
{
r = r[i]; //设置哨兵
int low=1,high=i-1; //折半查找
while (low《=high)
{
int mid=(low+high)/2;
if (r《r[mid]) high=mid-1;
else low = mid+1;
}
int j;
for (j=i-1;j》high;j--) r[j+1] = r[j]; //后移
r[j+1] = r;
}
}
for(int k=1;k《=n;k++) cout《《r[k]《《“ “;
cout《《“\n“;
}

void ShellSort ( int r, int n) //希尔排序
{
for(int d=n/2;d》=1;d=d/2) //以d为增量进行直接插入排序
{
for (int i=d+1;i《=n;i++)
{
r = r[i]; //暂存被插入记录
int j;
for( j=i-d; j》0 && r《r[j]; j=j-d) r[j+d] = r[j]; //记录后移d个位置
r[j+d] = r;

}
}
for(int i=1;i《=n;i++) cout《《r[i]《《“ “;
cout《《“\n“;
}

void BubbleSort(int r, int n) //起泡排序
{
int temp,exchange,bound;
exchange=n; //第一趟起泡排序的范围是r到r[n-1]
while (exchange) //仅当上一趟排序有记录交换才进行本趟排序
{
bound=exchange;
exchange=0;
for (int j=1; j《bound; j++) //一趟起泡排序
if (r[j]》r[j+1])
{
temp=r[j];
r[j]=r[j+1];
r[j+1]=temp;
exchange=j; //记录每一次发生记录交换的位置
}
}
for(int i=1;i《=n;i++) cout《《r[i]《《“ “;
cout《《“\n“;
}

int Partition(int r, int first, int end) //快速排序一次划分
{
int i=first; //初始化
int j=end;
r=r[first];
while (i《j)
{
while (i《j && r《= r[j]) j--; //右侧扫描
r[i]=r[j];
while (i《j && r[i]《= r) i++; //左侧扫描
r[j]=r[i];
}
r[i]=r;
return i; //i为轴值记录的最终位置
}
void QuickSort(int r, int first, int end) //快速排序
{
if (first《end)
{ //递归结束
int pivot=Partition(r, first, end); //一次划分
QuickSort(r, first, pivot-1);//递归地对左侧子序列进行快速排序
QuickSort(r, pivot+1, end); //递归地对右侧子序列进行快速排序
}
}

void SelectSort(int r[ ], int n) //简单选择排序
{
int i,j,index,temp;
for (i=1; i《n; i++) //对n个记录进行n-1趟简单选择排序
{
index=i;
for (j=i+1; j《=n; j++) //在无序区中选取最小记录
if (r[j]《r[index]) index=j;
if (index!=i)
{
temp=r[i];
r[i]=r[index];
r[index]=temp;
}
}
for(i=1;i《=n;i++) cout《《r[i]《《“ “;
cout《《“\n“;
}

void main()
{
const int numv=12;
int a[numv]={{0,6,13,19,23,37,39,41,45,48,58,86},{0,86,58,48,45,41,39,37,23,19,13,6},{0,23,13,48,86,19,6,41,58,37,45,39}};
int z1[numv],z2[numv];
int m,n;
cout《《“请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]“ 《《endl;
cin》》m;
while(m》0&&m《4)
{
cout《《“请选择排序算法：⑴直接插入排序 ⑵希尔排序 ⑶冒泡排序 ⑷快速排序 \n ⑸简单选择排序“《《endl;
cin》》n;
switch(n)
{
case 1:
cout 《《 “直接插入排序前：“ 《《 “\n“;
for(int j=1;j《numv;j++) cout《《a[m-1][j]《《“ “;
cout 《《 “\n直接插入排序结果为：“ 《《 “\n“;
BiInsertsort(a[m-1],numv-1);
break;
case 2:
cout 《《 “\n希尔排序前：“ 《《 “\n“;
for(int j=1;j《numv;j++) cout《《a[m-1][j]《《“ “;
cout 《《 “\n希尔排序结果为：“ 《《 “\n“;
ShellSort(a[m-1], numv-1);
break;
case 3:
cout 《《 “\n冒泡排序前：“ 《《 “\n“;
for(int k=1;k《numv;k++) cout《《a[m-1][k]《《“ “;
cout 《《 “\n冒泡排序结果为：“ 《《 “\n“;
BubbleSort(a[m-1], numv-1);
break;
case 4:
cout 《《 “\n快速排序前：“ 《《 “\n“;
for(int j=1;j《numv;j++) cout《《a[m-1][j]《《“ “;
cout 《《 “\n快速排序结果为：“ 《《 “\n“;
QuickSort(a[m-1],0,numv-1);
for(int i=1;i《numv;i++)
cout《《a[m-1][i]《《“ “;
cout《《“\n“;
break;
case 5:
cout 《《 “\n简单选择排序前：“ 《《 “\n“;
for(int j=1;j《numv;j++) cout《《a[m-1][j]《《“ “;
cout 《《 “\n简单选择排序结果为：“ 《《 “\n“;
SelectSort(a[m-1],numv-1);
break;

default:
cout《《“输入错误！“《《endl;
}
m=0;
cout《《“请选择测试数据类型：⑴正序 ⑵逆序 ⑶随机 [ 若跳出,请按⑷ ]“ 《《endl;
cin》》m;
}
if(m==4) cout《《“(*^__^*) 再见！“《《endl;
else cout《《“输入错误！“《《endl;
}

求C语言排序算法代码，要求排序完以后能够返回原来数值所在的位置不能返回位置的排序代码就不要复制了

#include《stdio.h》

int main()

{int n,i,j,t,a,b,c;

 printf(“请输入有几个数：“);

 scanf(“%d“,&n);

 printf(“请输入%d个数：\n“,n);

 for(i=0;i《n;i++)

 {

scanf(“%d“,&a[i]);

b[i]=a[i];

c[i]=i+1;

 }

 for(i=0;i《n-1;i++)

for(j=0;j《n-1-i;j++)

if(b[j]》b[j+1])

{ t=b[j];b[j]=b[j+1];b[j+1]=t;

 t=c[j];c[j]=c[j+1];c[j+1]=t;}

printf(“\n排序以后的B数组：\n“);

for(i=0;i《n;i++)

printf(“%d “,b[i]);

printf(“\n排序以后的B数组：\n“);

for(i=0;i《n;i++)

printf(“%d “,c[i]);

printf(“\n“);

return 0;

}

C语言中选择排序法和冒泡排序法代码

选择排序：

void select_sort(int a,int n)        //传入数组的要排序的元素个数

{int i,j,min,t;

for(i=0;i《n-1;i++)

{  min=i;      //min:当前最小值下标

for(j=i+1;j《n;j++)        //扫描余下的部分

if(a[min]》a[j])        //若有其它元素更小，就记录其下标

min=j;

if(min!=i)        //保若最小值不在排序区首位，就换到首位

{t=a[min]; a[min]=a[i]; a[i]=t;}

}

}

冒泡排序：

void bubble_sort(int a, int n)        //传入数组的要排序的元素个数

{ int i, j, t;

for (j=0; j《n-1; j++)        //n个元素比较n-1轮

for (i= 0; i《n-1-j;i++)   //比较相信的两个数

if(a[i]》a[i+1])          //若大小顺序不符，就交换

{t=a[i];  a[i]=a[i+1]; a[i+1]=t;

}

C语言，5个数按从大到小排序，冒泡法

#include《stdio.h》

#define N 5

void main()

{   int a[N],i,j,t;

printf(“请输入5位学生的成绩\n“);

for(i=0;i《N;i++)

scanf(“%d“,&a[i]);

for(i=0;i《N-1;i++)

{for(j=0;j《N-1-i;j++)

if(a[j+1]《=a[j]){

t=a[j];a[j]=a[j+1];a[j+1]=t;

}

}

printf(“成绩由高到低的排序为：\n“);   

for(i=0;i《N;i++)

printf(“%d “,a[i]);

}

算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

以上内容参考：百度百科-冒泡排序