算法的设计策略：

1：蛮力法 ------ 穷尽所有可能性 

2：递归技术 ： hanno法

3：分治法：  分而制之   ：一分二 二分四  的思想

4：模拟法  ：模拟实际场景

5：贪心算法：  当前最大利益， 例如炒股大多数股民都是考虑当前最大利益

6：优化法：   生物学优选原理， 例如基因

 

插入、 冒泡 、选择事件复杂度：O(N^2)

快速排序法： O(N * logN)

 

 

选择排序： 每次选择一个最小（或最大）的元素放到相应的位置

 

Good case1： 一个桌子上有 方块A 到方块K 13张扑克派，如何排序？

：  每次拿剩下的牌中最小的那个放到手里即可 即：每次拿最小的那个放到手里 当没有牌了  排序就完成了。

 

Good case2：一个数组里面 有几个 4 2 3 9 8 1  如何选择排序

1： 1 4 2 3 9 8    1前

2： 124398      2前

3： 123498       3前

4： 123498        4前

    5:   123489  8前

 

算法步骤：

    1:  i从0 ~Ｎ－１ 

2:  找从下标[i]到下标[N-1]的数据中 最小元素的位置minPos  

    3:  把最小元素与下标是[i]的元素交换

       

        ☞：运行结束，好比已经没有扑克牌

 

代码：

 

1. #include <iostream> 
2. #include <ctime> 
3. using namespace  std; 
4. //算出运算所用事件 
5.  
6. //定义 SelectSort 方法  类型灵活一些 
7. typedef  int    T; 
8. void    SelectSort (T*  arr, int num) 
9. { 
10.     int minPos = 0; 
11.  
12.     //I:遍历 从0 到num-1（因为最后一个不用比所以为num-1 ,注意个数和坐标最大值之间的换算）  
13.     for(int i=0; i<num-1; i++) 
14.     { 
15.         // 1:确定插入位置(i)位置正巧为i 2:确定最小元素位置 minPos  需要循环判断 
16.         minPos = i;  //假设第一个是最小的位置
17.  
18.         for (int j=i+1; j < num; j++)  //注意j从i后一个开始对边前面  j < num因为要比较最后一项 
19.         { 
20.             if(arr[j] < arr[minPos])  //找到最小的
21.             { 
22.                 minPos = j;     //找到最小的位置 
23.             } 
24.  
25.         }  
26.         //2:交换minPos 和 插入位置(i)的值 
27.         swap(arr[minPos], arr[i]); 
28.     } 
29. } 
30.      
31.  
32. int main() 
33. { 
34.  //定义102400长度的数组 越长越能计算所需世间   赋值 
35.     const int kNum = 102400; 
36.     T arr[kNum]; 
37.     for (int i=0; i<kNum; i++) 
38.     { 
39.         arr[i] = kNum - i; 
40.     } 
41.     time_t tStart = time(NULL); 
42.     SelectSort(arr, kNum); 
43.     time_t tEnd = time(NULL); 
44.      
45.     cout<<"require time:"<<tEnd-tStart <<endl; 
46.     //打印前十个看看是否完成排序 
47.     for(int i =0; i<10; i++) 
48.     { 
49.         cout<<arr[i]<<"     "; 
50.     } 
51.     system("pause"); 
52.     return 0; 
53.  
54. } 

 

 

运行结果：