C语言实现选择排序、冒泡排序和快速排序的代码示例

选择和冒泡

#include<stdio.h> 
  
 void maopao(int a[],int len){ 
   int i,j,temp; 
   for(i = 0;i < len - 1 ; i ++){//从第一个到倒数第二个 
     for (j = 0 ; j < len - 1 - i ; j ++)//排在后的是已经排序的 
     { 
       if (a[j] > a[j + 1])//大的数换到后面去 
       { 
         temp = a[j]; 
         a[j] = a[j + 1]; 
         a [j + 1] = temp; 
       } 
     } 
   } 
 } 
  
 void xuanze(int a[],int len){ 
   int i , j , t , temp; 
   for (i = 0 ; i < len - 1 ;i ++) 
   { 
     t = i; 
     for (j = i + 1 ; j < len ; j ++)//前面的实排好的 
     { 
       if (a[t] > a[j]) 
       { 
         t = j;//记下该趟最小数的序号 
       } 
     } 
     if (t != i)//如果序号不变就什么也不做 
     { 
       temp = a[t];//否则元素交换 
       a[t] = a[i]; 
       a[i] = temp; 
     } 
   } 
 } 
  
 void main(){ 
   int i; 
   int a[] = {5,4,6,7,2,5,4,6,8,9,1,2}; 
   //maopao(a, 12); 
   xuanze(a, 12); 
   for (i = 0 ; i < 12 ; i ++) 
   { 
     printf("%d ",a[i]); 
   } 
 } 

 
 
快速排序与冒泡、选择的比较：

#include <stdio.h> 
#include <time.h> 
#include <windows.h> 
 
//快速排序，参数是数组，最低索引，最高索引(从0开始) 
void qSort(int a[], int low, int high){ 
  int temp; 
  int mid = low;//定义一个中索引，用于记录一次排序后确定位置的一个元素索引 
  int right = high;//记录最右元素索引 
   
  //默认中值是左值，现在要把凡是比中值大的元素放到中值左边 
  while(right > mid){//因此从右开始向中值遍历，到达中值时遍历结束 
    if (a[right] < a[mid])//如果右值比中值还小，说明他不该在右边，要把它放到左边 
    { 
      temp = a[mid];//所以先把中值的地盘腾出来 
      a[mid] = a[right];//把比中值小的那个数放在那儿 
      //中值没地方放，必须右移移位，但是直接右移会覆盖原来他右边的那个值 
      a[right] = a[++mid];//不过right索引的空间已经腾出来了，就把中值原来右边的值放到right 
      a[mid] = temp;//然后就可以把mid右移一位 
    } 
    else{ 
      right--;//否则的话说明right已然大于等于mid，不用移动，继续判断right左边那个数 
    } 
  }//这样right与mid重合之时，退出循环，此时mid的位置已经确定了就是排完序后他的位置 
   //因为他左边的都比他小，右边的都比他大 
  if (mid - low > 1)//如果low到mid之间还有两个或以上元素，还要对他们排序 
  { 
    qSort(a, low, mid - 1); 
  } 
 
  if (high - mid > 1)//右边那半也是一样 
  { 
    qSort(a, mid + 1, high); 
  } 
} 
 
void sSort(int a[], int len){//选择排序，参数是数组名和元素个数 
  int i, j, m, temp; 
  for (i = 0; i < len - 1; i++)//从开始到倒数第二个元素 
  { 
    m = i;//先记录最左边的元素索引，假设他为最小 
    for (j = i + 1; j < len; j++)//从左往右遍历一直到最后 
    { 
      if (a[j] < a[m])//如果发现更小的元素 
      { 
        m = j;//记下这个元素的索引 
      } 
    } 
    if (m != i)//如果最小的元素不是开始那个，就需要把最小的换到最左边 
    { 
      temp = a[i]; 
      a[i] = a[m]; 
      a[m] = temp; 
    } 
  } 
} 
 
void mSort(int a[], int len){//冒泡法排序，参数是数组名，元素个数 
  int i, j, temp; 
  for (i = 0; i < len - 1; i ++)//从开始到倒数第二个元素 
  { 
    for (j = 0; j < len - 1 - i; j++)//从头遍历到已序队列往前第二个 
    { 
      if (a[j] > a[j + 1])//如果元素比他的后一个大，则交换 
      { 
        temp = a[j]; 
        a[j] = a[j + 1]; 
        a[j + 1] = temp; 
      } 
    }//一次遍历后最大元素放到最后面 
  } 
} 
 
int checkSorted(int a[], int len){//检查数组排序是否已经正确 
  int i; 
  for (i = 0; i < len - 1; i++) 
  { 
    if (a[i] > a[i + 1])//如果一个元素比他的下一个还要大，说明发生错误 
    { 
      return 0; 
    } 
  } 
  return 1; 
} 
 
void main(){ 
  int i, j; 
  int a[99999]; 
 
  clock_t begin, end; 
  double cost; 
   
  for (j = 0; j < 6; j++)//做6次测试 
  { 
    srand((int)time(0));//用时间做种，是每次数字都不同 
    for (i = 0; i < 99999; i++) 
    { 
      a[i] = rand();//产生随机数放入数组 
    } 
     
    begin = clock(); 
     
    //qSort(a, 0, 99998);//1秒左右 
    //sSort(a, 99999);//20秒左右 
    mSort(a, 99999);//40秒左右 
     
    end = clock(); 
     
    for (i = 0; i < 12; i++)//输出前面的几个排好序的元素 
    { 
      printf("%d ", a[i]); 
    } 
 
    cost = (double)(end - begin) / CLOCKS_PER_SEC;//计算排序时间 
    printf("...\t排序用时 %lf 秒 ", cost);//输出排序所用时间 
 
    if (checkSorted(a, 99999))//检查排序是否正确 
    { 
      printf("正确!\n"); 
    }else{ 
      printf("有错!\n"); 
    } 
    Sleep(1200);//暂停一下，使每次时间种子不同 
  } 
} 

1. 快速排序的结果：
 99999个随机数一般不超过0.05秒，很快
2.选择法排序结果：

 99999个随机数一般不超过0.05秒，很快
2.选择法排序结果：

一般在20多秒；
3.冒泡法，一般情况下交换的次数会很多，结果：

排序时间一般在50秒左右，最慢。
 
在C++中，还可以定义函数模板
因为快速排序通常很快，所以用它来对不同的数据类型排序

#include <iostream.h> 
 
template<class T> void qSort(T a[], int low, int high){//在C++中，可以定义函数模板 
  T temp; 
  int mid = low; 
  int right = high; 
 
  while (right > mid) 
  { 
    if (a[right] < a[mid]) 
    { 
      temp = a[mid]; 
      a[mid] = a[right]; 
      a[right] = a[++mid]; 
      a[mid] = temp; 
    }else{ 
      right--; 
    } 
  } 
  if (mid - low > 1) 
  { 
    qSort(a, low, mid - 1); 
  } 
  if (high - mid > 1) 
  { 
    qSort(a, mid + 1, high); 
  } 
} 
 
void main(){ 
  int a[10] = {1, 9, 6, 3, 5, 7, 1};//有了一个函数模板，可以对整型排序 
  qSort(a, 0, 9); 
  for (int i = 0; i < 10; i++) 
  { 
    cout<<a[i]<<" "; 
  } 
  cout<<endl; 
 
  float b[10] = {2.0f, 1.2f, 5.5f, 6.63f, 9.11f, 1.32f, 3.44f, 5.0f, 5.22f, 0.02f}; 
  qSort(b, 0, 9);//对浮点数排序 
  for (i = 0; i < 10; i++) 
  { 
    cout<<b[i]<<" "; 
  } 
  cout<<endl; 
 
  char c[10] = {'d','e','f','n','j','c','e','b','f','a'};//对字符数组排序 
  qSort(c, 0, 9); 
  for (i = 0; i < 10; i++) 
  { 
    cout<<c[i]<<" "; 
  } 
  cout<<endl; 
}//凡是可以用‘<'来比较大小的类型都可以排序了 

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：notice#nhooo.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。