常见排序算法实现

Posted 2022-04-09 zhangfuxiao

#include "pch.h"
#include <iostream>
#include<algorithm>
#include<cmath>
using namespace std;
//选择排序
void selectSort(int arr[], int n)
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (arr[j] < arr[i])
swap(arr[j], arr[i]);




//插入排序
void insertSort(int arr[], int n)
for (int i = 1; i < n; i++)
for (int j = i; j >=0; j--)
if (arr[j] < arr[j - 1])
swap(arr[j], arr[j - 1]);

else
break;

//改进的插入排序
void new_insertSort(int arr[], int n)
for (int i = 1; i < n; i++)
int j;
int tmp = arr[i];
for (j = i; j >= 0; j--)
if (tmp < arr[j - 1])
arr[j] = arr[j - 1];

else
break;

arr[j] = tmp;


//归并排序自顶向下
void __merge(int arr[], int left, int mid, int right)
int *tmp = new int[right - left + 1];
for (int i = left; i <= right; i++)
tmp[i - left] = arr[i];

int i = left, j = mid + 1;
for (int k = left; k <= right; k++)
if (i > mid)
arr[k] = tmp[j - left];
j++;

else if (j > right)
arr[k] = tmp[i - left];
i++;

else if (tmp[i - left] < tmp[j - left])
arr[k] = tmp[i - left];
i++;

else
arr[k] = tmp[j - left];
j++;


delete []tmp;

void __mergeSort(int arr[], int left, int right)
if (left >= right)
return;

int mid = (left + right) / 2;
__mergeSort(arr, left, mid);
__mergeSort(arr, mid + 1, right);
__merge(arr, left, mid, right);

void mergeSort(int arr[], int n)
__mergeSort(arr, 0, n - 1);

//归并排序自低向上
void mergeSortBU(int arr[], int n)
for (int size = 1; size <= n; size += size)
for (int i = 0; i + size < n; i += size + size)
__merge(arr, i, i + size - 1, min(i + size + size - 1,n - 1));

//快速排序
int __partition(int arr[], int left, int right)
int k = arr[left];
int j = left;
for (int i = left + 1; i <= right; i++)
if (arr[i] < k)
swap(arr[j + 1], arr[i]);
j++;


swap(arr[left], arr[j]);
return j;

void __quickSort(int arr[], int left, int right)
if (left >= right)
return;

int k = __partition(arr, left, right);
__quickSort(arr, left, k - 1);
__quickSort(arr, k + 1, right);

void quickSort(int arr[], int n)
__quickSort(arr, 0, n - 1);

//三路快排
void __quickSort3Ways(int arr[], int left, int right)
if (left >= right)
return;

int k = arr[left];
int j = left;
int lt = left;
int rt = right + 1;
int i = left + 1;
while (i < rt)
if (arr[i] > k)
swap(arr[i], arr[rt - 1]);
rt--;

else if (arr[i] < k)
swap(arr[i], arr[lt + 1]);
lt++;
i++;

else

i++;


swap(arr[left], arr[lt]);
__quickSort3Ways(arr, left, lt);
__quickSort3Ways(arr, rt, right);

void quickSort3Ways(int arr[], int n)
__quickSort3Ways(arr, 0, n - 1);

//堆排序
//建堆
class MaxHeap
private:
int *data;
int count;
void shiftUp(int n)
while (n > 1&&data[n / 2] < data[n])
swap(data[n / 2], data[n]);
n = n / 2;



void shiftDown(int k)
while (2 * k < count)
int j = 2 * k;
if (j + 1 < count && data[j + 1] > data[j])

j = j + 1;

if (data[k] > data[j])
break;

swap(data[k], data[j]);
k = j;


public:
MaxHeap(int capacity)
data = new int[capacity + 1];

~MaxHeap()
delete[]data;

int size()
return count;

bool empty()
return count == 0;

void insert(int n)
data[count + 1] = n;
count++;
shiftUp(count);

int extractMax()
if (count > 0)
int res = data[1];
data[1] = data[count];
count--;
shiftDown(1);
return res;

;
void heapSort(int arr[], int n)
MaxHeap maxheap = MaxHeap(n);
for (int i = 0; i < n; i++)
maxheap.insert(arr[i]);

for (int i = n - 1; i >= 0; i--)
arr[i] = maxheap.extractMax();



int main()

int a[10] = 1,4,3,7,5,8,9,6,11,10 ;
//selectSort(a, 10);
//insertSort(a, 10);
//new_insertSort(a, 10);
//mergeSort(a, 10);
//mergeSortBU(a, 10);
//quickSort(a, 10);
//quickSort3Ways(a, 10);
heapSort(a, 10);
for (int i = 0; i < 10; i++)
cout << a[i] << endl;