排序算法学习笔记-C语言版本

//冒泡排序

//简介：冒泡排序将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为ki的气泡。

//根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R；凡扫描到违反本原则的轻气泡，就使其向上"漂浮"。

//如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

#include<stdio.h>
#define n 10
int main()
{
              int i, j,temp;
              int array[10] = { 1, 2, 0, 5, 9,3, 4, 6, 7, 8 };
              for (i = 0; i < n- 1;i++)        //控制总的循环数
              for (j = 0; j < n- 1 - i;j++)   //每次外围走完一次即代表已有i个数完成排序如此则不在访问
              {
                            if (array[j+1] <array[j])
                            {
                                          temp =array[j];
                                          array[j]= array[j+1];
                                          array[j+1]= temp;                                 
                            }
              }
              for (i = 0; i < 10; i++)
              {
                            printf("%3d",array[i]);
              }
              return 0;
}

 

//直接选择排序

//简介：直接选择排序的过程是：首先在所有记录中选出序码最小的记录，把它与第1个记录交换，

//然后在其余的记录内选出排序码最小的记录，与第2个记录交换......依次类推，直到所有记录排完为止。

#include<stdio.h>
#define n 10
int main()
{
              int i, j, k,temp;
              int a[n] = { 9, 5, 1, 6, 2, 3, 8,4, 7, 0 };
              for (i = 0; i < n - 1; i++)
              {
                            k = i;
                            for (j = i + 1; j< n; j++)
                            {
                                          if(a[k]>a[j])
                                                        k= j;
                            }
                            if (k != i)
                            {
                                          temp =a[i];
                                          a[i] =a[k];
                                          a[k] =temp;
                            }
              }
              for (i = 0; i <= 9; i++)
              {
                            printf("%3d",a[i]);
              }
              return 0;
}

 

//直接插入排序

//简介接插入排序的过程为：在插入第i个记录时，R1,R2,..Ri-1已经排好序，

//将第i个记录的排序码Ki依次和R1,R2,..,Ri-1的排序码逐个进行比较，找到适当的位置。

//使用直接插入排序，对于具有n个记录的文件，要进行n-1趟排序。

#include<stdio.h>
#define N 10
int main()
{
              int i,j ,temp,a[N] = { 0, 5, 9, 3,2, 7, 6, 4, 1, 8 };
              for (int i = 1; i<N; i++)//循环从第2个元素开始
              {
                            if (a[i-1]>a[i])
                            {
                                          temp =a[i];
                                          for (j= i - 1; j >= 0 && a[j]>temp; j--)
                                          {//下方争论皆因未加大括号引起误解，故增加以避免误导
                                                        a[j+ 1] = a[j];
                                          }
                                          a[j +1] = temp;//此处就是a[j+1]=temp;
                            }
              }
              for (i= 0; i < 10; i++)
              {
                            printf("%3d",a[i]);
              }
              return 0;
}

//快速排序

//简介：快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：

//通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，

//然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

#include<stdio.h>
void sort(int a[],int left, int right)
{
              int i, j, t, temp;
              if (left > right)
                            return ;
 
              temp = a[left];
              i = left;
              j = right;
              if (i!= j)
              {
                            while (a[j] >temp && j > i)
                                          j--;
                            while (a[i] <temp && i < j)
                                          i++;
                            if (i < j)
                            {
                                          t =a[j];
                                          a[j] =a[i];
                                          a[i] =t;
                            }
                            a[left] = a[i];
                            a[i] = temp;
                            sort(a, left, i -1);
                            sort(a, i + 1,right);
              }
}
int main()
{
              int i;
              int a[5] = {5,9,7,6,8};
              sort(a,0,4);
              for (i = 0; i < 5; i++)
              {
                            printf("%3d",a[i]);
              }
              return 0;
}

//并归排序：

//简介：归并排序是建立在归并操作上的一种有效的排序算法,

//该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

//将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

//若将两个有序表合并成一个有序表，称为二路归并。

#include<stdio.h>
void mergesort(intarray[], int temparray[], int start_index, int end_index)
{
              int middle=(start_index+end_index)/2;
              int i = start_index, j = middle, k= start_index;
              if (start_index < end_index)
              {
                            mergesort(array,temparray,start_index,middle);
                            mergesort(array,temparray,middle+1,end_index);
                            while (i != middle&& j != end_index)
                            {
                                          if(array[i] < array[j])
                                                        temparray[k++]= array[i++];
                                          else
                                                        temparray[k++]= array[j++];
                            }
                            while (i != middle)
                            {
                                          temparray[k++]= array[i++];
                            }
                            while (j !=end_index)
                            {
                                          temparray[k++]= array[j++];
                            }
                            for (i =start_index; i < end_index; i++)
                            {
                                          array[i]= temparray[i];
                            }
              }
}
int main()
{
              int a[8] = { 50, 10, 20, 30, 70,40, 80, 60 };
              int i, b[8];
              mergesort(a, b, 0, 7);
              for (i = 0; i<8; i++)
              printf("%d ", a[i]);
              printf("\n");
              return 0;
}

//基数排序

//简介：基数排序（radix sort）属于“分配式排序”（distribution sort），

//又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，

//将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，

//其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，

//基数排序法的效率高于其它的稳定性排序法。

#include<stdio.h>
#include<math.h>
//找到数组中的最大值
int getmax(int *a,int n)
{
              int max = a[0];
              for (int i = 1; i < n; i++)
              {
                            if (a[i]>max)
                                          max =a[i];
              }
              return max;
}
//找到最大值的位数
int getlooptime(intmax)
{
              int count = 1;
              while (max / 10 != 0)
              {
                            max = max / 10;
                            count++;
              }
              return count;
}
 
//基数排序2
void sort2(int *a,int n,int times)
{
              int b[10][10] = {};//建立桶 大小根据实际进行调整
              //求桶的index的除数
              //如798个位桶index=(798/1)%10=8
              //十位桶index=(798/10)%10=9
              //百位桶index=(798/100)%10=7
              //tempNum为上式中的1、10、100
              int tempnum = pow((float)10,times-1);
              int i, j;
              // 将元素放入桶中
              for (int i = 0; i < n;i++)
              {
                            int row_index = (*(a+ i) / tempnum)%10;
                            for (j = 0; j <10; j++)
                            {
                                          if(b[row_index][j] == NULL)
                                          {
                                                        b[row_index][j]= *(a + i);
                                                        break;
                                          }
                            }
              }
              // 将元素倒回数组
              int k = 0;
              for (i = 0; i < 10;i++)
              for (j = 0; j < 10; j++)
              {
                            if (b[i][j] != NULL)
                            {
                                          *(a +k) = b[i][j];
                                          b[i][j]= NULL;
                                          k++;
                            }
              }
 
}
//基数排序1
void sort(int *a,int n)
{
              int max, sorttimes;
              max = getmax(a, n);
              sorttimes = getlooptime(max);
              printf("%d %d\n", max,sorttimes);
              for (int i = 1; i <= sorttimes;i++)
              {
                            sort2(a, n, i);
              }
}
int main()
{
              int a[6] = { 5, 10, 123, 21, 11,1234 };
              int n = sizeof(a) / sizeof(int);//找到长度
              sort(a,6);
              for (int i = 0; i < 6; i++)
              {
                            printf("%d",a[i]);
              }
              return 0;
}