常用基础算法总结

泡排序：(由于在排序的过程中总是小数在前，大数在后，相当于气泡上升，这是极经典的基础算法)

$arrar = array('a', 'f', 'c', 'b', 'e', 'h', 'j', 'i');

function maopao($array){

　　$len = count($array);

　　if($len<1){

　　　　return $array;

　　}

　　for($i=0; $i<$len; $i++){

　　　　for($j=$count-1; $j>$i; $j--){

　　　　　　if($array[$j] > $array[$j-1]){

　　　　　　　　$temp = $array[$j];

　　　　　　　　$array[$j] = $array[$j-1];

　　　　　　　　$array[$j-1] = $temp;

　　　　　　}

　　　　}

　　}

　　return $array;

}

2、快速排序：(是对冒泡排序的一种改进。基本思想是：通过一趟排序，将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的数据小，然后在按此方法对这两部分数据进行开速排序，整个排序过程可以递归进行，一次达到整个数据变成有序序列)

function quickSort($arr){

　　$len = count($arr);

　　if($len < 1){

　　　　return $arr;

　　}

　　$key = $arr[0];

　　$left = array();

　　$right = array();

　　for($i=1; $i<$len; $i++){

　　　　if($arr[$i] <= $key){

　　　　　　$left[] = $arr[$i];

　　　　}else{

　　　　　　$right[] = $arr[$i]; 

　　　　}

　　}

　　$left = quickSort($left);

　　$right = quickSort($right); 

　　return array_merge($left, array($key), $right);

}

3、选择排序（每一次从待排序的数据元素中选出最小或最大的一个元素，顺序放在已经排好的序列最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法）

function select_sort($arr){

　　$len = count($arr);

　　for($i=0; $i<$len; $i++){

　　　　for($j=$i+1; $j<$len;$j++){

　　　　　　if($arr[$i] > $arr[$j]){

　　　　　　　　$temp = $arr[$i];

　　　　　　　　$arr[$i] = $arr[j];

　　　　　　　　$arr[$j] = $temp;

　　　　　　}

　　　　}

　　}

　　return $arr;

}

C语言版本：

void select_sort(int *a,int n){

　　register int i,j,min,t;
　　for(i = 0;i < n-1;i++){
　　　　min = i;//查找最小值
　　　　for(j = i + 1;j < n;j++)
　　　　if(a[min] > a[j]){

　　　　　　min = j;//交换

　　　　}
　　　　if(min != i){
　　　　　　t = a[min];
　　　　　　a[min] = a[i];
　　　　　　a[i] = t;
　　　　}
　　}
}

4、插入排序（从第一个元素开始，该元素可以认为已经被排序，取出下一个元素，在已经排序的元素序列中从后向前扫描，如果该元素（已排序）大于新元素，将该元素移动到下一位置）。

function insert_sort(){

　　$len = count($arr);

　　for($i=1; $i<$len; $i++){

　　　　$temp = $arr[$i];

　　　　$j = $i-1;

　　　　while($arr[$j]>$temp){

　　　　　　$arr[$i] = $arr[j]

　　　　　　$arr[$j] = $temp;

　　　　　　$j--;

　　　　}

　　}

　　return $arr;

}

5、插入排序之希尔排序

基本思想：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

操作方法：

　　选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

　　按增量序列个数k，对序列进行k 趟排序；

　　每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

算法实现：

　　我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数。即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

void print(int a[], int n ,int i){

    cout<<i <<":";  

    for(int j= 0; j<8; j++){

        cout<<a[j] <<" ";

　　}

　　cout<<endl;

}

/ ** 

* 直接插入排序的一般形式 

* @param int dk 缩小增量，如果是直接插入排序，dk=1 

* / 

void ShellInsertSort(int a[], int n, int dk) {

    for(int i= dk; i<n; ++i){

        if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入

            int j = i-dk;

            int x = a[i];           //复制为哨兵，即存储待排序元素

            a[i] = a[i-dk];         //首先后移一个元素

            while(x < a[j]){     //查找在有序表的插入位置

                a[j+dk] = a[j];

                j -= dk;             //元素后移

             }

            a[j+dk] = x;            //插入到正确位置

        } 

        print(a, n,i );

    }

} 

 

/** 

 * 先按增量d（n/2,n为要排序数的个数进行希尔排序 

 */

 

void shellSort(int a[], int n){

    int dk = n/2;

    while( dk >= 1  ){

        ShellInsertSort(a, n, dk);

        dk = dk/2;

    }

}  

 

int main(){

    int a[8] = {3,1,5,7,2,4,9,6};  

    //ShellInsertSort(a,8,1); //直接插入排序  

    shellSort(a,8);           //希尔插入排序

    print(a,8,8); 

}

 

•  希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法，有取奇数的，也有取质数的，但需要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

6、采用非递归方式完成二分查找法。

(1)　　/* 非递归二分查找算法 

　　* 参数:整型数组,需要比较的数.

　　*/  

　　public static int binarySearch(Integer[]srcArray,int des){  

　　　　int low=0; //第一个位置.  

　　　　int high=srcArray.length-1;  //最高位置.数组长度-1,因为下标是从0开始的.  

　　　　while(low<=high){  //当low"指针"和high不重复的时候.  

　　　　　　int middle=low+((high-low)>>1);  //中间位置计算,low+ 最高位置减去最低位置,右移一位,相当于除2.也可以用(high+low)/2  

　　　　　　if(des==srcArray[middle]){ //与最中间的数字进行判断,是否相等,相等的话就返回对应的数组下标.  

 　　　　　　　　return middle;  

　　　　　　}else if(des<srcArray[middle]){  //如果小于的话则移动最高层的"指针"  

　　　　　　　　high=middle-1;  

　　　　　　}else{  //移动最低的"指针"   

　　　　　　　　low=middle+1;  

　　　　　　}  

　　　　}  

　　　　return-1;  

　　}  

(2)采用递归方式完成二分查找.

int BinSearch(int Array[],int low,int high,int key)  {  
    if (low<=high)  {  

        int mid = (low+high)/2;  

        if(key == Array[mid]){  

            return mid;

        }else if(key<Array[mid]){

                return BinSearch(Array,low,mid-1,key);  

         }else if(key>Array[mid]){ 

                return BinSearch(Array,mid+1,high,key);  

         }else {

                return -1;  

         }

    }

}

 

转载于:https://www.cnblogs.com/dong-blog/p/6999259.html