发现一个神器:http://visualgo.net/
1.插入排序(Insert Sort)
基本思想:
将一个记录插入到已经有序的记录序列中,得到一个新的、记录数加1的序列。排序时,将第一个记录先视为有序,再依次对后面的记录进行插入。
可以想象自己是在打牌,首先摸到一张牌,认为他是有序的,然后每摸到一张牌就要跟手里的牌作比较,找到正确的插入位置。
时间复杂度:
O(n^2),当序列为逆序时。
伪代码:
void insertSort(int a[]){
int len; //数组的长度
for(len=0; a[len]; len++) ;
int key; //带排关键字
for(int j=1; j<len; j++){
key = a[j];
int i=j-1;
while(i>0 && key<a[i]){
a[i+1] = a[i];
i--;
}
a[i+1] = key;
}
}
2.归并排序(Merge Sort)
基本思想:
运用分治法的思想。将一个序列分为左右两个子序列,将两个子序列分别排序后,进行合并。整个归并排序可以分成两个过程:1)左右子序列各自排序,2)左右子序列合并。
合并的过程依然想象自己是在打牌。左右两堆牌按序正面朝上放到桌上(比如从上到下是从小到大的顺序),每次接起两堆最上面较小的一张牌,这样就可以把两堆有序的牌合并成一堆有序的牌了。当然实现的时候要注意给每堆牌的底部加一个哨兵,当看见哨兵的时候就把另一堆剩下的牌直接复制过来就好了。
左右子序列各自排序的过程其实是递归调用的,递归到左右两堆只剩一张牌的时候,认为各自有序,就开始合并。有点树的意思,子节点一层层向上构成父节点,最后的根节点就是整个排好序的数组
时间复杂度:
O(nlgn)
伪代码:
#define INF 65535
void merge(int a[], int p, int q, int r){
int n1 = q-p+1; //已排好序的两个子序列的长度
int n2 = r-q;
vector<int> L,R; //复制两个子序列的值
for(int i=1; i<=n1; i++){ //L,R里从上到下存放的值从小到大
L.push_back(a[p+i-1]);
}
for(int j=1; j<=n2; j++){
R.push_back(a[q+j]);
}
L.push_back(INF);
R.push_back(INF);
i=0;
j=0;
for(int k=p; k<=r; k++){
if(L[i] <= R[j]){
if(R[j] == INF){ //如果某一边遇到了无穷大,则把另一边后面的值直接复制就好
while(L[i]!=INF && k<=r){
a[k] = L[i];
i++;
k++;
}
}
else{
a[k] = L[i];
i++;
}
}
else if(L[i] > R[j]){
if(L[i] == INF){
while(R[j]!=INF && k<=r){
a[k] = R[j];
j++;
k++;
}
}
else{
a[k] = R[j];
j++;
}
}
}
}
void mergeSort(int a[], int p, int r){
if(p < r){
int q = (p+r)/2;
mergeSort(a,p,q);
mergeSort(a,q+1,r);
merge(a,p,q,r);
}
}
3.堆排序(Heap Sort)
基本思想:
待续。。。
时间复杂度:
O(nlgn)
像合并排序一样,它的时间复杂度是O(nlgn),想插入排序一样,它是一种原地排序的算法,数组中只有常数个元素存储在输入数组之外。因此,堆排序结合了合并排序和插入排序的优点。这是一种
2.插入排序——希尔排序(Shell Sort)
基本思想:
把一个序列分成gap组,在组内用直接插入排序。gap初值为n/2,之后依次变成gap=gap/2,直到gap=1.。
时间复杂度:
最优:复杂度为O(n),当序列已经有序时;
最差:复杂度为O(n^2),当序列为逆序时。
void Sort::ShellSort(vector<int> &s){
<pre name="code" class="cpp"> int size = s.size();
int gap ; //每次的gap值
int i, j, k, key;
for(gap = size/2; gap>0; gap /= 2){
for(i=0; i<gap; i++){ //每次分成gap组
for(j=i+gap; j<size; j+=gap){//每组中有n/gap个值
if(s[j] < s[j-gap]){ //对着n/gap个值进行直接插入排序
key = s[j];
k = j-gap;
while( k>=0 && s[k]>key){
s[k+gap] = s[k];
k -= gap;
}
s[k+gap] = key;
}
}
}
}
}
3.选择排序——简单选择排序(Simple Selection Sort)
基本思想:
对于序列中的每一个值,从后续序列中找到一个最小的跟它交换。
时间复杂度:
最优:复杂度为O(n),当序列已经有序时;
最差:复杂度为O(n^2),当序列为逆序时。
void Sort::SimpleSelectionSort(vector<int> &s){
int sz = s.size();
int i, j, k, smallest, temp;
for(i=0; i<sz-1; i++){
smallest = s[i];
k = i;
for(j=i+1; j<sz; j++){ //寻找一堆数里的最小值
if(s[j] < smallest){
smallest = s[j];
k = j; //记住最小值的下标
}
}
temp = s[i];
s[i] = s[k];
s[k] = temp;
}
}
4.选择排序——堆排序(Heap Sort)
基本思想:
待续。。。
时间复杂度:
O(nlgn)
像合并排序一样,它的时间复杂度是O(nlgn),想插入排序一样,它是一种原地排序的算法,数组中只有常数个元素存储在输入数组之外。因此,堆排序结合了合并排序和插入排序的优点。这是一种
5.交换排序——冒泡排序(Bubble Sort)
基本思想:
对序列中的每一个元素,如果与后面相邻元素反序,则重复的交换。如果是升序排列,每循环一次都会把当前最大的一个沉底。
时间复杂度:
O(n^2)
伪代码:
void bubbleSort(int a[]){
int len;
for(len=0; a[len]; len++) ;
for(int i=0; i<len; i++){
for(int j=len-1; j>=i+1; j--){
if(a[j] < a[j-1]){ int temp=a[j]; a[j]=a[j-1]; a[j-1]=temp;}
}
}
}
6.交换排序——快速排序(Quick Sort)
void Sort::QuickSort(int s[], int low, int high){ // low, high分别记录要排序序列的起始位置
// int low = 0, high = sz-1;
if( low >= high)
return;
int first = low, last = high; //first, last记录分段子序列的起始位置
int key = s[first];
while(first < last && first < last){
while( s[last] > key )
last--;
swap( s[first], s[last]);
while( first < last && s[first] < key )
first++;
swap( s[first], s[last] );
}
QuickSort(s, low, first-1); //分段排序
QuickSort(s, first+1, high);
return ;
}
对排序算法的改进:
1.在插入排序寻找键值key的过程中使用二分查找法。它用的也是分治的思想,如果整个的用时为T(n),分成一半的用时为T(n/2),每次分完它只比较了一次(待寻找的值和a[mid]),所以T(n) = c(当v=a[(n-1)/2]时)或者T(n/2)+c(一般情况下),求解这个式子,得T(n)=lgn.
int bSearch(int a[], int v){
int len;
for(len=0; a[len]; len++) ;
int left = 0;
int right = len-1;
int mid;
while(!(left > right)){
mid = (left+right)/2;
if(v < a[mid])
right = mid-1;
else if(v > a[mid])
left = mid+1;
else
return mid;
}
return mid;
}
将二分查找用在插入排序中
(未完待续。。。)