冒泡排序(Bubble sort)
最简单,效率最低的冒泡排序
冒泡排序是一种交换排序,基本思想是:两两比较相邻记录的的关键字,如果反序则交换,直到没有反序的记录为止。
时间复杂度分析
最好的情况是,数组是有序的,只需要n - 1次的比较,时间复杂度是
O(n)
最坏的情况是,数组是逆序的,需要比较
∑ni=2(i−1)=1+2+3+...+(n−1)=n(n−1)2
, 所以时间复杂度为
O(n2)
代码实现
void Bubble_sort(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = i + 1; j < len; j ++)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
void Bubble_sort1(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = len - 1; j >= i; j --)
{
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
}
void Bubble_sort2(int arr[], int len)
{
bool flag = true;
while(flag)
{
flag = false;
for(int i = 0; i < len; i ++)
for(int j = len - 1; j >= i; j --)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
测试程序
#include <iostream>
#include <cstring>
#include <ctime>
using namespace std;
#define ArraySize 100000
void swap(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
void Bubble_sort(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = i + 1; j < len; j ++)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
void Bubble_sort1(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = len - 1; j >= i; j --)
{
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
}
void Bubble_sort2(int arr[], int len)
{
bool flag = true;
while(flag)
{
flag = false;
for(int i = 0; i < len; i ++)
for(int j = len - 1; j >= i; j --)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
void Print_array(int arr[], int len)
{
for(int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
int main(int argc, char const *argv[])
{
/* code */
int Array[ArraySize];
int Array1[ArraySize];
int Array2[ArraySize];
time_t begin , end;
srand(time(NULL));
for(int i = 0; i < ArraySize; i ++)
{
Array[i] = rand()%ArraySize;
//cout << Array[i] << " ";
}
memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));
// Print_array(Array, ArraySize);
begin = clock();
Bubble_sort(Array, ArraySize);
end = clock();
cout << "Bubble_sort runtime: " << double(end - begin) / CLOCKS_PER_SEC << endl;
begin = clock();
Bubble_sort1(Array1, ArraySize);
end = clock();
cout << "Bubble_sort1 runtime: " << double(end - begin) / CLOCKS_PER_SEC << endl;
begin = clock();
Bubble_sort2(Array2, ArraySize);
end = clock();
cout << "Bubble_sort2 runtime: " << double(end - begin) / CLOCKS_PER_SEC << endl;
//Print_array(Array, ArraySize);
return 0;
}
看下运行结果就知道有多慢了,这里我随机初始化了十万大小的数组:
Bubble_sort runtime: 24.2s
Bubble_sort1 runtime: 15.481s
Bubble_sort2 runtime: 15.146s
选择排序(Slection Sort)
基本思想
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。https://zh.wikipedia.org/wiki/%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F
代码实现
void Slect_sort(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
int min_index = i ;
for(int j = i + 1; j < len; j ++)
{
if(arr[min_index] > arr[j])
min_index = j;
}
if(i != min_index)
swap(arr[i],arr[min_index]);
}
}
测试代码
#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;
#define ArraySize 100000
void swap(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
void Bubble_sort(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = i + 1; j < len; j ++)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
void Bubble_sort1(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = len - 1; j >= i; j --)
{
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
}
void Bubble_sort2(int arr[], int len)
{
bool flag = true;
while(flag)
{
flag = false;
for(int i = 0; i < len; i ++)
for(int j = len - 1; j >= i; j --)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
void Slect_sort(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
int min_index = i ;
for(int j = i + 1; j < len; j ++)
{
if(arr[min_index] > arr[j])
min_index = j;
}
if(i != min_index)
swap(arr[i],arr[min_index]);
}
}
void Print_array(int arr[], int len)
{
for(int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
int main(int argc, char const *argv[])
{
/* code */
int Array[ArraySize];
int Array1[ArraySize];
int Array2[ArraySize];
time_t begin , end;
srand(time(NULL));
for(int i = 0; i < ArraySize; i ++)
{
Array[i] = rand()%ArraySize;
//cout << Array[i] << " ";
}
memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));
// Print_array(Array, ArraySize);
begin = clock();
Bubble_sort2(Array, ArraySize);
end = clock();
cout << "Bubble_sort runtime: " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;
begin = clock();
Slect_sort(Array1, ArraySize);
end = clock();
cout << "Slect_sort runtime: " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;
//Print_array(Array2, ArraySize);
return 0;
}
运行结果如下,比冒泡稍微快了点。
Bubble_sort runtime: 15.274s
Slect_sort runtime: 11.058s
时间复杂度分析
比较次数 O(n2) ,比较次数与关键字的初始状态无关,总的比较次数 N=(n−1)+(n−2)+...+1=n×(n−1)/2 。交换次数 O(n) ,最好情况是,已经有序,交换0次;最坏情况是,逆序,交换n-1次。交换次数比冒泡排序较少。所以总的时间复杂度依然为 O(n2)
插入排序(Insert Sort)
基本思想
插入排序(Insertion Sort)是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。https://zh.wikipedia.org/wiki/%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F
代码实现
void Insert_sort(int arr[], int len)
{
for(int i= 1; i < len; i ++)
{
int key = arr[i];
int j = i;
while(j && arr[j - 1] > key)
{
arr[j] = arr[j - 1];
j --;
}
arr[j] = key;
}
}
测试代码
#include <iostream>
#include <cstring>
#include <ctime>
#include <cmath>
using namespace std;
#define ArraySize 100000
void swap(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
void Bubble_sort(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = i + 1; j < len; j ++)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
void Bubble_sort1(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
for(int j = len - 1; j >= i; j --)
{
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
}
void Bubble_sort2(int arr[], int len)
{
bool flag = true;
while(flag)
{
flag = false;
for(int i = 0; i < len; i ++)
for(int j = len - 1; j >= i; j --)
if(arr[i] > arr[j])
swap(arr[i], arr[j]);
}
}
void Slect_sort(int arr[], int len)
{
for(int i = 0; i < len; i ++)
{
int min_index = i ;
for(int j = i + 1; j < len; j ++)
{
if(arr[min_index] > arr[j])
min_index = j;
}
if(i != min_index)
swap(arr[i],arr[min_index]);
}
}
void Insert_sort(int arr[], int len)
{
for(int i= 1; i < len; i ++)
{
int key = arr[i];
int j = i;
while(j && arr[j - 1] > key)
{
arr[j] = arr[j - 1];
j --;
}
arr[j] = key;
}
}
void Print_array(int arr[], int len)
{
for(int i = 0; i < len; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
int main(int argc, char const *argv[])
{
/* code */
int Array[ArraySize];
int Array1[ArraySize];
int Array2[ArraySize];
time_t begin , end;
srand(time(NULL));
for(int i = 0; i < ArraySize; i ++)
{
Array[i] = rand()%ArraySize;
//cout << Array[i] << " ";
}
memcpy(Array1, Array, ArraySize * sizeof(Array1[0]));
memcpy(Array2, Array, ArraySize * sizeof(Array2[0]));
// Print_array(Array, ArraySize);
begin = clock();
Bubble_sort2(Array, ArraySize);
end = clock();
cout << "Bubble_sort runtime: " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;
begin = clock();
Slect_sort(Array1, ArraySize);
end = clock();
cout << "Slect_sort runtime: " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;
begin = clock();
Insert_sort(Array2, ArraySize);
end = clock();
cout << "Insert_sort runtime: " << double(end - begin) / CLOCKS_PER_SEC << "s" << endl;
//Print_array(Array2, ArraySize);
return 0;
}
运行结果如下,比冒泡和选择都快。
Bubble_sort runtime: 15.336s
Slect_sort runtime: 11.044s
Insert_sort runtime: 6.453s
时间复杂度分析
最好情况就是,序列已经是升序排列了,在这种情况下,需要进行的比较操作需 (n−1) 次即可。最坏情况就是,序列是降序排列,那么此时需要进行的比较共有 n(n−1)/2 次。插入排序的赋值操作是比较操作的次数减去 (n−1) 次。平均来说插入排序算法复杂度为 O(n2) 。