排序算法模板

目录

1.冒泡排序 

2.选择排序 

3.插入排序

4. 归并排序

5.快速排序 

6.堆排序 

---

1.冒泡排序 

算法步骤:比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#include <cstdio>
#include <iostream>
using namespace std;
void bubble_sort(int arr[], int len) {
    for (int i = 0; i < len - 1; i++) //这里i可以理解为后面冒泡确定好的数量，当确定好了len-2个再循环一次确认最后一个即可
    {
        for (int j = 0; j < len - i - 1; j++) //从0开始一直到len-i-1的是这次需要确认最大值数量
        {
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
        }
    }
}
int main() {
    int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
    int len = (int)sizeof(arr) / sizeof(*arr);
    bubble_sort(arr, len);
    int i;
    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);
    return 0;
}

2.选择排序 

算法步骤:

1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

3.重复第二步，直到所有元素均排序完毕。

#include <cstdio>
#include <iostream>
using namespace std;
void selection_sort(int arr[], int len) {
    for (int i = 0; i < len - 1; i++) 
    {
        int minidx = i;
        for (int j = i+1; j < len ; j++) {
            if (arr[minidx] > arr[j])
                minidx=j;
        }
        swap(arr[i], arr[minidx]);
    }
}
int main() {
    int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
    int len = (int)sizeof(arr) / sizeof(*arr);
    selection_sort(arr, len);
    int i;
    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);
    return 0;
}

3.插入排序

 算法步骤:

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

#include <cstdio>
#include <iostream>
using namespace std;
void insertion_sort(int arr[], int len) {
    for (int i = 1; i < len; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
int main() {
    int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
    int len = (int)sizeof(arr) / sizeof(*arr);
    insertion_sort(arr, len);
    int i;
    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);
    return 0;
}

4. 归并排序

步骤

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

4. 重复步骤 3 直到某一指针达到序列尾；

5. 将另一序列剩下的所有元素直接复制到合并序列尾。

#include <cstdio>
#include <iostream>
using namespace std;
const int N = 1e6 + 5;
int a[N], tmp[N];
void merge_sort(int q[],int l,int r) {
    if (l >= r)
        return;
    int mid = l + r >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);
    int k = 0;
    int i = l, j = mid+1;
    while (i <= mid && j <= r) {
        if (q[i] < q[j])
            tmp[k++] = q[i++];
        else
            tmp[k++] = q[j++];
    }
    while (i <= mid)
        tmp[k++] = q[i++];
    while (j <= r)
        tmp[k++] = q[j++];
    for (int i = l, j = 0; i <= r; i++, j++)
        q[i] = tmp[j];
}
int main() {
    int n;
    while (~scanf("%d", &n))
    {
        for (int i = 0; i < n; i++)
            scanf("%d", &a[i]);
        merge_sort(a, 0, n - 1);
        for (int i = 0; i < n; i++)
            printf("%d ", a[i]);
        puts("");
    }
    return 0;
}

5.快速排序 

算法步骤:

1. 从数列中挑出一个元素，称为 "基准"（pivot）;

2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

#include <cstdio>
#include <iostream>
using namespace std;
const int N = 1e6 + 5;
int a[N], tmp[N];
void quick_sort(int q[],int l,int r) {
    if(l>=r)
        return ;
    int i=l-1,j=r+1;
    int t=q[l];
    while(i<j){
        while(q[++i]<t);
        while(q[--j]>t);
        if(i<j)
            swap(q[i],q[j]);
    }
    quick_sort(q,l,j);
    quick_sort(q,j+1,r);
}
int main() {
    int n;
    while (~scanf("%d", &n))
    {
        for (int i = 0; i < n; i++)
            scanf("%d", &a[i]);
        quick_sort(a, 0, n - 1);
        for (int i = 0; i < n; i++)
            printf("%d ", a[i]);
        puts("");
    }
    return 0;
}

6.堆排序 

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 Ο(nlogn)。

建堆时间复杂度为O(n)

证明如下

其中 i 表示第几层，2^( i - 1) 表示该层上有多少个元素，( k - i) 表示子树上要下调比较的次数。
S = 2^(k-2) * 1 + 2^(k-3)2…..+2(k-2)+2^(0)*(k-1) ===> 因为叶子层不用交换，所以i从 k-1 开始到 1
S = 2^k -k -1；又因为k为完全二叉树的深度，而log(n) =k，把此式带入
得到：S = n - log(n) -1，所以时间复杂度为：O(n)

代码:升序

void heapify(int tree[],int i,int n){
    int l=i*2+1,r=i*2+2;
    int max=i;
    if(l<n&&tree[l]>tree[max])
        max=l;
    if(r<n&&tree[r]>tree[max])
        max=r;
    if(i!=max){
        swap(tree[i],tree[max]);
        heapify(tree,max,n);
    }
}
void heapify_build(int tree[],int n){
    for(int i=n/2;i>=0;i--)
        heapify(tree,i,n);
}
void heapify_sort(int tree[],int n){
    heapify_build(tree,n);
    for(int i=0;i<n;i++){
        swap(tree[0],tree[n-i]);
        heapify(tree,0,n-i);
    }
}