常用算法

常用算法

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  }

 

 

 

 

posted on 2010-03-26 15:04  过河的小兵 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/eddyshn/archive/2010/03/26/1697028.html