今天开始复习数据结构,首当其冲的自然是面试必备的八大排序!因为博主之前复习过很多次了,所以这次就直接贴代码了。
插入排序
void insertionSort(){
for(int i = 1; i < n; ++i){
int j = i, t = arr[i];
while(j > 0 && t < arr[j-1]){
arr[j] = arr[j-1];
j -= 1;
}
arr[j] = t;
}
}
选择排序
void selectionSort(){
for(int i = 0; i < n-1; ++i){
int rec = i;
for(int j = i+1; j < n; ++j){
if(arr[j] < arr[rec])
rec = j;
}
if(rec != i)
swap(arr[rec], arr[i]);
}
}
冒泡排序
void bubbleSort(){
bool flag = 1;
for(int i = 0; flag; ++i){ //表示交换的趟数
flag = 0;
for(int j = 0; j < n-i-1; ++j){
if(arr[j] > arr[j+1]) {
swap(arr[j], arr[j + 1]);
flag = 1;
}
}
}
}
快速排序
int partition(int l, int r){
int x = l;
for(int i = l; i < r; ++i){
if(arr[i] < arr[r])
swap(arr[x++], arr[i]);
}
swap(arr[x], arr[r]);
return x;
}
void quickSort(int l, int r){
if(l >= r)
return;
int x = partition(l, r);
quickSort(l, x-1);
quickSort(x+1, r);
}
int main(){
quickSort(0, n-1);
}
希尔排序
- 一般选择 g n + 1 = 3 g n + 1 g_{n+1} = 3g_n + 1 gn+1=3gn+1 的 g a p gap gap 数列
- 使用上述 g a p gap gap,希尔排序的时间复杂度基本维持在 O ( n 1.25 ) O(n^{1.25}) O(n1.25) 左右
void insertionSort(int g){
for(int i = g; i < n; ++i){
int j = i, t = arr[i];
while(j > 0 && t < arr[j-g]){
arr[j] = arr[j-g];
j -= g;
}
arr[j] = t;
}
}
void shellSort(){
vector<int> gap;
int g = 1;
while(g < n) {
gap.push_back(g);
g = 3 * g + 1;
}
for(int i = gap.size()-1; i >= 0; --i){
insertionSort(gap[i]);
}
}
归并排序
- 归并排序的思想和快排的思想有些类似,区别在于:快排是将数组前后两部分分成大致有序后再进行递归,有自上而下的感觉;而归并则是先不断二分,分到每组只有一个元素后再合并,是自下而上变得有序的过程。
vector<int> L(n), R(n);
void merge(int l, int mid, int r){
int n1 = mid-l;
int n2 = r-mid;
for(int i = 0; i < n1; ++i){
L[i] = arr[l+i];
}
for(int i = 0; i < n2; ++i){
R[i] = arr[mid+i];
}
int i = 0, j = 0;
L[n1] = R[n2] = INT_MAX; // 因为L,R中的未填充部分为0,因此需要设置标志位,代表终点
for(int k = l; k < r; ++k){
if(L[i] < R[j])
arr[k] = L[i++];
else
arr[k] = R[j++];
}
}
void mergeSort(int left, int right){ //区间为[left, right)
if(left+1 < right){
int mid = (left + right) / 2;
mergeSort(left, mid);
mergeSort(mid, right);
merge(left, mid, right);
}
}
int main(){
mergeSort(0, n);
}
计数排序
- 思想有点类似于逆序对的思想,但是要注意稳定性以及部分细节
- 仅适用于 a r r [ i ] ≥ 0 arr[i] \ge 0 arr[i]≥0 的数组排序
void countingSort(int MAX){ // MAX为数组中的最大值
vector<int> C(MAX+1);
for(int t : arr){
C[t] += 1;
}
for(int i = 1; i <= MAX; ++i){ // 前缀和计算
C[i] += C[i-1];
}
for(int i = n-1; i >= 0; --i){ // 逆向计算 保证稳定性
ans[C[arr[i]]] = arr[i];
C[arr[i]] -= 1;
}
}
堆排序
- 堆排可以直接使用 p r i o r i t y _ q u e u e priority\_queue priority_queue 实现
- 实际上就是构建堆时的 s i f t _ u p sift\_up sift_up 和 p o p pop pop 后的 s i f t _ d o w n sift\_down sift_down 的实现