十大排序算法
- 冒泡排序
- 选择排序
- 插入排序
- 桶排序
- 计数排序
- 基数排序
- 快速排序
- 归并排序
- 基尔排序
- 堆排序
#include "stdafx.h"
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
void bubbleSort(vector<int> &v)
{
int len = v.size();
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i-1; j++)
{
if (v[j] > v[j + 1])
{
int temp = v[j + 1];
v[j+1] = v[j];
v[j] = temp;
}
}
}
}
void seletionSort(vector<int> &v)
{
int len = v.size();
for (int i = 0; i < len - 1; i++)
{
for (int j = i + 1; j < len; j++)
{
if (v[i] > v[j])
{
int temp = v[j];
v[j] = v[i];
v[i] = temp;
}
}
}
}
void insertSort(vector<int> &v)
{
int len = v.size();
for (int i = 1; i < len; i++)
{
int temp = v[i];
int j;
for (j = i-1; j >= 0; j--)
{
if (temp >= v[j])
{
break;
}
v[j + 1] = v[j];
}
v[j + 1] = temp;
}
}
void bucketSort(vector<int> &v, int n)
{
int value_min = *min_element(v.begin(), v.end());
int value_max = *max_element(v.begin(), v.end());
float interval = (value_max - value_min + 1) / (float)n;
vector<vector<int>> value_sort;
value_sort.resize(10);
for (int i = 0; i < v.size(); i++)
{
int index = (int)((v[i] - value_min) / interval);
value_sort[index].push_back(v[i]);
}
for (int i = 0; i < n; i++)
{
bubbleSort(value_sort[i]);
}
int k = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < value_sort[i].size(); j++)
{
v[k++] = value_sort[i][j];
}
}
}
void countSort(vector<int> &v)
{
const int num = 100;
int temp[num] = {0};
for (int i = 0; i < v.size(); i++)
{
temp[v[i]]++;
}
int k = 0;
for (int i = 0; i < num; i++)
{
for (int j = 0; j < temp[i]; j++)
v[k++] = i;
}
}
void radixSort(vector<int> &v)
{
int value_max = *max_element(v.begin(), v.end());
int exp;
for (exp = 1; value_max / exp>0; exp *= 10)
{
int bucket[10] = { 0 };
vector<int> output;
output.resize(v.size());
for (int i = 0; i < v.size(); i++)
{
bucket[(v[i]/exp)%10]++;
}
for (int i = 1; i < 10; i++)
{
bucket[i] += bucket[i - 1];
}
for (int i = v.size() - 1; i >= 0; i--)
{
output[bucket[(v[i] / exp) % 10] - 1] = v[i];
bucket[(v[i] / exp) % 10]--;
}
for (int i = 0; i < v.size(); i++)
{
v[i] = output[i];
}
}
}
void quickSort1(vector<int> &v,int begin, int end)
{
if (begin >= end)
return;
int left = begin;
int right = end;
int temp = v[left];
while (left < right)
{
while (left < right && v[right] >= temp)
right--;
if (left < right)
v[left++] = v[right];
while (left < right && v[left] <= temp)
{
left++;
}
if (left < right)
{
v[right--] = v[left];
}
}
v[left] = temp;
quickSort1(v,begin,left-1);
quickSort1(v, left + 1, end);
}
void merge(vector<int> &v, int begin, int mid, int end)
{
vector<int> result;
int i = begin, j = mid + 1;
while (i <= mid && j <= end)
{
if (v[i] <= v[j])
{
result.push_back(v[i++]);
}
else
{
result.push_back(v[j++]);
}
}
while (i <= mid)
{
result.push_back(v[i++]);
}
while (j <= end)
{
result.push_back(v[j++]);
}
for (int i = 0; i <result.size(); i++)
{
v[i+begin] = result[i];
}
result.clear();
vector<int>().swap(result);
}
void mergeSort(vector<int> &v, int begin, int end)
{
if (v.size() == 0 || begin >= end)
return;
int mid = (end + begin) / 2;
mergeSort(v, begin, mid);
mergeSort(v, mid + 1, end);
merge(v, begin, mid, end);
}
void group_sort(vector<int> &v,int i,int gap)
{
int len = v.size();
for (int j = i + gap; j < len;j += gap)
{
int temp = v[j];
int k;
for (k = j - gap; k >= 0; k -= gap)
{
if (v[k] <= temp)
break;
v[k + gap] = v[k];
}
v[k + gap] = temp;
}
}
void shellSort(vector<int> &v)
{
int len = v.size();
for (int gap = len / 2; gap > 0; gap /= 2)
{
for (int i = 0; i < gap; i++)
{
group_sort(v, i, gap);
}
}
}
void maxHeapDown(vector<int> &v,int begin, int end)
{
int current_index = begin;
for (int next_index = 2 * current_index + 1; next_index <= end; current_index = next_index, next_index = 2 * next_index + 1)
{
if (next_index < end && v[next_index] < v[next_index+1])
next_index++;
if (v[current_index] >= v[next_index])
{
break;
}
else
{
int temp = v[current_index];
v[current_index] = v[next_index];
v[next_index] = temp;
}
}
}
void heapSort(vector<int> &v)
{
for (int i = v.size()/ 2 - 1; i >= 0; i--)
{
maxHeapDown(v,i, v.size()-1);
}
for (int i = v.size() - 1; i > 0; i--)
{
int temp = v[0];
v[0] = v[i];
v[i] = temp;
maxHeapDown(v, 0, i-1);
}
}
void minHeapDown(vector<int> &v, int begin, int end)
{
int c = begin;
for (int next = 2 * c + 1; next <= end; c = next, next = 2 * next + 1)
{
if (next<end && v[next]>v[next + 1])
next++;
if (v[c] <= v[next])
break;
else
{
int temp = v[c];
v[c] = v[next];
v[next] = temp;
}
}
}
void minHeapSort(vector<int> &v)
{
int len = v.size();
for (int i = len / 2 - 1; i >= 0; i--)
{
minHeapDown(v,i, len-1);
}
for (int i = len - 1; i > 0; i--)
{
int temp = v[0];
v[0] = v[i];
v[i] = temp;
minHeapDown(v,0,i-1);
}
}
int main()
{
vector<int> v;
v.push_back(3);
v.push_back(1);
v.push_back(5);
v.push_back(3);
v.push_back(2);
v.push_back(12);
v.push_back(11);
v.push_back(24);
v.push_back(43);
v.push_back(34);
v.push_back(24);
v.push_back(30);
heapSort(v);
for (int i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
return 0;
}