代码如下:
#include <iostream>
using namespace std;
const int N = 10;
void ShowArray(int n, int *arr){
for(int i=0; i<n; i++){
cout << arr[i] << " ";
}
cout << endl;
}
void SwapInt(int &x, int &y){
int temp = x;
x = y;
y = temp;
}
//冒泡排序
void BubbleSort(int n, int *arr){
for (int i=0; i<n; i++){
for (int j=1; j<n; j++){
//从大到小,相邻的两个数,如果前面的值小于后面,两个数互换位置
if(arr[j-1] < arr[j]){
SwapInt(arr[j-1], arr[j]);
}
}
}
}
//冒泡排序优化版
void BubbleSortOptimize(int n, int *arr){
for (int i=0; i<n; i++){
for (int j=i+1; j<n; j++){
//从小到大,比较指定位置的数和后面所有的数,如果前面的值大于后面,两个数互换位置
if(arr[i] > arr[j]){
SwapInt(arr[i], arr[j]);
}
}
}
}
//选择排序
void SelectSort(int n, int *arr){
for (int i=0; i<n; i++){
int position = i;
int maxInt = arr[i];
for (int j=i+1; j<n; j++){
//从大到小,找出剩余数中最大值的位置,与arr[i]交换位置
if (maxInt < arr[j]){
maxInt = arr[j];
position = j;
}
}
if(i < position){
SwapInt(arr[i], arr[position]);
}
}
}
//插入排序
void InsertSort(int n, int *arr){
for (int i=1; i<n; i++){
for (int j=i; j>0 && arr[j] < arr[j-1]; j--){ //需要判断数组是否越界
SwapInt(arr[j], arr[j-1]);
}
}
}
//插入排序优化版,让需要排序的数组从1位置开始,0位置做哨兵
void InsertSortOptimize(int n, int *arr){
int a[n+1]={0};
for (int i=0; i<n; i++){
a[i+1] = arr[i];
}
for (int i=2; i<n+1; i++){
a[0] = a[i]; //哨兵
for (int j=i; a[j] > a[j-1]; j--){//可以不用判断数组是否越界,不会有数大于或小于他自己
SwapInt(a[j], a[j-1]);
}
}
for (int i=0; i<n; i++){
arr[i] = a[i+1];
}
}
//希尔排序,高级插入排序,当输入串相对有序时,可以减少插入排序的移位操作
void ShellSort(int n, int *arr){
int rate=2;
for (int step=n/rate; step>0; step/=rate){
for (int i=0; i<step; i++){
for(int j=i+step; j<n; j+=step){
for (int k=j; k>i && arr[k] > arr[k-step]; k-=step){
SwapInt(arr[k],arr[k-step]);
}
}
}
}
}
//归并排序,递归深度一定log2n,算法复杂度稳定为O(nlog2n)
int ms[N] ={-1};
void MergeSort(int s, int n, int *arr){
if (1 == (n-s)){
return;
}
int i=s,j=(n+s)/2;
MergeSort(s, j, arr);
MergeSort(j, n, arr);
for(int k=s; k<n; k++){
if (j < n && arr[i] > arr[j]){
ms[k] = arr[j++];
}else{
ms[k] = arr[i++];
}
}
for(int k=s; k<n; k++){
arr[k]=ms[k];
}
}
//快速排序,递归深度会出现随机变换,算法复杂度最差为O(n2),单考虑到输入串比较随机,平均复杂度和归并排序一样
void QuickSort(int s, int n, int *arr){
if(1 >= n-s){
return;
}
int temp = arr[s];
int position = s;
int i=s, j=n-1;
while (i != j){
while(arr[j] < temp && j > i){
j--;
}
arr[position] = arr[j];
position = j;
while(arr[i] >= temp && i < j){
i++;
}
arr[position] = arr[i];
position = i;
}
arr[position] = temp;
QuickSort(s, position+1, arr);
QuickSort(position+1, n, arr);
}
//堆排序:递归实现
void maintain(int parent, int n,int *hs){
int maxPosition = parent*2;
if (maxPosition > n){return ;}
if(maxPosition < n && hs[maxPosition] > hs[maxPosition+1]){
maxPosition++;
}
if(hs[parent] > hs[maxPosition]){
SwapInt(hs[parent], hs[maxPosition]);
maintain(maxPosition, n, hs);
}
}
void HeapSort(int n, int *arr){
int hs[n+1] = {0};
for (int i=0; i<n; i++) {
hs[i+1] = arr[i];
}
//建堆
for (int parent=n/2; parent>0; parent--){
maintain(parent, n, hs);
}
//排序
for (int i=0; i<n; i++){
arr[i] = hs[1];
//hs[1] = hs[n-i];
SwapInt(hs[1],hs[n-i] ); //可以用一个数组实现
maintain(1, n-i-1, hs);
}
}
int main()
{
int arr[N] = {5,3,1,7,9,2,4,0,8,6};
BubbleSort(N, arr);
ShowArray(N, arr);
BubbleSortOptimize(N, arr);
ShowArray(N, arr);
SelectSort(N, arr);
ShowArray(N, arr);
InsertSort(N, arr);
ShowArray(N, arr);
InsertSortOptimize(N, arr);
ShowArray(N, arr);
MergeSort(0, N, arr);
ShowArray(N, arr);
QuickSort(0,N,arr);
ShowArray(N, arr);
HeapSort(N,arr);
ShowArray(N, arr);
ShellSort(N, arr);
ShowArray(N, arr);
return 0;
}
如题!