各种排序算法收集

插入排序

插入排序首先需要一个已经从小到大排序好的数组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;
}