冒泡排序
template<typename T>
//整数或浮点数皆可使用
void bubble_sort(T arr[], int len)
{
int i, j; T temp;
for (i = 0; i < len - 1; i++) {
bool flag = false;
for (j = 0; j < len - 1 -i; j++) {
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = true;
}
}
if (flag == true)
break; // 剪枝操作
}
}
int main()
{
int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
int len = (int) sizeof(arr) / sizeof(*arr);
bubble_sort(arr, len);
for (int i = 0; i < len; i++)
cout << arr[i] << ' ';
cout << endl;
float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
len = (int) sizeof(arrf) / sizeof(*arrf);
bubble_sort(arrf, len);
for (int i = 0; i < len; i++)
cout << arrf[i] << ' ';
}
快排
快排1
#include <iostream>
using namespace std;
void Qsort(int arr[], int low, int high){
if (high <= low) return;
int i = low ;
int j = high + 1 ;
int key = arr[low];
while (true)
{
/*从左向右找比key大的值*/
// i = 8;
// ++i = 9; arr[++i] < key 这个条件符合 i = 9
//question : 如果
while (arr[++i] < key)
{
if (i == high){
break;
}
}
/*从右向左找比key小的值*/
while (arr[--j] > key)
{
if (j == low){
break;
}
}
if (i > j) break;
/*交换i,j对应的值*/
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/*中枢值与j对应值交换*/
int temp = arr[low];
arr[low] = arr[j];
arr[j] = temp;
Qsort(arr, low, j - 1);
Qsort(arr, j + 1, high);
}
int main()
{
int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};
/*
low high
57, 24, 59, 52, 72, 28, 96, 33, 68
i j
57, 24, 33, 52, 72, 28, 96, 59, 68
i j
57, 24, 33, 52, 28, 72, 96, 59, 68
i j
57, 24, 33, 52, 28, 72, 96, 59, 68
j i i丛左向右搜索找到合适的大于key值的a[i] ,j从右向左检索到合适的大于key值的a[j]
但是i > j ,导致a[i] 与 a[j] 不会引起交换，而且这次分类结束，break 跳出while
循环。
28, 24, 33, 52, 57, 72, 96, 59, 68
j i a[low] 和 a[j] 换一下位置
*/
Qsort(a, 0, sizeof(a) / sizeof(a[0]) - 1);/*这里原文第三个参数要减1否则内存越界*/
for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
cout << a[i] << " ";
}
system("pause");
}/*参考数据结构p274(清华大学出版社，严蔚敏)*/
快排2
#include<vector>
#include<iostream>
using namespace std;
//快速排序（从小到大）
void quickSort(int left, int right, vector<int>& arr )
{
if (left >= right)
return;
int i, j, base, temp;
i = left, j = right;
base = arr[left]; //取最左边的数为基准数
while (i < j)
{
// 顺序不能颠倒
while (arr[j] >= base && i < j)
j--;
while (arr[i] <= base && i < j)
i++;
if (i < j)
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//基准数归位
arr[left] = arr[j];
arr[j] = base;
quickSort(left, j - 1, arr);//递归左边
quickSort(j + 1, right, arr);//递归右边
}
举个例子 7 0 1 2 10 11 22 key取7你让i先++的话i就会走到10最后key归位的时候就会交换10和7
int main() {
vector<int> arr = { 4,2,7,36,743,23,47,3,23,33,7,33 };
int length = arr.size();
quickSort(0, length-1, arr);
for (auto num : arr)
cout << num << " ";
cout << endl;
return 0;
}
归并排序
void MergeSort (int arr [], int low,int high) {
if(low>=high) { return; } // 终止递归的条件，子序列长度为1
int mid = low + (high - low)/2; // 取得序列中间的元素
MergeSort(arr,low,mid); // 对左半边递归
MergeSort(arr,mid+1,high); // 对右半边递归
merge(arr,low,mid,high); // 合并
}
void Merge(int arr[],int low,int mid,int high) {
//low为第1有序区的第1个元素，i指向第1个元素, mid为第1有序区的最后1个元素
int i=low,j=mid+1,k=0; //mid+1为第2有序区第1个元素，j指向第1个元素
int *temp=new int[high-low+1]; //temp数组暂存合并的有序序列
while(i<=mid&&j<=high){
if(arr[i]<=arr[j]) //较小的先存入temp中
temp[k++]=arr[i++];
else
temp[k++]=arr[j++];
}
while(i<=mid)//若比较完之后，第一个有序区仍有剩余，则直接复制到t数组中
temp[k++]=arr[i++];
while(j<=high)//同上
temp[k++]=arr[j++];
for(i=low,k=0;i<=high;i++,k++)//将排好序的存回arr中low到high这区间
arr[i]=temp[k];
delete []temp;//释放内存，由于指向的是数组，必须用delete []
}
插入排序
#include<iostream>
#include<cstdlib>
using namespace std;
//交换数组元素位置位置
void swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
/*
插入排序。注意，若后面一个元素比其前面一个元素小，则将这两个元素交换位置，然后再来比较这个插入元素与前面一个元素的大小，若小，则还需要交换这两个元素位置，一直到这个插入元素在正确的位置为止
*/
void insertSort(int a[], int length)
{
for (int i = 1; i < length; i++)
{
for (int j = i - 1; j >= 0 && a[j + 1] < a[j]; j--)
{
swap(a[j], a[j + 1]);
}
}
}
int main()
{
int a[] = { 2,1,4,5,3,8,7,9,0,6 };
insertSort(a, 10);
for (int i = 0; i < 10; i++)
{
cout << a[i] << "";
}
cout << endl;
system("pause");
return 0;
}
shell 排序
#include<iostream>
using namespace std;
const int INCRGAP = 3;
void shellsort1(int a[], int n)
{
int i, j, gap;
for (gap = n / 2; gap > 0; gap /= 2) //步长
for (i = 0; i < gap; i++) //直接插入排序
{
for (j = i + gap; j < n; j += gap)
if (a[j] < a[j - gap])
{
int temp = a[j];
int k = j - gap;
while (k >= 0 && a[k] > temp)
{
a[k + gap] = a[k];
k -= gap;
}
a[k + gap] = temp;
}
}
}
int main()
{
int array[11] = {2, 1, 4, 3, 11, 6, 5, 7, 8, 10, 15};
shellSort(array, 11);
for(auto it: array)
{
cout<<it<<endl;
}
return 0;
}
堆排
#include <iostream>
#include <algorithm>
using namespace std;
void max_heapify(int arr[], int start, int end) {
int dad = start; int son = dad * 2 + 1;
while ( son <= end ){
if (son + 1 <= end && arr[son] < arr[son+1]){
son++;
}
if (arr[dad] > arr[son]){
return;
} else {
swap(arr[dad], arr[son]);
dad = son;
son = dad * 2 + 1;
}
}
}
void heap_sort(int arr[], int length){
for(int i = length / 2 - 1; i >= 0; i--){
max_heapify(arr, i, length-1); // 这样的话是大堆顶
}
for(int i = length - 1; i >= 0; i--){
swap(arr[0], arr[i]);
max_heapify(arr,0,i-1);
}
}
int main(){
int arr[] = { 4,6,1,32,56,7,2,3,5,3};
int length = sizeof(arr) / sizeof(*arr);
heap_sort(arr, length);
for(int i = 0; i < length; i++){
cout << arr[i] << " ";
}
system("pause");
return 0;
}
