C/C++算法排序合集
1.选择排序
第一步：在数组中，选择最大值，并且记录最大值下标，然后将最大值与最后一个值交换
第二步：在剩下的待排序数列中，重新找最大值，重复步骤一直到数列排序完成
#include
#include
void select(int* arr,int size) {
int index = 0;
for (int i = 0; i < size; i++) {
index = 0;
int j = 0;
for (; j < size - i; j++) {
if (arr[index] < arr[j]) {
index = j;
}
}
int temp = arr[index];
arr[index] = arr[j - 1];
arr[j - 1] = temp;
}
}
int main() {
int arr[6] = { 4,1,6,2,8,0 };
int n = sizeof(arr) / sizeof(int);
select(arr, n);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
} 2.插入排序:
将数列分为有序表和无序表，每次从无序表中取出一个元素，插入到有序表的适当位置，一开始有序表是一个数，无序表是n-1个数。
每遍历一次，有序表中的元素 增加一个·，无序表中的元素减少一个，重复n-1次，完成排序。
#include
void Insert_sort(int* arr,int n) {//有多少个数需要插入
for (int i=1; i < n ; i++){
int j = i - 1;//有序数组的最后一个数
int temp = arr[i];//无序数组的第一个数
for (; j >= 0; j--) {
if (temp < arr[j]) {//判断temp的位置
arr[j + 1] = arr[j];//有序数组比它大的向后移动一位
}
else {
break;
}
}
arr[j + 1] = temp;//把temp赋值给第一个元素
}
}
int main() {
int arr[] = { 20,30,40,10,60,50 };
int n = sizeof(arr) / sizeof(int);
Insert_sort(arr, n);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
} 3.冒泡排序
第一步：从左到右，两两比较，将最大的数放在数组的最后一位(即下标n-1的位置)
第二步：采用相同的方法，再次遍历，将第二大的数,放在数组倒数第二的位置(即n-2的位置) ，以
此类推，直至数组有序。
#include
void Quick_sort(int* arr, int n) {
for (int i = 0; i < n-1; i++) {
for (int j = 0; j arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = { 20,30,40,10,60,50 };
int n = sizeof(arr) / sizeof(int);
Quick_sort(arr,n);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
} 优化:当数组在整个遍历过程中，没有发生交换,说明待排序数组已经是有序的了，此时可以直接结
束排序过程。
void bubblesort(int *arr, int n)
{
for (int i = 0; i < n; i++)
{
int flag = 0;
for (int j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j + 1] = temp;
flag = 1;
}
}
if (flag == 0)
{
break;
}
}
}4.快速排序
第一步：（三色旗问题）找到一个基准值（即为待排序数组中最左边的那个值），然后将待排序数组分为三步份，
第一部分：数据全部都小于基准值
第二部分：数据全都等于基准值
第三部分：数据全都大于基准值
C语言：
#include
#include
int *F(int arr[], int L, int R)
{
int i = L - 1;
int j = R + 1;
int index = L;
int temp = arr[L];
while (index < j)
{
if (arr[index] == temp)
{
index++;
}
else if (arr[index] >temp)
{
--j;
int p = arr[index];
arr[index] = arr[j];
arr[j] = p;
}
else
{
i++;
int p = arr[index];
arr[index] = arr[i];
arr[i] = p;
index++;
}
}
int *a = (int *)malloc(sizeof(int) * 2);
a[0] = i;
a[1] = j;
return a;
}
void Quick_sort(int *arr, int L, int R)
{
if (L >= R) return;
int *a = F(arr, L, R);
Quick_sort(arr, L, a[0]);
Quick_sort(arr, a[1], R);
}
int main() {
int arr[] = { 20,30,40,10,60,50,0 };
Quick_sort(arr, 0, 6);
for (int i = 0; i <= 6; i++) {
printf("%d ", arr[i]);
}
system("pause");
return 0;
} c++版本代码：
#include
#include
#include
using namespace std;
pair Quick(vector &vec, int L, int R)
{
int temp = vec[L];
int i = L - 1;
int j = R + 1;
int index = L;
while (index < j)
{
if (vec[index] < temp)
{
swap(vec[index++], vec[++i]);
}
else if (vec[index]>temp)
{
swap(vec[index], vec[--j]);
}
else
{
index++;
}
}
pair p = make_pair(i, j);
return p;
}
void Quicksort(vector&vec, int L, int R)
{
if (L >= R)return;
pair p = Quick(vec, L, R);
Quicksort(vec,L,p.first);
Quicksort(vec,R,p.second);
}
int main()
{
vector vec = { 5,4,3,7,6 };
Quicksort(vec, 0, vec.size() - 1);
for (auto it : vec)
{
cout << it << " ";
}
return 0;
} 5.桶排序：
将待排序数组中的数作为桶号，遍历整个数组，将桶进行计数
第一步：遍历数组找到最大值max，申请max+1个桶，初始化为0，下标从0--max，
第二步：遍历原数组，找到每个数值对应的桶号，并对桶计数，即bucket[a[i]]++;
第三步：遍历桶数组，看对应的桶内计数为几就取出几个下标值，放到原数组中
#include
#include
void Bucket_Sort(int *arr, int n) {
int max = arr[0];//创建桶，桶的第一个数是arr中最大值加1
for (int i = 1; i < n; i++) {
max = max < arr[i] ? arr[i] : max;
}
int *bucket = (int *)malloc((max + 1) * sizeof(int));
memset(bucket, 0, sizeof(int)*(max + 1));
//遍历arr，将arr中元素在桶中计数
for (int i = 0; i < n; i++)
{
bucket[arr[i]]++;
}
int j = 0;
for (int i = 0; i < max + 1; i++) {
while (bucket[i] > 0) {
arr[j++] = i;
bucket[i]--;
}
}
}
int main() {
int arr[] = { 20,30,40,10,60,50 };
int n = sizeof(arr) / sizeof(int);
Bucket_Sort(arr, n);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
} 6.堆排序
第一步：将待排序数组形象成一个堆结构，并将其调整为最大堆（左孩子的下标是2*i+1,右孩子下标是2*i+2）
第二步：将堆顶元素与与待排序数组最后一个元素进行交换
第三步：待排序数据量减少一个，将待排序数组重新调整为最大堆结构，重复第二步，循环n-1次
c++版本代码：
#include
#include
#include
using namespace std;
void adjust_head(vector& vec, int start, int end)
{
int father = start;
int child = father*2+1;
while (child <= end)
{
if (child + 1 <= end && vec[child] < vec[child + 1])
{
child++;
}
if (vec[child] > vec[father])
{
swap(vec[child], vec[father]);
}
father = child;
child = father * 2 + 1;
}
}
void Head_sort(vector& vec)
{
int n = vec.size();
for (int i = n / 2 - 1; i >= 0; i--)
{
adjust_head(vec, i, n - 1);
}
for (int i = n - 1; i >= 0; i--)
{
swap(vec[0], vec[i]);
adjust_head(vec, 0, i - 1);
}
}
int main()
{
vector vec = { 1,5,4,3,7,6,1 };
Head_sort(vec);
for (auto it : vec)
{
cout << it << " ";
}
return 0;
} C语言版本代码：
#include
#include
#include
void adjust(int *arr, int start,int end) {
int father = start;
int child = father * 2 + 1;
while (child <= end) {
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child++;
}
if (arr[child] > arr[father]) {
int temp = arr[child];
arr[child] = arr[father];
arr[father] = temp;
}
father = child;
child = father * 2 + 1;
}
}
void Heap_Sort(int *arr, int n) {
//先调整最大堆
for (int i = n / 2 - 1; i >= 0; i--) {
adjust(arr, i, n - 1);
}
//
for (int i = n - 1; i >= 0; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
adjust(arr, 0, i - 1);
}
}
int main() {
int arr[] = { 20,30,40,10,60,50 };
int n = sizeof(arr) / sizeof(int);
Heap_Sort(arr, n);
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
} 7.归并排序
思想：将两个有序数组合并成一个有序数组
第一步：将数组进行分解，当分解成单个元素为一组的时候才为有序数组
第二步：将两个有序数组进行合并成一个有序数组，重复第二步，直到排序完成
C语言：
#include
#include
void Merg(int *arr, int L, int mid, int R)
{
int *temp = (int *)malloc(sizeof(int)*(R - L + 1));
int i = L;
int j = mid + 1;
int index = 0;
while (i <= mid && j <= R)
{
if (arr[i] < arr[j])
{
temp[index++] = arr[i++];
}
else
{
temp[index++] = arr[j++];
}
while (i <= mid)
{
temp[index++] = arr[i++];
}
while (j <= R)
{
temp[index++] = arr[j++];
}
index = L;
for (int i = 0; i < (R - L + 1); i++)
{
arr[index++] = temp[i];
}
}
}
void Merg_Sort(int *arr, int L, int R)
{
if (L >= R)return;
int mid = (L + R) / 2;
Merg_Sort(arr, L, mid);
Merg_Sort(arr, mid + 1, R);
Merg(arr, L, mid, R);
}
int main() {
int arr[] = { 20,30,40,10,60,50,1 };
Merg_Sort(arr, 0, 6);
for (int i = 0; i <= 6; i++) {
printf("%d ", arr[i]);
}
return 0;
} c++版本代码：
#include
#include
#include
#include
using namespace std;
void Merg(vector &vec, int L, int mid, int R)
{
vector temp(R - L + 1);
int i = L, j = mid+1, index = 0;
while (i <= mid && j <= R)
{
if (vec[i] > vec[j])
{
temp[index++] = vec[j++];
}
else
{
temp[index++] = vec[i++];
}
}
while (i <= mid)
{
temp[index++] = vec[i++];
}
while (j <= R)
{
temp[index++] = vec[j++];
}
index = L;
for (int i = 0; i < (R - L + 1); i++)
{
vec[index++] = temp[i];
}
}
void MergSort(vector &vec, int L, int R)
{
if (L >= R)return;
int mid = (L + R) / 2;
MergSort(vec, L, mid);
MergSort(vec, mid + 1, R);
Merg(vec, L, mid, R);
}
int main()
{
vector vec = { 2,3,4,1,4,5 };
MergSort(vec, 0, vec.size()-1);
for (auto it : vec)
{
cout << it << " ";
}
return 0;
}