插入排序
插入排序首先需要一个已经从小到大排序好的数组A[1...n],然后假设要插入一个数字k,那么首先将k与A数组最末尾一个数字进行比较,如果k比A[n]小的话就将k和A[n]交换位置,这个动作一直到k比A[i]大的时候。
这个时候注意交换的操作,假设k要与A[i]进行交换,那么过程是这样的:temp = k , k = A[i] , A[i] = temp
因为每个交换动作都要temp = k ,所以先保存k,又因为前一个交换过程使得k位于A[i+1]的位置,所以是A[i+1]=A[i],假设这个交换动作之后存在下一个交换动作,所以这时候A[i]=A[i-1],则不用使得A[i]=temp,因为始终都是要变的,如果不存在下一个交换动作,则A[i]=k。所以最终这时候只需要记得最后一个j,使得A[j]>k,并且A[j-1]<=k,则可以在这时候才执行A[j]=k。
最后的用C++写的函数代码(好久没写C++了。。):
int maxLength = 4;
void insertion_sort(int *arr) {
for (int i = 1 ; i < maxLength ; i ++) {
int temp = arr[i];
int j = i-1 ;
for ( ;j >=0 && arr[j] > temp ;j --) {
arr[j+1] = arr[j];
}
arr [j+1] = temp;
}
}
归并排序
归并排序的策略是基于所谓的“分治算法”,也就是将原问题划分为若干个结构与原问题相似的子问题,然后递归的解决这些子问题,最后合并其结果的算法。归并排序的算法总结起来就三个步骤:
1)分解:将n个元素分解为两个个含n/2个元素的子序列
2)解决:对这两个子序列递归的排序
3)合并:合并两个已排序的子序列得到最后的排序结果
分析可以得到上面的步骤最重要的是第三点,因为将一个数组从大到小分解最终得到的是若干个包含0个或1个元素的元数组。
那么怎么将两个已经排序好的数组进行合并呢?
其实策略也是很简单,只要从比较二个数列的第一个数,谁小就先取谁,取了后就在对应数列中删除这个数。然后再进行比较,如果有数列为空,那直接将另一个数列的数据依次取出即可。下面是代码:
void merge(int *arr , int p ,int q, int r) {
int n = q-p+1 ;
int m = r - q;
int *left = new int[n];
int *right = new int[m];
for (int i = 0 ;i < n ; i ++) {
left[i] = arr[p + i];
}
for (int j = 0 ;j < m ; j ++) {
right[j] = arr[q+j+1];
}
int i = 0, j = 0 ,k = p ;
while (i < n && j < m) {
if ( left[i]<= right[j] ) {
arr[k++] = left[i++];
}
else {
arr [k++] = right[j++];
}
}
while (i < n) {
arr[k++] = left[i++];
}
while (j < m ) {
arr[k++] = right[j++];
}
}
void merge_sort(int *arr ,int p ,int r) {
if(p < r) {
int q = (p + r)/2;
merge_sort(arr , p, q);
merge_sort(arr , q+1 , r);
merge (arr, p , q , r);
}
}
冒泡排序
冒泡排序是我第一个掌握的排序,那时候还不知道啥叫算法,只知道照这样写就行了。
冒泡排序的基本思想是用一个变量i遍历整个数组,并且确保第i个数是前i-1个数里面最大的。非常暴力。
int maxLength = 4;
void bubble_sort(int *arr) {
for ( int i = 0 ; i < maxLength ; i ++ ) {
for ( int j = 0 ; j < i ; j ++ ) {
if ( arr[j] > arr[i] ) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
}
}
快速排序
下面是不用递归的快速排序,主要是用栈模拟递归的算法
#include <iostream>
#include <stack>
using namespace std;
/**
* 非递归实现快速排序算法,算法思路:使用堆模拟分治算法
*/
void quick_sort(int *arr ,int from ,int to) {
//Stack存放原则:待分治的数组的开始和结束坐标,第一个为开始坐标,第二个为结束坐标
stack <int>Stack;
Stack.push(from);
Stack.push(to);
while (Stack.empty() != true) {
int tempJ ,j, tempI ,i;
tempJ= j = Stack.top();
Stack.pop();
tempI = i = Stack.top();
Stack.pop();
int key = arr[i];
while (i= key) {
j --;
}
if (i < j && arr[j] < key) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
while (i < j && arr[i] <= key) {
i++;
}
if (i < j && arr[i] > key) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
if(i > tempI) {
Stack.push(tempI);
Stack.push(i-1);
}
if (i < tempJ) {
Stack.push(i+1);
Stack.push(tempJ);
}
}
}
int main() {
while (true) {
int size;
cin >> size;
int *arr = new int[size];
for (int i = 0 ; i < size; i ++) {
cin >> arr[i];
}
quick_sort(arr ,0,size-1);
for(int i = 0 ; i < size; i ++ ) {
cout << arr[i]<<" ";
}
cout << endl;
}
}
下面是递归方法写的快排
#include <iostream>
#include <cmath>
using namespace std;
/*分治和递归的思想*/
int Partition(int arr[], int p, int r)
{
int element = arr[r], i = p - 1;
for(int j = p; j < r; j ++)
{
if(arr[j] < element)
{
i ++;
swap(arr[i],arr[j]);
}
}
/*这个循环后:1、p <= k <=i,arr[k] <= element;2、i+1 <= k <= j-1, arr[k] > element*/
swap(arr[i+1],arr[r]);
return i + 1;
}
void Quick_sort(int arr[],int p, int r)
{
if(p < r)
{
int q = Partition(arr,p,r);
Quick_sort(arr,p,q-1);
Quick_sort(arr,q+1,r);
}
}
int main()
{
int arr[] = {7,5,8,4,9,2,1,4,6,10,-3,0};
Quick_sort(arr,0,11);
for(int i = 0; i < 12; i ++)
cout << arr[i] << endl;
return 0;
}
拓扑排序
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define MAX_SIZE 1024
vector<int> graph[MAX_SIZE]; //邻接表表示有向图
int<int> indegree[MAX_SIZE]; //各点的入度
//针对有向无环图的拓扑排序
vector top_sort(int n)
{
queue<int> q;
vector<int> ans;
for(int i = 0; i < n; i++)
if(indegree[i] ==0)
q.push(i);
int cur=0;
while(!q.empty())
{
cur = q.front(); q.pop();
ans.push_back(cur);
int tmp=0;
for(int j = 0; j < graph[cur].size(); j++)
{
tmp = graph[cur][j];
indegree[tmp]--;
if(indegree[tmp] == 0)
q.push(tmp);
}
}
return ans;
}