本篇博客实现了 1.冒泡排序 2.冒泡排序的一种优化(当某次冒泡没有进行交换时，退出循环) 3.选择排序 4.归并排序 5.快速排序。
主要是源码的实现，并将自己在敲的过程中所遇到的一些问题记录下来。
全局定义与相关声明：
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int num[100005]; //存储数组
void swap1(int i, int j) //交换函数swap
{
int t = num[i];
num[i] = num[j];
num[j] = t;
}
/*Printnum 输出*/
void Printnum(int n) //输出排序完成的数组
{
for (int i = 1; i <= n; i++) {
cout << num[i] << " ";
}
cout << endl;
}
1.冒泡排序
/*Bubble_Sort 冒泡排序*/
void Bubble_Sort(int n)
{
int i, j;
for (i = 1; i <= n; i++) //遍历n次
{
for (j = 1; j <= n-i; j++) //每次都把最大数往后排，缩小范围
{
if (num[j] > num[j+1])
{
swap1(j, j+1);
}
}
}
}冒泡的思想：不断把范围中的最大数往后排，排完之后缩小范围；以上过程执行n次。
个人小结：思想很简单，但是太久不碰真的会忘记。
2.冒泡排序的优化
void Bubble_Sort_Better(int n)
{
int i, j;
for (i = 1; i <= n; i++)
{
bool flag = true;
for (j = 1; j <= n-i; j++)
{
if (num[j] > num[j+1])
{
flag = false;
swap1(j, j+1);
}
}
if (flag) break; //某一次遍历没有发生交换时，结束
}
}优化的思想：当某一次冒泡没有交换任何数时，则说明当前范围内序列有序，结束循环。
3.选择排序
/*Selection_Sort 选择排序*/
void Selection_Sort(int n)
{
int i, j;
int rcd;
for (i = 1; i <= n; i++)
{
rcd = i;
for (j = i+1; j <= n; j++)
{
if (num[j] < num[rcd]) //找出i+1=>n范围内的最小元并前移
{
rcd = j;
}
}
swap1(i, rcd);
}
}思想：找出范围i => n内最小的数，用rcd(初始化为i)记录其位置，之后与寻找范围内的第一个数num[i]进行交换，保证i+1 => n的所有数均大于num[i]。
4.归并排序：
/*Merge_Sort 归并排序*/
int temp[100005];
void Merge_Array(int l1, int r1, int l2, int r2)
{
int p1 = l1;
int p2 = l2;
int i = 1;
memset(temp, 0, sizeof(temp));
for (i = l1; i <= r2; i++)
{
if (p1 > r1)
{
temp[i] = num[p2++];
continue;
}
if (p2 > r2)
{
temp[i] = num[p1++];
continue;
}
if (num[p1] < num[p2])
{
temp[i] = num[p1++];
continue;
}
else
{
temp[i] = num[p2++];
continue;
}
}
for (i = l1; i <= r2; i++)
{
num[i] = temp[i];
}
}
void Merge_Sort(int l, int r)
{
if (l < r)
{
int mid = (l+r)/2;
Merge_Sort(l, mid); //l => mid
Merge_Sort(mid+1, r); //mid+1 => r
Merge_Array(l, mid, mid+1, r); //l => mid => mid+1 => r
}
}思想可以参考：白话经典算法系列之五 归并排序的实现
大概的思路是，先并后归，将范围二分，分别递归排序之后再进行合并(利用一个额外的数组temp)。
个人小结：
1.看似简单，实现起来总是会出问题；动手吧。
2.一定要注意：递归选取的范围，取了mid = (l+r)/2之后，左边的一半范围为[l => mid]，右边的一半范围为[mid+1 => r]。原因可以考虑以下情况：两个数3 1进行排序，mid = 1，如果选取的范围为[l => mid-1]和mid => r，则会出现死循环。
5.QuickSort快速排序
int Quick_Sort_Adjust(int l, int r)
{
int key = l; //选取第一个元素为基准值
int a, b;
a = l+1;
b = r;
while (a < b)
{
bool out_bound = false;
while (1)
{
if (num[a] > num[key]) break;
a++;
if (a > r)
{
out_bound = true;
break;
}
}
while (1)
{
if (num[b] < num[key]) break;
b--;
if (b < l)
{
out_bound = true;
break;
}
}
if (out_bound || a >= b) break; //如果出现越界或a>=b直接结束
swap1(a, b);
a++;
b--;
}
swap1(key, a-1);
return a-1;
}
void Quick_Sort(int l, int r)
{
if (l < r)
{
int mid = Quick_Sort_Adjust(l, r);
Quick_Sort(l, mid-1); //l => mid-1
Quick_Sort(mid+1, r); //mid+1 => r
}
}思想可以参考：白话经典算法系列之六 快速排序 快速搞定
思路上文讲的很清楚了，建议在纸上模拟以下四种情况：
1.n = 7
1 3 1 2 -1 8 9
2.n = 7
1 1 1 1 1 1 1
3.n = 7
7 6 5 4 3 2 1
4.n = 7
7 1 1 1 1 1 1个人小结：
1.同样的，自己敲一遍能够发现一堆问题。
2.一定要注意，当出现以下两种情况时：(1)i>j(这里的代码是a>b) (2)i、j越界 应该立即退出循环。
3.递归范围的选择，在基准值num[key]和num[mid]交换之后，接下来的递归范围应该为[l => mid-1]和[mid+1 => r]，因为[l => mid-1]范围内的所有值都小于num[mid]，[mid+1 => r]内的所有值都大于num[mid]；如果选取范围对mid取等，会出现上文中两个数(如 3 1)的死循环。
4.这里选择的基准是第一个数，快速排序还有很多改进版本，如随机选择基准数，区间内数据较少时直接用别的方法排序以减小递归深度。
完整代码如下：
//
// main.cpp
// Sort
//
// Created by wasdns on 16/12/25.
// Copyright © 2016年 wasdns. All rights reserved.
//
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
/*存储数组定义*/
int num[100005];
void swap1(int i, int j)
{
int t = num[i];
num[i] = num[j];
num[j] = t;
}
/*Printnum 输出*/
void Printnum(int n)
{
for (int i = 1; i <= n; i++) {
cout << num[i] << " ";
}
cout << endl;
}
/*Bubble_Sort 冒泡排序*/
void Bubble_Sort(int n)
{
int i, j;
for (i = 1; i <= n; i++) //遍历n次
{
for (j = 1; j <= n-i; j++) //每次都把最大数往后排，缩小范围
{
if (num[j] > num[j+1])
{
swap1(j, j+1);
}
}
}
}
void Bubble_Sort_Better(int n)
{
int i, j;
for (i = 1; i <= n; i++)
{
bool flag = true;
for (j = 1; j <= n-i; j++)
{
if (num[j] > num[j+1])
{
flag = false;
swap1(j, j+1);
}
}
if (flag) break; //某一次遍历没有发生交换时，结束
}
}
/*Selection_Sort 选择排序*/
void Selection_Sort(int n)
{
int i, j;
int rcd;
for (i = 1; i <= n; i++)
{
rcd = i;
for (j = i+1; j <= n; j++)
{
if (num[j] < num[rcd]) //找出i+1=>n范围内的最小元并前移
{
rcd = j;
}
}
swap1(i, rcd);
}
}
/*Merge_Sort 归并排序*/
int temp[100005];
void Merge_Array(int l1, int r1, int l2, int r2)
{
int p1 = l1;
int p2 = l2;
int i = 1;
memset(temp, 0, sizeof(temp));
for (i = l1; i <= r2; i++)
{
if (p1 > r1)
{
temp[i] = num[p2++];
continue;
}
if (p2 > r2)
{
temp[i] = num[p1++];
continue;
}
if (num[p1] < num[p2])
{
temp[i] = num[p1++];
continue;
}
else
{
temp[i] = num[p2++];
continue;
}
}
for (i = l1; i <= r2; i++)
{
num[i] = temp[i];
}
}
void Merge_Sort(int l, int r)
{
if (l < r)
{
int mid = (l+r)/2;
Merge_Sort(l, mid); //l => mid
Merge_Sort(mid+1, r); //mid+1 => r
Merge_Array(l, mid, mid+1, r); //l => mid => mid+1 => r
}
}
/*Quick_Sort 快速排序*/
int Quick_Sort_Adjust(int l, int r)
{
int key = l; //选取第一个元素为基准值
int a, b;
a = l+1;
b = r;
while (a < b)
{
bool out_bound = false;
while (1)
{
if (num[a] > num[key]) break;
a++;
if (a > r)
{
out_bound = true;
break;
}
}
while (1)
{
if (num[b] < num[key]) break;
b--;
if (b < l)
{
out_bound = true;
break;
}
}
if (out_bound || a >= b) break; //如果出现越界或a>=b直接结束
swap1(a, b);
a++;
b--;
}
swap1(key, a-1);
return a-1;
}
void Quick_Sort(int l, int r)
{
if (l < r)
{
int mid = Quick_Sort_Adjust(l, r);
Quick_Sort(l, mid-1); //l => mid-1
Quick_Sort(mid+1, r); //mid+1 => r
}
}
int main()
{
int n;
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> num[i];
}
int option;
cin >> option;
if (option == 1)
{
cout << "Bubble_Sort" << endl;
Bubble_Sort(n);
}
else if (option == 2)
{
cout << "Bubble_Sort_Better" << endl;
Bubble_Sort_Better(n);
}
else if (option == 3)
{
cout << "Selection_Sort" << endl;
Selection_Sort(n);
}
else if (option == 4)
{
cout << "Merge_Sort" << endl;
Merge_Sort(1, n);
}
else if (option == 5)
{
cout << "Quick_Sort" << endl;
Quick_Sort(1, n);
}
Printnum(n);
return 0;
}
2016/12/26
837
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
