七种基本排序实现源码
1.【插入排序】
void InsertSort(int* p ,int size)
{
for(int i=1;i<size;i++)
{
int j = i;
int t = p[i];
for(; j > 0 && p[j-1] > t; j--)
p[j] = p[j-1];
p[j] = t;
}
}
2.【选择排序】
void SelectSort(int* arr,int size)
{
for(int i=0;i<size;i++)
{
int psn=i;
for(int j=i;j<size;j++)
{
if(arr[j]<arr[psn])
psn = j;
}
swap(arr[psn],arr[i]);
}
}
3.【冒泡排序】
void BubbleSort(int* arr,int size)
{
bool cg = true;
int n = 0;
do
{
cg = false;
for (int i=0;i<size-1-n;i++)
{
if (arr[i]>arr[i+1])
{
cg = true;
swap(arr[i],arr[i+1]);
}
}
n++;
} while (cg);
}
4.【快速排序】
void QuickSort(int* arr,int size)
{
int *L,*R;
if(size <= 1) return;
if(2 == size)
{
if(arr[0] > arr[1])
swap(arr[0],arr[1]);
return;
}
L = &arr[1];
R = &arr[size -1];
while(L < R)
{
while(L<R && *L < *arr) ++L;
while(R>arr && !(*R < *arr)) --R;
if(L<R) swap(*R,*L);
}
swap(*R,*arr);
QuickSort(arr, R-arr);
QuickSort(R+1,size -1 -(R-arr));
}
5.【堆排序】
void Shift(int* heap, int start, int end)
{
int tmp = heap[start];
int parent = start;
int child = parent * 2 + 1;
while(child <= end)
{
if(child < end &&
heap[child] < heap[child+1])
child++;
if(tmp < heap[child])
{
heap[parent] = heap[child];
parent = child;
child = 2 * parent +1;
} else break;
}
heap[parent] = tmp;
}
void BuildHeap(int* heap,int size)
{
for(int i=size/2-1; i >=0; i--)
Shift(heap,i,size-1);
}
void HeapSort(int* heap,int size)
{
BuildHeap(heap,size);
for(int i = size-1; i>0; i--)
{
swap(heap[0],heap[i]);
Shift(heap,0,i-1);
}
}
6.【归并排序】
void Merge(int* arr,int first,int mid,int last)
{
int size = last -first + 1;
int* tmp = new int[size];
int b1 = first;
int e1 = mid;
int b2 = mid + 1;
int e2 = last;
int k = 0;
while(b1<=e1 && b2<=e2)
if(arr[b1]<arr[b2])
tmp[k++] = arr[b1++];
else tmp[k++] = arr[b2++];
while(b1<=e1) tmp[k++]=arr[b1++];
while(b2<=e2) tmp[k++]=arr[b2++];
for(int i=0; i<size; i++)
arr[first + i] = tmp[i];
delete tmp;
}
void MergeSort(int* arr,int first,int last)
{
if(first < last)
{
int mid = (first +last) / 2;
MergeSort(arr,first,mid);
MergeSort(arr,mid+1,last);
Merge(arr,first,mid,last);
}
}
7.【希尔排序】
void ShellSort(int *p, int size)
{
int iTemp;
for( int iStep = size/2; iStep > 0; iStep = iStep/2 ) {
for( int i = iStep; i < size; ++i ) {
iTemp = p[i];
int j = i;
for( ; j >= iStep; j -= iStep ) {
if( iTemp < p[j-iStep] ) {
p[j] = p[j-iStep];
} else {
break;
}
}
p[j] = iTemp;
}
}
}
【代码测试】
#include<iostream>
#include<string>
using namespace std;
typedef void(*SortFunc)(int*, int, int*, int*);
// 插入排序
void InsertSort(int* p ,int size, int* move_cnt, int* compare_cnt)
{
for(int i=1;i<size;i++)
{
int j = i;
int t = p[i];
++*move_cnt;
++*compare_cnt;
for(; j > 0 && p[j-1] > t; j--) {
++*compare_cnt;
p[j] = p[j-1];
++*move_cnt;
}
p[j] = t;
++*move_cnt;
}
}
// 希尔排序
void ShellSort(int *p, int size, int* move_cnt, int* compare_cnt)
{
int iTemp;
for( int iStep = size/2; iStep > 0; iStep = iStep/2 )
{
for( int i = iStep; i < size; ++i )
{
iTemp = p[i];
++*move_cnt;
int j = i;
for( ; j >= iStep; j -= iStep )
{
++*compare_cnt;
if( iTemp < p[j-iStep] )
{
p[j] = p[j-iStep];
++*move_cnt;
}
else
{
break;
}
}
p[j] = iTemp;
++*move_cnt;
}
}
}
// 冒泡排序
void BubbleSort(int* arr,int size, int* move_cnt, int* compare_cnt)
{
bool cg = true;
int n = 0;
do
{
cg = false;
for (int i=0;i<size-1-n;i++)
{
++*compare_cnt;
if (arr[i]>arr[i+1])
{
cg = true;
swap(arr[i],arr[i+1]);
*move_cnt += 3;
}
}
n++;
} while (cg);
}
// 快速排序
void QuickSort(int* arr,int size, int* move_cnt, int* compare_cnt)
{
int *L,*R;
if(size <= 1) return;
if(2 == size)
{
++*compare_cnt;
if(arr[0] > arr[1]) {
swap(arr[0],arr[1]);
*move_cnt += 3;
}
return;
}
L = &arr[1];
R = &arr[size -1];
while(L < R)
{
++*compare_cnt;
while(L<R && *L < *arr) {
++*compare_cnt;
++L;
}
++*compare_cnt;
while(R>arr && !(*R < *arr)) {
++*compare_cnt;
--R;
}
++*compare_cnt;
if(L<R){
swap(*R,*L);
*move_cnt += 3;
}
}
swap(*R,*arr);
*move_cnt += 3;
QuickSort(arr, R-arr, move_cnt, compare_cnt);
QuickSort(R+1,size -1 -(R-arr), move_cnt, compare_cnt);
}
// 简单选择排序
void SelectSort(int* arr,int size, int* move_cnt, int* compare_cnt)
{
for(int i=0;i<size;i++)
{
int psn=i;
for(int j=i;j<size;j++)
{
++*compare_cnt;
if(arr[j]<arr[psn]) {
psn = j;
}
}
swap(arr[psn],arr[i]);
*move_cnt += 3;
}
}
void Shift(int* heap, int start, int end, int* move_cnt, int* compare_cnt)
{
int tmp = heap[start];
++*move_cnt;
int parent = start;
int child = parent * 2 + 1;
while(child <= end)
{
++*compare_cnt;
if(child < end && heap[child] < heap[child+1]) {
++child;
}
++*compare_cnt;
if(tmp < heap[child])
{
heap[parent] = heap[child];
++*move_cnt;
parent = child;
child = 2 * parent +1;
} else break;
}
heap[parent] = tmp;
++*move_cnt;
}
void BuildHeap(int* heap,int size, int* move_cnt, int* compare_cnt)
{
for(int i=size/2-1; i >=0; i--)
Shift(heap,i,size-1, move_cnt, compare_cnt);
}
void HeapSort(int* heap, int size, int* move_cnt, int* compare_cnt)
{
BuildHeap(heap, size, move_cnt, compare_cnt);
for(int i = size-1; i>0; i--)
{
swap(heap[0],heap[i]);
Shift(heap,0,i-1, move_cnt, compare_cnt);
}
}
void Merge(int* arr,int first,int mid,int last, int* move_cnt, int* compare_cnt)
{
int size = last -first + 1;
int* tmp = new int[size];
int b1 = first;
int e1 = mid;
int b2 = mid + 1;
int e2 = last;
int k = 0;
while(b1<=e1 && b2<=e2) {
++*compare_cnt;
if(arr[b1]<arr[b2])
tmp[k++] = arr[b1++];
else tmp[k++] = arr[b2++];
++*move_cnt;
}
while(b1<=e1) {
tmp[k++]=arr[b1++];
++*move_cnt;
++*compare_cnt;
}
while(b2<=e2) {
tmp[k++]=arr[b2++];
++*move_cnt;
++*compare_cnt;
}
for(int i=0; i<size; i++) {
arr[first + i] = tmp[i];
++*move_cnt;
}
delete tmp;
}
void MergeSort(int* arr,int size, int* move_cnt, int* compare_cnt)
{
if(size > 1)
{
int mid = size / 2;
MergeSort(arr, mid, move_cnt, compare_cnt);
MergeSort(arr + mid, size - mid, move_cnt, compare_cnt);
Merge(arr, 0, mid - 1, size -1, move_cnt, compare_cnt);
}
}
// 输出数组
void ShowArray(int * p, int size)
{
for(int i = 0; i < size; i++)
{
cout<< p[i];
if(i < size-1)
{
cout<< ", ";
}
}
cout<< endl;
}
void CopyToTmp(int* arr, int* temp, int length) {
for( int i = 0; i < length; ++i )
{
temp[i] = arr[i];
}
}
int main()
{
int arr[4][20] = { {-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100},
{100, 99, 96, 93,89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20},
{99, 75, -10, 87, 41,100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79},
{0} };
const string arr_name[3] = {"顺序的数组" ,"逆序的数组", "随机的数组"};
SortFunc sort_functions[7] = {InsertSort, SelectSort, BubbleSort, QuickSort, ShellSort, HeapSort, MergeSort };
const string sort_func_name[7] = {"插入排序", "选择排序", "冒泡排序", "快速排序", "希尔排序", "堆排序", "归并排序" };
int compare_cnt = 0, move_cnt = 0;
cout << "========================================================" << endl;
for (int i = 0; i < 7; ++i) {
cout << " **** " << sort_func_name[i] << " ****" << " 测试结果如下：" << endl ;
cout << "========================================================" << endl;
for (int j = 0; j < 3; ++j) {
compare_cnt = 0;
move_cnt = 0;
CopyToTmp(arr[j], arr[3], 20);
cout << endl << arr_name[j] << "：";
ShowArray(arr[3], 20);
sort_functions[i](arr[3], 20, &move_cnt, &compare_cnt);
cout << sort_func_name[i] << "后: " ;
ShowArray(arr[3], 20);
cout << sort_func_name[i] << "对" << arr_name[j] << "排序,共进行 " << compare_cnt << " 次比较 和 " << move_cnt << " 次移动" << endl;
}
cout << endl << "========================================================" << endl;
}
system("pause");
return 0;
}
【测试结果】
======================================================== **** 插入排序 **** 测试结果如下： ======================================================== 顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 插入排序对顺序的数组排序,共进行 19 次比较 和 38 次移动 逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20 插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 插入排序对逆序的数组排序,共进行 209 次比较 和 228 次移动 随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79 插入排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 插入排序对随机的数组排序,共进行 132 次比较 和 151 次移动 ======================================================== **** 选择排序 **** 测试结果如下： ======================================================== 顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 选择排序对顺序的数组排序,共进行 210 次比较 和 60 次移动 逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20 选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 选择排序对逆序的数组排序,共进行 210 次比较 和 60 次移动 随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79 选择排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 选择排序对随机的数组排序,共进行 210 次比较 和 60 次移动 ======================================================== **** 冒泡排序 **** 测试结果如下： ======================================================== 顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 冒泡排序对顺序的数组排序,共进行 19 次比较 和 0 次移动 逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20 冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 冒泡排序对逆序的数组排序,共进行 190 次比较 和 570 次移动 随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79 冒泡排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 冒泡排序对随机的数组排序,共进行 189 次比较 和 339 次移动 ======================================================== **** 快速排序 **** 测试结果如下： ======================================================== 顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 快速排序对顺序的数组排序,共进行 244 次比较 和 54 次移动 逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20 快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 快速排序对逆序的数组排序,共进行 235 次比较 和 57 次移动 随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79 快速排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 快速排序对随机的数组排序,共进行 140 次比较 和 54 次移动 ======================================================== **** 希尔排序 **** 测试结果如下： ======================================================== 顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 希尔排序对顺序的数组排序,共进行 62 次比较 和 124 次移动 逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20 希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 希尔排序对逆序的数组排序,共进行 80 次比较 和 160 次移动 随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79 希尔排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 希尔排序对随机的数组排序,共进行 88 次比较 和 163 次移动 ======================================================== **** 堆排序 **** 测试结果如下： ======================================================== 顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 堆排序对顺序的数组排序,共进行 126 次比较 和 119 次移动 逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20 堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 堆排序对逆序的数组排序,共进行 108 次比较 和 101 次移动 随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79 堆排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 堆排序对随机的数组排序,共进行 118 次比较 和 108 次移动 ======================================================== **** 归并排序 **** 测试结果如下： ======================================================== 顺序的数组：-20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 归并排序对顺序的数组排序,共进行 88 次比较 和 176 次移动 逆序的数组：100, 99, 96, 93, 89, 87, 82, 79, 75, 65, 62, 51, 41, 24, 18, 10, 0, -10, -15, -20 归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 归并排序对逆序的数组排序,共进行 88 次比较 和 176 次移动 随机的数组：99, 75, -10, 87, 41, 100, 89, 65, 18, 93, 0, 51, 62, 10, -20, 82, 24, 96, -15, 79 归并排序后: -20, -15, -10, 0, 10, 18, 24, 41, 51, 62, 65, 75, 79, 82, 87, 89, 93, 96, 99, 100 归并排序对随机的数组排序,共进行 88 次比较 和 176 次移动
原创文章，转载请注明： 转载自 IIcyZhao’s Road
本文链接地址：http://blog.csdn.net/iicy266/article/details/11905851