#include<iostream>
using namespace std;
#if 1
void InsertSort(int* array, int size) {
for (int i = 1;i < size;++i) {
int key = array[i];
int end = i - 1;
while (end >= 0&&key < array[end]) {
array[end + 1] = array[end];
end--;
}
array[end + 1] = key;
}
}
#endif
#if 0
void ShellSort(int* array, int size) {
int gap = 3;
while (gap) {
for (int i = gap;i < size;++i) {
int key = array[i];
int end = i - gap;
while (end >= 0 && key < array[end]) {
array[end + gap] = array[end];
end = end - gap;
}
array[end + gap] = key;
}
gap--;
}
}
#endif
#if 0
void SelectSort(int* array, int size) {
for (int j = 0;j < size - 1;++j) {
int MaxPos = 0;
for (int i = 0;i < size - j;++i) {
if (array[i] > array[MaxPos]) {
MaxPos = i;
}
}
if (MaxPos != size - 1 - j) {
swap(array[MaxPos], array[size - 1 - j]);
}
}
}
#endif
#if 0
void SelectSortOP(int* array, int size) {
int begin = 0;
int end = size - 1;
while (begin < end) {
int MaxPos = begin;
int MinPos = begin;
int index = begin + 1;
while (index <=end) {
if (array[index] > array[MaxPos]) {
MaxPos = index;
}
if (array[index] < array[MinPos]) {
MinPos = index;
}
index++;
}
if (MinPos == end) {
MinPos = MaxPos;
}
if (MaxPos != end) {
swap(array[MaxPos], array[end]);
}
if (MinPos != begin) {
swap(array[MinPos], array[begin]);
}
begin++;
end--;
}
}
#endif
//优化快排 为了避免所取基准值为最小或最大情况 采用三数取中法得基准值
//当区间元素比较少时用插入排序
int GetMidIndex(int* array, int left, int right) {
int mid = left + ((right - left) >> 1);
if (array[left] < array[right]) {
if (array[mid] < array[left]) {
return left;
}
else if (mid > array[right]) {
return right;
}
else {
return mid;
}
}
else {
if (array[mid] < array[right]) {
return right;
}
else if (array[mid] > array[left]) {
return left;
}
else {
return mid;
}
}
}
int Partion1(int* array, int left, int right) {
int begin = left;
int end = right - 1;
int key = array[right - 1];
//begin从前往后找比基准值大的元素
while(begin<end){
while (begin < end && array[begin] <= key)
begin++;
//end从后往前找比基准值小的元素
while (begin < end && array[end] >= key)
end--;
if (begin != end) {
swap(array[begin], array[end]);
}
}
if (begin != right - 1) {
swap(array[begin], array[right - 1]);
}
return begin;
}
//挖坑法
int Partion2(int* array, int left, int right) {
int begin = 0;
int end = right - 1;
int key = array[end];
//begin从前往后找到基准值的值则填坑
while (begin < end) {
while (begin < end&&array[begin] <= key) {
begin++;
}
if (begin < end) {
swap(array[begin], array[end]);
end--;
}
//end从后找到比基准值的值则填上一个坑
while (begin < end&&array[end] >= key) {
end--;
}
if (begin < end) {
swap(array[end], array[begin]);
begin++;
}
}
array[begin] = key;
return begin;
}
//前后指针
int Partion3(int* array, int left, int right) {
int cur = left;
int pre = left - 1;
int key = array[right - 1];
int mid = GetMidIndex(array, left, right);
swap(key, array[mid]);
while (cur < right) {
if (array[cur] < key&&cur != ++pre) {
swap(array[cur], array[pre]);
}
cur++;
}
++pre;
swap(array[pre], array[right - 1]);
return pre;
}
void QuickSort(int* array, int left, int right) {
/*if (right - left > 1) {
int div = Partion3(array, left, right);
QuickSort(array, left, div);
QuickSort(array, div + 1, right);
}*/
if (right - left <16) {
InsertSort(array, right - left);
}
else {
int div = Partion3(array, left, right);
QuickSort(array, left, div);
QuickSort(array, div + 1, right);
}
}
//循环快排
#include<stack>
void QuickSortNor(int* array, int size) {
int left = 0;
int right = size;
stack<int> s;
s.push(right);
s.push(left);
while (!s.empty()) {
left = s.top();
s.pop();
right = s.top();
s.pop();
if (right - left > 1) {
int mid = Partion1(array, left, right);
s.push(right);
s.push(mid + 1);
s.push(mid);
s.push(left);
}
}
}
//归并排序
void MergeData(int* array, int left, int mid, int right, int* temp) {
int begin1 = left, end1 = mid;
int begin2 = mid, end2 = right;
int index = left;
while (begin1 < end1&&begin2 < end2) {
if (array[begin1] <= array[begin2]) {
temp[index++] = array[begin1++];
}
else {
temp[index++] = array[begin2++];
}
while (begin1 < end1) {
temp[index++] = array[begin1++];
}
while (begin2 < end2) {
temp[index++] = array[begin2++];
}
}
}
void _MergeSort(int* array, int left, int right, int* temp) {
if (right - left> 1) {
int mid = left + ((right - left) >> 1);
_MergeSort(array, left, mid, temp);
_MergeSort(array, mid, right, temp);
MergeData(array, left, mid, right, temp);
memcmp(array + left, temp + left, (right - left) * sizeof(array[0]));
}
}
void MergeSort(int* array, int size) {
int* temp = new int[size];
_MergeSort(array, 0, size, temp);
delete[] temp;
}
#if 0
void HeapAdjust(int* array, int size, int parent)
{
int child = parent * 2 + 1;
while (child < size)
{
// 找左右孩子中较大的孩子
if (child+1 < size && array[child+1] > array[child])
{
child += 1;
}
if (array[parent] < array[child])
{
swap(array[parent], array[child]);
parent = child;
child = parent * 2 + 1;
}
else
return;
}
}
// 堆排序
void HeapSort(int* array, int size)
{
// 1. 创建堆---向下调整
// 升序---->大堆 降序---小堆
// 找倒数第一个非叶子节点
int root = ((size - 2) >> 1);
for (; root >= 0; --root)
HeapAdjust(array, size, root);
// 2. 堆删除的思想---向下调整
int end = size - 1;
while (end)
{
swap(array[0], array[end]);
HeapAdjust(array, end, 0);
--end;
}
}
c++实现常见排序算法
猜你喜欢
转载自blog.csdn.net/weixin_44374280/article/details/101178746
今日推荐
周排行