各种排序算法源码(c++)20150913

• #include "sort.h"
  #include "mytool.h"
  
  void selectSort(int *a, int n) {
      int min;
      for(int i = 0; i < n; i++){
          min = i;
          for(int j = i + 1; j < n; j++){
              if(a[j] < a[min]){
                  min = j;
              }
          }
          int temp = a[i];
          a[i] = a[min];
          a[min] = temp;
      }
  }
  
  void insertSort(int a[], int n) {
      for(int i = 0; i < n; i++) {
          int j = i;
          while(j > 0 && a[j] < a[j-1]) {
              int temp = a[j];
              a[j] = a[j-1];
              a[j-1] = temp;
              j--;
          }
      }
  }
  
  
  void bubbleSort(int a[], int n) {
      for(int i = 0; i < n-1; i++) {
          int is_swap = false;
          for(int j = n-1; j > i; j--) {
              if(a[j] < a[j-1]) {
                  swap(a[j], a[j-1]);
                  is_swap = true;
              }
          }
          if(is_swap == false) {
              break;
          }
      }
  }
  
  
  
  void merge(int a[], int start, int mid, int end) {
      int nl=mid-start+1;  
      int nr=end-mid;  
      int *b = new int[nl];
      int *c = new int[nr];
      for(int i = 0; i < nl; i++){  
          b[i]=a[start + i];  
      }
      for(int i = 0 ; i < nr; i++){  
          c[i]=a[mid + 1 + i];  
      }
      int i = start;
      int il = 0, ir = 0;
      while(il != nl && ir != nr) {
          if(b[il] < c[ir]){
              a[i++] = b[il++];
          }else {
              a[i++] = c[ir++];
          }
      }
      while(il != nl) {
          a[i++] = b[il++];
      }
      while(ir != nr) {
          a[i++] = c[ir++];
      }
  }
  
  void mergeSort(int a[], int start, int end) {
      if(start == end) {
          return;
      }
      int mid = (start + end) / 2;
      mergeSort(a, start, mid);
      mergeSort(a, mid+1, end);
      merge(a, start, mid, end);
  }
  
  void mergeSort(int a[], int n) {
      mergeSort(a, 0, n-1);
  }
  
  void quickSort(int a[], int start, int end) {
      if(start >= end){
          return;
      }
      int flag = a[start];
      int index_l = start, index_r = end;
      while(index_l != index_r) {
          while(index_l < index_r && a[index_r] > flag)
              index_r--;
          a[index_l] = a[index_r];
          while(index_l < index_r && a[index_l] < flag)
              index_l++;
          a[index_r] = a[index_l];
      }
      a[index_l] = flag;
      quickSort(a, start, index_l-1);
      quickSort(a, index_l+1, end);
  }
  
  void c(int a[], int n) {
      quickSort(a, 0, n-1);
  }
  
  void maxHeapAdjust(int a[], int i, int n) {
      int temp, j;
      temp = a[i];
      j = 2 * i + 1;
      while(j < n) {
          if(j + 1 < n && a[j + 1] > a[j])
              j++;
          if(a[j] <= temp)
              break;
          a[i] = a[j];
          i = j;
          j = 2 * i + 1;
      }
      a[i] = temp;
  }
  
  void heapAdjust(int a[], int n) {
      for(int i = n / 2; i >= 0; i--) {
          maxHeapAdjust(a, i, n);
      }
  }
  
  void heapSort(int a[], int n) {
      heapAdjust(a, n);
      swap(a[n-1], a[0]);
      for(int i = n-1; i > 0; i--) {
          maxHeapAdjust(a, 0, i);
          swap(a[i-1], a[0]);
      }
  }
  
  void countSort(int a[], int n) {
      int count[10000] = {0};
      int *b = new int[n];
      for(int i = 0; i != n; i++) {
          count[a[i]]++;
      }
      for(int i = 1; i != 10000; i++) {
          count[i] += count[i-1];
      }
      for(int i = 0; i < n; i++) {
          *(b+count[a[i]]-1) = a[i];
          count[a[i]]--;
      }
      for(int i = 0; i < n; i++) {
          a[i] = *(b + i);
      }
  }
  
  int getNum(int a, int l) {
      while(l-- > 0) {
          a /= 10;
      }
      return a%10;
  }
  
  class Bucket {
  public:
      int num;
      Bucket *next;
  
      Bucket(int num) {
          this->num = num;
          this->next = 0;
      }
  };
  
  void radixSort(int a[], int l, int n) {
      Bucket *bucket[10] = {0};
      int isRe = false;
      for(int i = 0; i < n; i++) {
          int index = getNum(a[i], l);
          Bucket *temp = new Bucket(a[i]);
          if(bucket[index] == 0) {
              bucket[index] = temp;
          }else {
              Bucket *last = bucket[index];
              while(last->next != 0)
                  last = last->next;
              last->next = temp;
          }
          if(index != 0){
              isRe = true;
          }
      }
      int j = 0;
      for(int i =0; i < 10; i++) {
          while(bucket[i] != 0) {
              a[j++] = bucket[i]->num;
              Bucket *temp = bucket[i];            
              bucket[i] = bucket[i]->next;
              delete temp;
          }
      }
      if(isRe) {
          radixSort(a, l+1, n);
      }
  }
  
  void radixSort(int a[], int n) {
      radixSort(a, 0, n);
  }
  
  void bucketSort(int a[], int n) {
      int b[MAX_BUCKET_SIZE] = {0};
      for(int i = 0; i < n; i++) {
          b[a[i]]++;
      }
      int index = 0;
      for(int i = 0; i < MAX_BUCKET_SIZE; i++) {
          while(b[i]-- > 0) {
              a[index++] = i;
          }
      }
  }