常用算法

1.冒泡排序

 1 void BubbleSort(int arr[] ,int len)
 2 {
 3     for (int pass =1; pass <len; pass++)//一共比较len-1轮
 4     {
 5         for (int i=0; i<len - pass; i++)//每轮比较len-pass次
 6         {
 7             int temp = 0;
 8             if (arr[i] > arr[i+1]) //升序就大于，降序就小于
 9             {
10                 temp = arr[i];
11                 arr[i] = arr[i+1];
12                 arr[i+1] = temp;
13             }
14         }
15     }
16 }
17 

2.快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。一趟快速排序的算法是：

　　1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；

　　2）以第一个数组元素作为关键数据，赋值给X，即 X=A[0]；

　　3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于X的值a[j]； 

　　4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于X的值a[i]；        5)  交换a[i]和a[j]的值；

　　6）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j+完成的最后另循环结束)

    方法1：

 1 void QuickSort(int arr[], int low, int high)
 2 {
 3     int left = low;
 4     int right = high;
 5     int pivotKey = arr[low];
 6     while (left<right)
 7     {
 8         while((left<right)&&(arr[right]>=pivotKey)) right--;
 9         arr[left] = arr[right];
10         while((left<right)&&(arr[left]<=pivotKey)) left++;
11         arr[right] = arr[left];
12     }
13     arr[left]=pivotKey;
14 
15     if (left-1>low)  QuickSort(arr,low,left-1);
16     if (left+1<high) QuickSort(arr,left+1,high);    
17 }

   方法2： 

 1 int Partition(int arr[], int low, int high)
 2 {
 3     int pivotKey = arr[low];
 4 
 5     while(low<high)
 6     {
 7         while((low<high)&&(arr[high]>=pivotKey)) high--;
 8         arr[low]=arr[high];
 9         while((low<high)&&(arr[low]<=pivotKey)) low++;
10         arr[high]=arr[low];
11     }
12     arr[low]=pivotKey;
13     return low;
14 }
15 
16 void QuickSort(int arr[], int low, int high)
17 {
18     int pivotLoc=Partition(arr,low,high);
19 
20     if(pivotLoc-1>low) QuickSort(arr,low,pivotLoc-1);
21     if(pivotLoc+1<high) QuickSort(arr,pivotLoc+1,high);
22 }

 3.二分查找

 前提：用顺序存储结构的数组

首先，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。

 1 int BinarySearch(int arr[], int data, int length)
 2 {
 3     int start=0;
 4     int end=length - 1;
 5     while (start<=end)
 6     {
 7         int middle = (start + end)/2;
 8         if (data == arr[middle])
 9         {
10             return middle;
11         }
12         else if (data > arr[middle])
13         {
14             start = middle+1;
15         }
16         else
17         {
18             end = middle -1;
19         }        
20     }
21 
22     return -1;
23 }

递归法：

 1 int BinarySearch(int arr[],int data, int low, int high)        
 2 {                                                              
 3     int middle = -1;                                           
 4     if (low<=high)                                             
 5     {                                                          
 6         middle = (low+high)/2;                                 
 7     }                                                          
 8     
 9     if (data>arr[middle])                                      
10     {                                                          
11         BinarySearch(arr,data,middle+1,high);                  
12     }                                                          
13     else if (data<arr[middle])                                 
14     {                                                          
15         BinarySearch(arr,data,low,middle-1);                   
16     }                                                          
17     else                                                       
18     {                                                          
19         return middle;                                         
20     }
21     //return middle;
22 }