常见排序算法杂记

#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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值