排序算法（C语⾔）
冒泡排序
冒泡排序(Bubble Sort)，原理为从头（⽔底）开始，依次⽐较相邻元素的⼤⼩，若前⼀个元素⽐后⼀个⼤（以升序为例），则交换两个元素，直到把最⼤的元素放到尾部（浮出⽔⾯）；接下来，依次把第⼆⼤，第三⼤…的元素放在尾部，直到整个序列有序。
冒泡排序的优化：检测每⼀次排序是否有元素交换发⽣，若某次排序没有元素交换，证明序列已有序，可退出循环。
#include<stdio.h>
void swap(int* a,int* b);逻辑运算符都有哪些
void maopao(int*arr,int size);
int main()
{
int size;
scanf("%d",&size);
int arr[1000];
for(int i =0; i < size; i++)
scanf("%d",&arr[i]);
maopao(arr, size);
for(int i =0; i < size; i++)
printf("%d ", arr[i]);
}
void maopao(int*arr,int size)
{
int tmp, change =1;
for(int i =0; i < size -1&& change; i++)
阮一峰 java教程{
change =0;
for(int j =0; j < size - i -1; j++)
{
if(arr[j]> arr[j+1])//⽐较相邻的元素，如果第⼀个⽐第⼆个⼤，就交换它们两个
{
swap(&arr[j],&arr[j+1]);
}
}
}
}
void swap(int*a,int*b)
{
int tmp;
tmp =*a;
*a  =*b;
*b  = tmp;
}
2
时间复杂度：O(N)
稳定性：稳定
选择排序
选择排序（Selection Sort），原理为寻最⼤元素（以升序为例），将其放置尾部，再寻第⼆⼤元素，将其置于尾部…直⾄整个序列有序。
#include<stdio.h>
void swap(int*a,int*b);
void xuanze(int*arr,int size);
int main()
{
int size;
scanf("%d",&size);
int arr[1000];
for(int i =0; i < size; i++)
scanf("%d",&arr[i]);
xuanze(arr, size);
for(int i =0; i < size; i++)
printf("%d ", arr[i]);
}
void xuanze(int*arr,int size)
{
int k, tmp;//k为待排序序列中最⼤值元素下标
for(int i =0; i < size -1; i++)
{
k = i;
for(int j = i +1; j < size; j++)
if(arr[j]< arr[k])
k = j;
swap(&arr[i],&arr[k]);
}
}
void swap(int*a,int*b)
{
int tmp;
tmp =*a;
*a  =*b;
*b  = tmp;
}
2冒泡排序代码c语言
时间复杂度：O(N)
稳定性：不稳定
插⼊排序
插⼊排序（Insertion Sort），原理为将⼀个个元素插⼊到有序列的合适位置，使得新的序列依然有序。
{
int  size ;
scanf ("%d", &size );
linux操作系统下载isoint  arr [1000];
vs字符串转数字for (int  i = 0; i < size ; i ++)
scanf ("%d", &arr [i ]);
charu (arr , size );
for (int  i = 0; i < size ; i ++)
printf ("%d ", arr [i ]);
}
void  charu (int  *arr , int  size )
{
int  tmp ;
for  (int  i = 1; i < size ; i ++)//取未排序数列⾸位数
{
if  (arr [i ] < arr [i -1])//若该数⼤于有序数列末位数，则不⽤移动位置，置于尾端即有序
{
tmp = arr [i ];//将该数存在tmp 处
for  (int  j = i - 1; j >= 0 && arr [j ] > tmp ; j --)//将数列由尾端向前扫描，到该数正确位置
{
arr [j +1] = arr [j ];
}
arr [j +1] = tmp ;//插⼊该数
}
}
}
时间复杂度：O(N )
稳定性：稳定
希尔排序
希尔排序(Shell’s Sort)的核⼼是以某个增量h为步长跳跃分组（类似于按该增量报数，报相同数的元素为⼀组）进⾏插⼊排序。由于分组的步长h逐步缩⼩, 所以也叫“缩⼩增量排序”（Diminishing Increment Sort）。
希尔排序的时间复杂度是所取步长序列的函数, 该函数在数学上⽆确定的解, 所以⼀直以来SHELL算法的分析被认为是⼀个复杂的问题。下⾯，给出常见的shell增量。
原始希尔序列：d(max)=N/2, d(i)=d(i+1)/2
Hibbard 增量序列：d(k)=2^k-1
Sedgewick 增量序列：{1, 5, 19, 41, 109…} 猜想：d(i)=9×4- 9x2 +1或d(i)=4-3x2+1
下⾯的代码以原始希尔序列为例
2i i i i
{
int  size ;
scanf ("%d", &size );
int  arr [1000];
for (int  i = 0; i < size ; i ++)
scanf ("%d", &arr [i ]);
xier (arr , size );
for (int  i = 0; i < size ; i ++)
printf ("%d ", arr [i ]);
}
void  xier (int  *arr , int  size )
{
int  tmp , j , d ;
for  (d = size / 2; d > 0; d /= 2)//确定增量⼤⼩
{
for  (int  i = d ; i < size ; i ++)//对每个⼦数列进⾏插⼊排序
{
tmp = arr [i ];
for  (j = i - d ; j >= 0 && tmp < arr [j ]; j -= d )
{
arr [j + d ] = arr [j ];
}
arr [j + d ] = tmp ;
}
}
}时间复杂度：
原始希尔序列 T =O(n )
Hibbard 增量序列 T =O(n )
Sedgewick 增量序列 T =O(n )
稳定性：不稳定
快速排序
快速排序（Quick Sort）是对冒泡排序的⼀种改进。其原理为通过⼀趟排序将要排序的数据分割成独⽴的两部分，其中⼀部分的所有元素都⽐另外⼀部分都要⼩，然后再按此⽅法对这两部分数据分别进⾏快速排序，直⾄整个序列有序。
worse 2worse 3/2worse 4/3
void kuaisu(int*arr,int left,int right);
int main()
{
int size;
scanf("%d",&size);
int arr[1000];
for(int i =0; i < size; i++)
scanf("%d",&arr[i]);
kuaisu(arr,0, size-1);
for(int i =0; i < size; i++)
printf("%d ", arr[i]);
}
void kuaisu(int arr[],int left,int right)
自增自减运算符详解举例{
if(left >= right)
{
return;
}
int i = left;
int j = right;
int centre = arr[left];
while(i < j)
{
while(i < j && centre <= arr[j])//从右向左依次搜索，⼀个⽐中⼼数⼩的
{
j--;
}
arr[i]= arr[j];//把这个数放在左端
while(i < j && arr[i]<= centre)//从左向右依次搜索，⼀个⽐中⼼数⼤的
{
i++;
}
arr[j]= arr[i];//把这个数放在右端
}
arr[i]= centre;//更新中⼼数位置
kuaisu(arr, left, i -1);
kuaisu(arr, i +1, right);
}
时间复杂度：O(Nlog N)
2
稳定性：不稳定
计数排序
计数排序（Counting Sort）是⼀种不基于⽐较的排序算法。其原理为对于序列中每⼀个元素，统计⽐它⼩（或⼤）的元素个数，以到该元素的正确位置。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。