算法就是这么一回事（排序）（第二部分）

上次说到冒泡排序

一共能够产生4种方式来产生，由于两个for循环皆可从小到大，也可从大到小

分类         排序算法
数据结构     vector、数组
最差时间复杂度     O(n^2)
最优时间复杂度     O(n)
平均时间复杂度     O(n^2)
最差空间复杂度     总共O(n)，须要辅助空间O(1)//用于交换所需临时变量

冒泡排序算法的运做以下：

 一、   比较相邻的元素。若是第一个比第二个大，就交换他们两个。
 二、   对每一对相邻元素做一样的工做，从开始第一对到结尾的最后一对。这步作完后，最后的元素会是最大的数。
 三、   针对全部的元素重复以上的步骤，除了最后一个。
 四、   持续每次对愈来愈少的元素重复上面的步骤，直到没有任何一对数字须要比较。

因为它的简洁，冒泡排序一般被用来对于程序设计入门的学生介绍算法的概念。
4、插入算法

    一句话就是从未处理的数组（或vector）向前面处理好的数组插入，由于前面处理好的已经有必定规律
    通常来讲，插入排序都采用in-place在数组上实现。具体算法描述以下：

 一、   从第一个元素开始，该元素能够认为已经被排序
 二、   取出下一个元素，在已经排序的元素序列中从后向前扫描
 三、   若是该元素（已排序）大于新元素，将该元素移到下一位置
 四、   重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
 五、   将新元素插入到该位置后
 六、   重复步骤2~5

若是比较操做的代价比交换操做大的话，能够采用二分查找法来减小比较操做的数目。该算法能够认为是插入排序的一个变种，称为二分查找排序。

若是目标是把n个元素的序列升序排列，那么采用插入排序存在最好状况和最坏状况。最好状况就是，序列已是升序排列了，在这种状况下，须要进行的比较操做需(n-1)次便可。最坏状况就是，序列是降序排列，那么此时须要进行的比较共有n(n-1)/2次。插入排序的赋值操做是比较操做的次数减去(n-1)次。平均来讲插入排序算法复杂度为O(n2)。于是，插入排序不适合对于数据量比较大的排序应用。可是，若是须要排序的数据量很小，例如，量级小于千，那么插入排序仍是一个不错的选择。 插入排序在工业级库中也有着普遍的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序做为快速排序的补充，用于少许元素的排序（一般为8个或如下）。

 1 #include <iostream>
 2 #include <iterator>
 3 #include <vector>
 4 #include <ctime>
 5 #include <random>
 6 #include <functional>
 7 #include <algorithm>
 8 using namespace std;
 9 int intSwap(int& a,int& b)
10 {
11     int intswaptemp=a;
12     a=b;
13     b=intswaptemp;
14     return 0;
15 }
16 /*----------------------------------------
17 插入排序
18 从小到大
19 vector<int>
20 -----------------------------------------*/
21 int insertionSort(vector<int> &ivec)
22 {
23     int i,j,temp;
24     for(i=1;i<=ivec.size();i++)
25     {
26         j=i-1;
27         temp=ivec[i];
28         while((temp<ivec[j])&&(j>=0))
29         {
30             ivec[j+1]=ivec[j];
31             j--;
32          }
33          ivec[j+1]=temp;
34 
35     }
36     return 0;
37 }
38 //照猫画猫-------->>>>上面
39 template<typename T>
40 int insertionSort_(T begin,T end)
41 {
42     typedef typename iterator_traits<T>::value_type value_type;
43     value_type key;
44     T ins=begin;
45     T j;
46     advance(ins,1);
47     while(ins!=end)
48     {
49         key=*ins;
50         j=ins;
51         T pre=j;
52         advance(j,-1);
53         while(key<*j&&pre!=begin)
54         {
55             iter_swap(pre,j);
56             advance(pre,-1);
57             advance(j,-1);
58         }
59         *pre=key;
60         advance(ins,1);
61     }
62 }
63 inline void insertSort_1(vector<int>&ivec)
64 {
65     insertionSort_(ivec.begin(),ivec.end());
66 }
67 int main()
68 {
69     clock_t start,end;
70     vector<int> ivec,copyivec;
71     srand(14);
72     for(int i=0;i<10000;i++)//10k
73         ivec.push_back((int)rand());
74     copyivec=ivec;
75     start=clock();
76     insertionSort(ivec);
77     end=clock();
78     for(int i=0;i<10000;i+=500)
79         cout<<ivec[i]<<'\t';
80     cout<<endl;
81     cout<<"the time  of 1 is "<<end-start<<endl;
82     start=clock();
83     insertSort_1(copyivec);
84     end=clock();
85     for(int i=0;i<10000;i+=500)
86         cout<<ivec[i]<<'\t';
87     cout<<endl;
88     cout<<"the time of 2  is "<<end-start<<endl;
89     return 0;
90 }

 可见仍是比较费时。不过因为暂时尚未优化，最后比较的时候才能判断。

5、堆排序

　　堆排序的前提是要了解二叉树这样一种玩意。这个排序的讲解有个大神，我也是第一次学这方法。

　　这个地方讲解的很清楚了~（最喜欢这种无脑就能够看懂的玩意，不须要本身拿笔一点点算）http://www.cnblogs.com/dolphin0520/archive/2011/10/06/2199741.html

　　个人话说就是这玩意能够就是一直要记得二叉树（有规律的，而这种规律能够用来实现排序）

　　这幅图一共二种信息，第一种就是刚开始会整理，注意，最大的在第一列，这就是二叉树的顶（头，）第二种就是开始排序算法，经过实现未排序最后一个和第一个交换，而后接着造成新的二叉树（头最大），对了，感受代码解释不多，我须要填写一些信息，第一次写，求不坑人！

 

 1 #include <iostream>
 2 #include <iterator>
 3 #include <vector>
 4 #include <ctime>
 5 #include <random>
 6 #include <functional>
 7 #include <algorithm>
 8 using namespace std;
 9 int intSwap(int& a,int& b)
10 {
11     int intswaptemp=a;
12     a=b;
13     b=intswaptemp;
14     return 0;
15 }
16 /*----------------------------------------
17 堆构造
18 从小到大
19 para：vector<int> 、int length、int node;
20 vector<int>数据集合
21 length经过该参数，能够不须要把已找到的数据和Ivec种分离出来，
22 就像图片第二幅信息中没有红线的一些数据（一列就是一数据）
23 node该参数肯定结点，根据二叉树的原理。
24 -----------------------------------------*/
25 int buildHeap(vector<int> &ivec,int node,int length)
26 {
27     int bondnode=node;//保存node，防止修改node
28     int lchild=bondnode*2+1;//左孩子数  二叉树关系（+1为了防止从node为0致使左孩子一直为0，先左后右（二叉树））
29     while(lchild<length)
30     {
31         //存在右孩子，且知足左小右大
32         //从两者中选出较大的并记录为lchild中保存
33         if(lchild+1<length&&ivec[lchild]<ivec[lchild+1])
34             lchild++;
35 
36         //判断node和右子数大小
37         if(ivec[bondnode]>ivec[lchild])
38             break;//若是知足说明这个3个数或2个数已经按照逻辑关系已经排序好。 39         else//
40         {
41             intSwap(ivec[bondnode],ivec[lchild]);
42             //重置结点和左孩子
43             //这些都是二叉树的一些性质
44             bondnode=lchild;//找下一个结点
45             lchild=2*bondnode+1;//新的左子数
46         }
47     }
48     return 0;
49 }
50 /*----------------------------------------
51 堆排序
52 从小到大
53 vector<int>
54 -----------------------------------------*/
55 int SortHeap(vector<int> &ivec)
56 {
57     for(int i=(ivec.size())/2-1;i>=0;i--)//产生node
58         buildHeap(ivec,i,ivec.size());//构造每一个小堆，从底层向高层。恰好能够减小不少次无效的循环
59     for(int j=0;j<ivec.size();j++)//排序开始了
60     {
61         intSwap(ivec[0],ivec[ivec.size()-j-1]);
62         //为0的结点发生变换
63         buildHeap(ivec,0,ivec.size()-j-1);
64     }
65     return 0;
66 }
67 int main()
68 {
69     clock_t start,end;
70     vector<int> ivec,copyivec;
71     srand(14);
72     for(int i=0;i<10000;i++)//10k
73         ivec.push_back((int)rand());
74     copyivec=ivec;
75     start=clock();
76     SortHeap(ivec);
77     end=clock();
78     for(int i=0;i<10000;i+=500)
79         cout<<ivec[i]<<'\t';
80     cout<<endl;
81     cout<<"the time  of 1 is "<<end-start<<endl;
82 
83     return 0;
84 }

 

　　堆排序其实也是一种选择排序，是一种树形选择排序。只不过直接选择排序中，为了从R[1...n]中选择最大记录，需比较n-1次，而后从 R[1...n-2]中选择最大记录需比较n-2次。事实上这n-2次比较中有不少已经在前面的n-1次比较中已经作过，而树形选择排序刚好利用树形的特 点保存了部分前面的比较结果，所以能够减小比较次数。对于n个关键字序列，最坏状况下每一个节点需比较log2(n)次，所以其最坏状况下时间复杂度为 nlogn。堆排序为不稳定排序，不适合记录较少的排序。（转自上面连接做者）

　　

一般堆是经过一维数组来实现的。在起始数组为 0 的情形中：

• 父节点i的左子节点在位置 (2*i+1);
• 父节点i的右子节点在位置 (2*i+2);
• 子节点i的父节点在位置 floor((i-1)/2);