Sort(啊哈算法)

桶排序

/** 给定5个同学的分数，按照从大到小的顺序排序

• 桶排序

• 时间复杂度：O(M+N)

• 缺点：浪费空间

  */

int main(){

/****************5***************/
int a[11];
for(int i=0; i<=10; i++){
    a[i] = 0; //初始化为0 
}

for(int i=0; i<5; i++){ //循环读入5个数 
    int t;
    cin >> t;
    a[t]++;   //进行计数 
}
for(int i=10; i>=0; i--){
    for(int j=1; j<=a[i]; j++){
        cout << i << " "; 
    }
}
cout << endl;

/****************1000****************/ 
int book[1001],i,j,t,n;
for(i=0; i<=1000; i++){ //循环m次,m为桶的个数 
    book[i] = 0;
}

scanf("%d", &n);//输入一个数n，表示接下来有n个数
for(i=1; i<=n; i++){//循环读入n个数，并进行桶排序，循环了n次（n为待排序数的个数） 
    scanf("%d", &t); 
    book[t]++; //进行计数，对编号为t的桶放一个小旗子
}

for(i=1000; i>=0; i--){ //一共循环了m+n 次
    for(j=1; j<=book[i]; j++){ //
        printf("%d ", i);
    }
}
cout << endl;

return 0;   

}

冒泡排序

/** 给定5个同学的分数，按照从大到小的顺序排序

• 冒泡排序

• 时间复杂度：O(N^2)

• 缺点：双重嵌套循环，执行效率低

  */

  写法(1) :

  for(int i=1; i<=n; i++){
       cin >> a[i];
   }
  for(int i=1; i<=n-1; i++){ //n个数排序，只用进行n-1趟
  for(int j=1; j<=n-i; j++){ //第1位开始比较直到最后一个尚未归位的数
      if(a[j] < a[j+1]){
          int t = a[j];
          a[j] = a[j+1];
          a[j+1] = t;
      }
  }
  

  写法(2) :

  for(int i=0; i<4; i++){  //比较n-1次 
      for(int j=i+1; j<5; j++){
          if(a[i] < a[j]){
              int temp = a[i];
              a[i] = a[j];
              a[j] = temp;
         }
      }
  }
  

快速排序

/** 快速排序

• 时间复杂度：O(NlogN)，最坏为O(N^2)

• 基于二分思想

  */
  

    int a[101];
    int n;   //定义全局变量，这两个变量需要在子函数中使用 
    void quickSort(int left, int right){
        int i,j,t,temp;
        if(left > right) return;
  
        temp = a[left]; //temp中存的是基准数
        i = left;
        j = right; 
        while(i != j){
       //顺序很重要，要先从右往左找
            while(a[j]>=temp && i<j){
                j--;
            }
      //再从左往右找
           while(a[i]<=temp && i<j){
                i++;
           } 
  
     //交换两个数在数组中的位置
           if(i < j){
               t = a[i];
               a[i] = a[j];
               a[j] = t;
           } 
    }
    //最终将基准数归位,i、j相同时的位置即为基准数需要的位置 
     a[left] = a[i];
     a[i] = temp;
  
     quickSort(left, i-1); //继续处理左边的序列，此处为递归 
     quickSort(i+1, right); //继续处理右边的序列，此处为递归 
  }
  
  
  int main(){
      int i,j,t;
      cin >> n;
      for(i=0; i<n; i++){
          cin >> a[i];
      }
      quickSort(0, n-1);  //调用快排
  
     for(i=0; i<n; i++){
         cout << a[i] << " ";
     } 
     cout << endl;
  
     return 0;
   }
  

以上三个算法为啊哈算法中所介绍的算法，之后会持续更新所学习到的算法。