总结快速排序、归并排序、堆排序、计数排序、桶排序、基数排序、插入排序、冒泡排序、希尔排序、选择排序的基本思想以及实现。
一、快速排序
1.1 基本思想
- 分解：数组A[p…r]被划分为两个子数组A[p…q-1和A[q+1，r]，使得A[q]为大小居中的数，左侧A[A…q-1]中每一个元素都小于等于它，而右侧A[q+1，r]中每个元素都大于等于它。其中计算下表q也是划分过程的一部分。
- 解决：通过递归调用快速排序，对子数组A[p…q-1]和A[q+1,r]进行排序
- 合并：因为子数组都是用原址排序的，所以不需要合并，数组A已经有序
1.2 代码实现
#include <iostream>
#include <algorithm>
#include <ctime>
using namespace std;
void randArray(int m[], int n)//随机生成n个数的数组
{
srand(unsigned(time(NULL)));
for (int i = 0; i < n; i++)
m[i] = rand() % 100;
}
int partition(int *arr, int low, int high)//一维单向扫描法
{
int pivot = arr[low];
int sp = low + 1;
while (sp <= high)
{
if (arr[sp] <= pivot)
sp++;
else
swap(arr[sp], arr[high--]);
}
swap(arr[low], arr[high]);
return high;
}
int partitionTwo(int *arr, int low, int high)//双向扫描法
{
int pivot = low++;
while (low <= high)
{
while (low <= high && arr[high] > arr[pivot])
high--;
while (low <= high && arr[low] <= arr[pivot])
low++;
if (low < high)
swap(arr[low], arr[high]);
}
swap(arr[pivot], arr[high]);
return high;
}
void QuickSort(int *arr, int low, int high)
{
if (low < high)
{
int q = partitionTwo(arr, low, high);
QuickSort(arr, low, q - 1);
QuickSort(arr, q + 1, high);
}
}
void partitionThree(int *arr, int low, int high, int &p1, int &p2)//三分法
{
int pivot = low++;
int mid = low;
while (low <= high)
{
if (arr[pivot] > arr[low])
swap(arr[low++], arr[mid++]);
else if (arr[pivot] == arr[low])
low++;
else
swap(arr[low], arr[high--]);
}
swap(arr[mid - 1], arr[pivot]);
p1 = mid - 1;
p2 = high;
}
void QuickSortThree(int *arr, int low, int high)
{
if (low < high)
{
int p1, p2;
partitionThree(arr, low, high, p1, p2);
QuickSortThree(arr, low, p1);
QuickSortThree(arr, p2 + 1, high);
}
}
int main()
{
int n;
cin >> n;
int *m;
m = new int(n);
randArray(m, n);
for (int i = 0; i < n; i++)
cout << m[i] << " ";
cout << endl;
// QuickSort(m, 0, n - 1);
QuickSortThree(m, 0, n - 1);
for (int i = 0; i < n; i++)
cout << m[i] << " ";
cout << endl;
return 0;
}
二、归并排序
2.1 基本思想
- 分解：将n个元素分解成各含n/2个元素的子序列；
- 解决：对两个子序列递归的排序；
- 合并：合并两个已排序的子序列得到排序结果。
2.2 代码实现
#include <iostream>
#include <ctime>
using namespace std;
void randArray(int m[], int n)
{
srand(unsigned(time(NULL)));
for (int i = 0; i < n; i++)
m[i] = rand() % 100;
}
void merge(int *a, int start, int mid, int end)
{
int *tmp = new int[end - start + 1]; // tmp是汇总2个有序区的临时区域
int i = start; // 第1个有序区的索引
int j = mid + 1; // 第2个有序区的索引
int k = 0; // 临时区域的索引
while (i <= mid && j <= end)
{
if (a[i] <= a[j])
tmp[k++] = a[i++];
else
tmp[k++] = a[j++];
}
while (i <= mid)
tmp[k++] = a[i++];
while (j <= end)
tmp[k++] = a[j++];
for (i = 0; i < k; i++)
a[start + i] = tmp[i];
delete[] tmp;
}
void mergeSortUp2Down(int *a, int start, int end)
{
if (a == NULL || start >= end)
return;
int mid = (end + start) / 2;
mergeSortUp2Down(a, start, mid); // 递归排序a[start...mid]
mergeSortUp2Down(a, mid + 1, end); // 递归排序a[mid+1...end]
merge(a, start, mid, end);
}
int main()
{
int i;
int *a;
int ilen;
cin>>ilen;
randArray(a,ilen);
cout << "before sort:";
for (i = 0; i < ilen; i++)
cout << a[i] << " ";
cout << endl;
mergeSortUp2Down(a, 0, ilen - 1); // 归并排序(从上往下)
cout << "after sort:";
for (i = 0; i < ilen; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
三、堆排序
3.1 基本思想
- 堆化：反向调整使得每个子树都是大顶堆或者小顶堆。
- 按序输出元素：把堆顶和最末的元素对调，然后调整堆顶元素。
3.2 代码实现
#include <iostream>
#include <algorithm>
#include <ctime>
using namespace std;
void randArray(int m[], int n)
{
srand(unsigned(time(NULL)));
for (int i = 0; i < n; i++)
m[i] = rand() % 100;
}
void MinHeapFixdown(int *arr, int i, int n)
{
//找到左右孩子
int left = 2 * i + 1;
int right = 2 * i + 2;
//查看是否超出边界
if (left >= n)
return;
//寻找最小值
int min = left;
if (right < n && arr[left] > arr[right])
min = right;
//查看是否比节点小
if (arr[i] <= arr[min])
return;
//交换最小的节点
swap(arr[i], arr[min]);
MinHeapFixdown(arr, min, n);
}
void sort(int *arr, int n)
{
//首先进行堆化
for (int i = n / 2 - 1; i >= 0; i--)
MinHeapFixdown(arr, i, n);
for (int i = n - 1; i >= 0; i--)
{
//把堆顶元素和最后一个元素对调。
swap(arr[i], arr[0]);
//缩小堆的范围，对堆顶元素进行向下调整。
MinHeapFixdown(arr, 0, i);
}
}
int main()
{
int n;
cin >> n;
int *num = (int *)malloc(sizeof(int) * n);
randArray(num, n);
cout << "sort again: ";
for (int i = 0; i < n; i++)
cout << num[i] << " ";
cout << endl;
sort(num, n);
cout << "sort end: ";
for (int i = 0; i < n; i++)
cout << num[i] << " ";
cout << endl;
return 0;
}
四、计数排序
4.1 基本思想
用辅助数组对数组中出现的数字计数，元素转下标，下标转元素。假设元素均大于0，依次扫描原数组，将元素值k记录在辅助数组的第K位上，依次扫描辅助数组，如果为1，将其插入目标数组的空白处。
4.2 代码实现
#include <iostream>
#include <vector>
using namespace std;
void CountSort(vector<int> &arr, int maxVal) {
int len = arr.size();
if (len < 1)
return;
vector<int> count(maxVal+1, 0);
vector<int> tmp(arr);
for (auto x : arr)
count[x]++;
for (int i = 1; i <= maxVal; ++i)
count[i] += count[i - 1];
for (int i = len - 1; i >= 0; --i) {
arr[count[tmp[i]] - 1] = tmp[i];
count[tmp[i]]--;
}
}
int main()
{
vector<int> arr = { 1,5,3,7,6,2,8,9,4,3,3 };
int maxVal = 9;
CountSort(arr,maxVal);
for (auto x : arr)
cout << x << " ";
cout << endl;
return 0;
}
五、桶排序
5.1 基本思想
设计K个桶（编号0——k-1），然后将n个输入数分布到各个桶中去，对各个桶中的个数进行排序，然后按照次序吧各个桶中的元素列出来即可。
5.2 代码实现
#include <iostream>
#include <algorithm>
#include <list>
#include <vector>
#include <ctime>
using namespace std;
int randArray(int m[], int n)
{
int max_vlaue = -1;
srand(unsigned(time(NULL)));
for (int i = 0; i < n; i++)
{
m[i] = rand() % 100;
if (m[i] > max_vlaue)
max_vlaue = m[i];
}
return max_vlaue;
}
void sort(int *arr, int n, int max)
{
list<int> L[105];
for (int i = 0; i < n; i++)
{
int j = arr[i] * n / (max + 1);
auto iter = L[j].begin();
while (iter != L[j].end() && arr[i] >= *iter)
++iter;
L[j].insert(iter, arr[i]);
}
cout << "sort end: ";
for (int i = 0; i < n; i++)
{
for (list<int>::iterator iter = L[i].begin(); iter != L[i].end(); iter++)
cout << *iter << " ";
}
}
int main()
{
int n;
cin >> n;
int *num = (int *)malloc(sizeof(int) * n);
int max = randArray(num, n);
cout << "sort again: ";
for (int i = 0; i < n; i++)
cout << num[i] << " ";
cout << endl;
sort(num, n, max);
return 0;
}
六、基数排序
6.1 基本思想
是一种特殊的桶排序，首先按低位有效数字进行排序，然后逐次向上一位进行排序，知道最高位的排序结果。
6.2 代码实现
#include <bits/stdc++.h>
using namespace std;
void printArray(int array[],int length)
{
for (int i = 0; i < length; ++i)
{
cout << array[i] << " ";
}
cout << endl;
}
int maxbit(int data[], int n)
{
int d = 1;
int p = 10;
for(int i = 0; i < n; ++i)
{
while(data[i] >= p)
{
p *= 10;
++d;
}
}
return d;
}
void radixsort(int data[], int n) //基数排序
{
int d = maxbit(data, n);
int tmp[n];
int count[10];
int i, j, k;
int radix = 1;
for(i = 1; i <= d; i++)
{
for(j = 0; j < 10; j++)
count[j] = 0;
for(j = 0; j < n; j++)
{
k = (data[j] / radix) % 10;
count[k]++;
}
for(j = 1; j < 10; j++)
count[j] = count[j - 1] + count[j];
for(j = n - 1; j >= 0; j--)
{
k = (data[j] / radix) % 10;
tmp[count[k] - 1] = data[j];
count[k]--;
}
for(j = 0; j < n; j++)
data[j] = tmp[j];
radix = radix * 10;
}
}
int main()
{
srand(time(NULL));
int n;
cin>>n;
int arr[n];
cout<<"Before ordering of data for:"<<endl;
for(int i=0;i<n;i++)
{
arr[i] = rand()%50;
cout<<arr[i]<<" ";
}
cout<<endl<<"Sorted data:"<<endl;
radixsort(arr,10);
printArray(arr,10);
return 0;
}
七、插入排序
7.1 基本思想
将开头的元素视为已经排好序，执行以下操作：
- 取出未排序的开头部分元素赋值给变量x 在已排序的部分，
- 将所有比x大或小的数据往后移动一个单位
- 将以取出的数据x插入空位
7.2代码实现
#include <iostream>
#include <ctime>
using namespace std;
void sort(int arr[],int k)
{
if(k == 0)
return;
//对前k-1个元素进行排序
sort(arr,k-1);
//把位置k的元素插入到前面的部分
int x = arr[k];
int index = k-1;
while(index >= 0 && arr[index] > x)
{
arr[index+1] = arr[index];
index--;
}
arr[index+1] = x;
}
int main()
{
srand(time(NULL));
int n;
cin>>n;
int arr[n];
cout<<"Before ordering of data for:"<<endl;
for(int i=0;i<n;i++)
{
arr[i] = rand()%50;
cout<<arr[i]<<" ";
}
sort(arr,n);
cout<<endl<<"Sorted data:"<<endl;
for(int i = 0;i<n;i++)
cout<<arr[i]<<" ";
return 0;
}
八、冒泡排序
8.1 基本思想
第一趟，通过两两交换的手段，将最大元素顶到最末端
第二趟，…………………………………………，将次大元素顶到倒数第二个位置
…
8.2 代码实现
#include <iostream>
#include <algorithm>
#include <ctime>
using namespace std;
void randArray(int m[], int n) //随机生成n个数的数组
{
srand(unsigned(time(NULL)));
for (int i = 0; i < n; i++)
m[i] = rand() % 100;
}
void sort(int *arr,int n)
{
for (int j = 0; j < n; j++)
{
//标记这一趟是不是有交换，如果没有交换，顺序就已经排好了
bool ordered = true;
//注意上边界，泡都从第一个开始冒，但是每一趟完成之后，天花板在降低
for (int i = 0; i < n - j - 1; i++)
{
if (arr[i] > arr[i + 1])
{
swap(arr[i],arr[i + 1]);
ordered = false;
}
}
if (ordered)
{
break;
}
}
}
int main()
{
int n;
cin >> n;
int *m;
m = new int(n);
randArray(m, n);
for (int i = 0; i < n; i++)
cout << m[i] << " ";
cout << endl;
sort(m,n);
for (int i = 0; i < n; i++)
cout << m[i] << " ";
cout << endl;
return 0;
}
九、希尔排序
9.1 基本思想
也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法
9.2 代码实现
#include<iostream>
using namespace std;
const int INCRGAP = 2;
void shellSort(int a[],int len)
{
int insertNum = 0;
unsigned gap = len/INCRGAP; // 步长初始化
while(gap) // while gap>=1
{
for (unsigned i = gap; i < len; ++i) // 分组，在每个子序列中进行插入排序
{
insertNum = a[i];//将当前的元素值先存起来方便后面插入
unsigned j = i;
while (j >= gap && insertNum < a[j-gap])//寻找插入位置
{
a[j] = a[j - gap];
j -= gap;
}
a[j] = insertNum;
}
gap = gap/INCRGAP;
}
}
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;
}
十、选择排序
10.1 基本思想
重复执行N-1次以下操作
- 找出未排序部分最小值的位置minx。
- 将minx位置的元素与未排序部分的起始元素交换。
10.2 代码实现
#include <bits/stdc++.h>
using namespace std;
void sort(int arr[],int n)
{
for(int i = 0;i<n;i++){
int minx = i;
for(int j = i;j<n;j++)
if(arr[minx]>arr[j])
minx = j;
swap(arr[minx],arr[i]);
}
}
int main()
{
srand(time(NULL));
int n;
cin>>n;
int arr[n];
cout<<"sort begin:"<<endl;
for (int i = 0; i < n; i++)
{
arr[i] = rand()%50;
cout<<arr[i]<<" ";
}
sort(arr,n);
cout<<endl<<"sort end:"<<endl;
for(int i = 0;i<n;i++)
cout<<arr[i]<<" ";
return 0;
}
703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
