排序算法总结-插入排序、希尔排序、堆排序、快速排序

来源：互联网发布：java中格式化日期编辑：程序博客网时间：2024/05/08 08:33

今天去面试被问到了自己知道哪些排序算法，虽然答了一堆，但是想想会的真没几个，所以回来后这里将几个（自认为）重要的写在这里。

1、插入排序

[cpp] view plaincopy
//插入排序  
//原理：前i项是排过序的，将当前元素插入到前面已经排过序的序列中  
//时间界:O(N2)  
template <</SPAN>typename Comparable>  
void insertionSort(vector &a){  
    for( size_t i = 1; i < a.size(); i++){  
        Comparable temp = a[i];  
        int j;  
        for(j = i; j > 0 && temp < a[j - 1]; j--){  
            //如果当前待插入的元素小于前面的元素，  
            //则依次后移  
            a[j] = a[j - 1];  
        }  
        //将当前带插入元素放到循环退出的位置  
        //即前面的元素没有他大，或者j已经到了第一个位置  
        a[j] = temp;  
    }  
}  

2、希尔排序

[cpp] view plaincopy
//希尔排序  
//原理：所有相隔某个增量的元素都被排序  
//时间界与选取的增量序列相关，一般好于插入排序，但大于NlogN  
int getGap(int num){  
    int power = 0;  
    while((num/=2) > 0){  
        power++;  
    }  
  
    return (int)pow((double)2,(double)power);  
}  
template<</SPAN>typename Comparable>  
void shellSort(vector &v){  
    //这里选取增量序列为1,3,7,...,pow(2,k)-1  
    int gap = getGap(v.size());  
    for(; gap > 0; gap = gap/2 - 1){  
        for( size_t i = gap; i < v.size(); i++){  
            Comparable temp = v[i];  
            int j = i;  
            //我感觉这里跟插入排序是一样的，插入排序可以理解为gap是1的情况。  
            for(j = i; j >= gap && temp < v[j - gap]; j -= gap)  
                v[j] = v[j - gap];  
            v[j] = temp;  
        }  
    }  
}  

3、堆排序

[cpp] view plaincopy
//堆排序  
//根据二叉堆而来，这里用最大堆，即根的键值比其儿子的键值大  
//通过deleteMax操作得到排序后的序列  
template<</SPAN>typename Comparable>  
//下率操作  
void percDown(vector &v, int current, int n){  
    Comparable temp;  
    int child;  
    for( temp = v[current]; 2*current < n; current = child){  
        child = 2*current;  
        //找到最大的孩子  
        if( child + 1 < n && v[child] < v[child+1])  
            child++;  
  
        //如果最大的孩子比父亲大，则交换，否则找到了正确的位置退出  
        if( v[child] > temp)  
            v[current] = v[child];  
        else  
            break;  
    }  
    //将传进来的位置上的键值放到找到的位置  
    v[current] = temp;  
}  
  
template<</SPAN>typename Comparable>  
void heapSort(vector &v){  
    for( int i = v.size()/2; i >= 0; i--){  
        percDown(v, i, v.size());  
    }  
  
    for(size_t j = v.size() - 1; j > 0; j--){  
        //这里将最大的值与最后一个元素互换，即deleteMax操作  
        Comparable temp = v[0];  
        v[0] = v[j];  
        v[j] = temp;  
        //然后对根处的元素进行下率  
        percDown( v, 0, j);  
    }  
}  

4、快速排序

[cpp] view plaincopy
//快速排序  
//主要需要找到枢纽元，然后对其进行分段排序  
//找到枢纽元的方法可以自己进行各种改进  
template<</SPAN>typename Comparable>  
void swap(vector &v, int i, int j){  
    Comparable temp = v[i];  
    v[i] = v[j];  
    v[j] = temp;  
}  
template<</SPAN>typename Comparable>  
int getPivot(vector &v, int low, int high){  
    int middle = (low + high)/2;  
  
    if( v[low] > v[middle]){  
        swap(v, low, middle);  
    }  
    if( v[low] > v[high]){  
        swap(v, low, high);  
    }  
    if( v[middle] > v[high]){  
        swap(v, middle, high);  
    }  
  
    //这里将选出的中间值放在倒数第二个位置，因为最后一个不用再筛选了，他肯定比中间值大  
    swap(v, middle, high - 1);  
  
    return v[high - 1];  
}  
template<</SPAN>typename Comparable>  
void quickSort(vector &v, int low, int high){  
    if( low >= high)  
        return;  
  
    Comparable pivot = getPivot( v, low, high);  
  
    int l = low;  
    int r = high - 1;  
    while(1){  
        //当遇到不满足条件的元素时，l和r分别指向他们  
        while(v[++l] < pivot){}  
        while(v[--r] > pivot){}  
  
        if( l < r){  
            swap( v, l, r);  
        }else{  
            break;  
        }  
    }  
    //将枢纽元放置到结束的地方  
    swap(v, l, high - 1);  
    quickSort( v, low, l -1);  
    quickSort( v, l + 1, high);  
}  

今天就写到这里吧，上面的我都试了一下可以正常工作。睡觉了

0 0