排序 - C++ - 冒泡排序 , 插入排序，快速排序，选择排序，
支付宝捐赠
- 常见的稳定排序算法有：
冒泡排序（Bubble Sort） — O(n²)
插入排序（Insertion Sort）— O(n²)
桶排序（Bucket Sort）— O(n); 需要 O(k) 额外空间
计数排序 (Counting Sort) — O(n+k); 需要 O(n+k) 额外空间
合并排序（Merge Sort）— O(nlogn); 需要 O(n) 额外空间
二叉排序树排序 （Binary tree sort） — O(n log n) 期望时间; O(n²)最坏时间; 需要 O(n) 额外空间
基数排序（Radix sort）— O(n·k); 需要 O(n) 额外空间
- 常见的不稳定排序算法有：
选择排序（Selection Sort）— O(n²)
希尔排序（Shell Sort）— O(nlogn)
堆排序（Heapsort）— O(nlogn)
快速排序（Quicksort）— O(nlogn) 期望时间, O(n²) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序
void Swap(int* array,int i ,int j)
{
int temp;
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
- 冒泡排序
void BubbleSort(int* array,int length)
{
for(int i = 0; i < length - 1 ; i++ ) // 若最小元素在序列末尾，需要 n-1 次交换，才能交换到序列开头
{
for(int j = 0; j < length - 1; j++ )
{
if(array[j] > array[j+1]) // 若这里的条件是 >=，则变成不稳定排序
{
Swap(array,j,j+1);
}
}
}
}
//在非最坏的情况下，冒泡排序过程中，可以检测到整个序列是否已经排序完成，进而可以避免掉后续的循环
void BubbleSort2(int* array , int length)
{
for(int i = 0; i < length - 1 ; i++ )
{
bool swapped = false;
for(int j = 0; j < length - 1; j++ )
{
if(array[j] > array[j+1])
{
Swap(array,j,j+1);
swapped = true;
}
}
if(!swapped) // 没有发生交互，证明排序已经完成
{
break;
}
}
}
//进一步地，在每轮循环之后，可以确认，最后一次发生交换的位置之后的元素，都是已经排好序的，因此可以不再比较那个位置之后的元素，大幅度减少了比较的次数
void BubbleSort3(int* array,int length)
{
int n = length;
for(int i = 0; i < length - 1 ; i++ )
{
int newn = 0;
for(int j = 0 ; j < n - 1 ; j++ )
{
if(array[j] > array[j+1])
{
Swap(array,j,j+1);
newn = j + 1; // newn 以及之后的元素，都是排好序的
}
}
n = newn;
if(n == 0)
{
break;
}
}
}
//可以进行双向的循环，正向循环把最大元素移动到末尾，逆向循环把最小元素移动到最前，这种优化过的冒泡排序，被称为鸡尾酒排序
void CocktailSort(int* array,int length)
{
int begin = 0;
int end = length - 1;
while(begin < end){
int newBegin = begin;
int newEnd = end;
for(int j = begin; j < end ; j++ )
{
if(array[j] > array[j+1])
{
Swap(array,j,j+1);
newEnd = j + 1;
}
}
end = newEnd - 1;
for(int j = end ; j > begin - 1; j--)
{
if(array[j] > array[j+1])
{
Swap(array,j,j+1);
newBegin = j;
}
}
begin = newBegin + 1;
}
}
- 插入排序
/*
*
* 插入排序
*
* 参数说明：
* array -- 待排序的数组
* length -- 数组的长度
*
* 插入排序也是一个简单的排序算法，它的思想是，每次只处理一个元素，从后往前查找，找到该元素合适的
* 插入位置，最好的情况下，即正序有序(从小到大)，这样只需要比较n次，不需要移动。因此时间复杂度为O(n)
* 最坏的情况下，即逆序有序，这样每一个元素就需要比较n次，共有n个元素，因此实际复杂度为O(n²)
*/
void InsertionSort(int* array,int length)
{
int i = 1;
while(i < length)
{
int j = i;
while(j > 0 && array[j-1] > array[j])
{
Swap(array,j,j-1);
j--;
}
i++;
}
}
- 快速排序
/*
* 快速排序
*
* 参数说明：
* array -- 待排序的数组
* left -- 数组的左边界(例如，从起始位置开始排序，则left=0)
* right -- 数组的右边界(例如，排序截至到数组末尾，则right=array.length-1)
*
* 选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；
* 其中一部分的所有数据都比另外一部分的所有数据都要小。
* 然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
*/
void QuickSort(int* array,int left,int right)
{
if(left < right)
{
int i,j,data;
i = left;
j = right;
data = array[i];
while(i < j)
{
while(i < j && array[j] > data)
j--;
if( i < j)
array[i++] = array[j];
while(i < j && array[i] < data)
i++;
if(i < j)
array[j--] = array[i];
}
array[i] = data;
QuickSort(array,left,i-1);
QuickSort(array,i+1,right);
}
}
- 选择排序
/*
* 选择排序
*
* 参数说明：
* array -- 待排序的数组
* length -- 数组的长度
*
* 首先在未排序的数列中找到最小(or最大)元素，然后将其存放到数列的起始位置；
* 接着，再从剩余未排序的元素中继续寻找最小(or最大)元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
*/
void SelectSort(int* array,int length)
{
int i; // 有序区的末尾位置
int j; // 无序区的起始位置
int min;// 无序区中最小元素位置
for(i = 0 ; i < length ; i++)
{
min = i;
// 找出"arraya[i+1] ... array[n]"之间的最小元素，并赋值给min。
for(j = i + 1 ; j < length; j++)
{
if(array[j] < array[min])
{
min = j;
}
}
// 若min!=i，则交换 array[i] 和 array[min]。
// 交换之后，保证了array[0] ... array[i] 之间的元素是有序的。
if(min != i)
{
Swap(array,i,min);
}
}
}
void Print(int* array,int length)
{
for(int i = 0 ; i < length; i++)
{
cout << array[i] << " ";
}
cout << endl;
cout << "=============" << endl;
}
#include 支付宝捐赠