排序算法学习笔记-C语言版本
//冒泡排序
//简介：冒泡排序将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为ki的气泡。
//根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R；凡扫描到违反本原则的轻气泡，就使其向上"漂浮"。
//如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
#include
#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]
//直接选择排序
//简介：直接选择排序的过程是：首先在所有记录中选出序码最小的记录，把它与第1个记录交换，
//然后在其余的记录内选出排序码最小的记录，与第2个记录交换......依次类推，直到所有记录排完为止。
#include
#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
#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; ia[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
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] //并归排序：
//简介：归并排序是建立在归并操作上的一种有效的排序算法,
//该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
//将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
//若将两个有序表合并成一个有序表，称为二路归并。
#include
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
#include
//找到数组中的最大值
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;
}