常见排序算法杂记

#include<iostream>
#include<cstdlib>
using  namespace std;

void SelectSort( int *a,  int n) {
      int min;
      for ( int i =  0; i < n -  1; i++) {
        min = i;
          for ( int j = i+ 1; j < n; j++) {
             if (a[min] > a[j]) {
                min = j;              
            }         
        }
         if (min != i) {
            swap(a[min], a[i]);           
        }      
     }
}

void MergeArray( int a[],  int left,  int mid,  int right,  int tmp[]) {
      int i = left, j = mid+ 1, k =  0;
      while (i <= mid && j <= right) {
             if (a[i] > a[j]) {
                     tmp[k++] = a[j++];         
           }  else {
                    tmp[k++] = a[i++];             
           }
     }
      while (i <= mid) {
            tmp[k++] = a[i++];
     }
      while (j <= right) {
           tmp[k++]= a[j++];       
     }
      for ( int l =  0; l < k; l++) {
            a[l+left] = tmp[l];     
     }
}

void MergeSort( int a[],  int left,  int right,  int tmp[]) {
      if (left < right) {
            int mid = (left + right) /  2;
          MergeSort(a, left, mid, tmp);
          MergeSort(a,mid+ 1,right,tmp);
          MergeArray(a,left, mid, right, tmp);       
     }     
}

void QuickSort( int left,  int right,  int *a) {
     if (left < right) {
        int i = left, j = right, index = a[i];
        while (i < j) {
            while (i < j && a[j] >= index) {
                j--;
           }
            if (i < j) {
                 a[i++] = a[j];           
           }
            while (i < j && a[i] <= index  ) {
                 i++;
           }
            if (i < j) {
                 a[j--] = a[i];           
           }         
       }
       a[i] = index;
       QuickSort(left, i- 1, a);
       QuickSort(i+ 1,right, a);            
    }      
}

void InsertSort( int *a,  int n) {
      int pos, j, tmp;
      // 插入排序是从第gap位开始的，gap = 1往前插入。 
      for ( int i =  1; i < n; i++) {
         j = i -  1; 
          if (a[i] > a[j])  continue;
         tmp = a[i];
          // 尝试二分操作, 若用顺序操作的话，我们可以把搜索和移位放在一起  
          int left =  0, right = i, mid;
          // 这里的<=是为了防止忽略了值相等的情况下将插入的值放前面而破坏排序稳定性。 
          while (left <= right) {
                mid = (left + right) /  2;
                 if (a[i] >= a[mid]) {
                     left = mid +  1;                
               }  else {
                   right = mid -  1;           
               }
         } 
          /*
         while (j < pos) {
             if (a[j] > a[pos]) {
                 break;          
             }       
             j++;
         } */
         
          for (; j >= left; j--) {
             a[j+ 1] = a[j];     
         }     
         a[left] = tmp;
     }     
}

// 如果里层循环是往后搜的话，每一内循环是将最大的放在后面，
// 而不是把最小的放在前面，里层循环比外层少i，i为已经移动最大数的次数。 
// 可以设置里层是否已经交换来检测冒泡是否可以早些完毕 
int BubbleSort( int * a,  int n) {
     for ( int i =  0; i < n -  1; i++) {
         for ( int j =  0; j < n -  1 - i; j++) {
             if (a[j] > a[j+ 1])    {
               swap(a[j],a[j+ 1]);            
            }
        }
    }
}


// 下面的是希尔增量
// 还有Hibbard：{1, 3, ..., 2^k-1}，
// Sedgewick：{1, 5, 19, 41, 109...}该序列中的项是9*4^i - 9*2^i + 1和4^i - 3*2^i + 1交替得到。 
int ShellSort( int *a,  int n) {
    
     int gap = n /  2, j, tmp;
     while (gap >  0) {
           // 注意点1，i是inc的，因为这个方法是第二组，第三组，第四组的第二个数开始比较。
           // 是每组比较完再到下一组 
         for( int i = gap; i < n; i++) {
             if (a[i - gap] < a[i])  continue;    
            j = i -gap; 
            tmp = a[i];
             // 将移位和搜索放一起 
             // 注意点2:  a[j] > a[i]致命错误，因为a[i]被覆盖了 
             while ((j >=  0) && (a[j] > tmp)) {
                a[j+gap] = a[j]; 
                j -= gap;  
            }
            a[j+gap] = tmp;
         }
        gap /=  2;      
    } 
 } 
 

//小根堆调整，默认删除根节点,注意这里的n是减去了根节点以后的节点数
//重点是这个
void HeapDelete(int a[],int i, int n) {
    int j, tmp;
    tmp = a[i];
    j = 2 * i + 1;
    while (j < n) {
    if (j + 1 < n && a[j + 1] < a[j]) {
        j++;
    }
    if (a[j] >= tmp) {
       break;
    }
    a[i] = a[j];
    i = j;
    j = 2 * i + 1;
 }
 a[i] = tmp;
}

void BigHeapSort(int a[], int i, int n) {
   int j, tmp;
   tmp = a[i];
   j = 2 * i + 1;
   while (j < n) {
      if (j + 1 < n && a[j + 1] > a[j]) {
        j++;
      }
      if (a[j] <= tmp) {
          break;
      }
      a[i] = a[j];
      i = j;
      j = 2 * i + 1;
   }
   a[i] = tmp;
}

void HeapSort(int a[], int n) {
 for (int i = n / 2; i >= 0; i--) {
    BigHeapSort(a, i, n);
 }
 for (int i = n - 1; i >= 1; i--) {
    swap(a[0], a[i]);
    BigHeapSort(a, 0, i);
 }
}

void RadixSort() {
     
} 

int main() {
     int a[ 10], tmp[ 10];
     for ( int i =  0; i <  10; i++) {
        a[i] = rand()% 10;
    }
     for ( int i =  0; i<  10; i++) {
        cout << a[i] <<  "   ";    
    }
    cout << endl;
     // MergeSort(a,0,100-1,tmp);
    ShellSort(a, 10);
     for ( int i =  0; i<  10; i++) {
        cout << a[i] <<  "   ";    
    }
    system( " pause ");
}  

//Mark一下http://www.cs.usfca.edu/~galles/visualization/Algorithms.html 

转载于:https://www.cnblogs.com/KiddingJohn/p/5353511.html