排序算法 c++ 实现

代码

#include <iostream>                                                                                                                                                                                                 
#include <memory>

using std::cout;
using std::endl;

void ShowArr(int *arr, int len, const char* title=NULL) {
  if (title != NULL) {
    cout << title << " ";
  }
  for (int i = 0; i < len; i++) {
    cout << arr[i] << " ";
  }
  cout << endl;
}

void Swap(int *arr, int left, int right) {
  int t = arr[left];
  arr[left] = arr[right];
  arr[right] = t;
}

// 1. bubble sort
void BubbleSort(int *arr, int len) {
  cout << "bubble sort..." << endl;
  bool has_Swap = false;
  for (int i = len-1; i >= 1; i--) {
    for (int j = 0; j < i; j++) {
      if (arr[j] > arr[j+1]) {
        has_Swap = true;
        Swap(arr, j, j+1);
      }
    }

    ShowArr(arr, len);

    if (!has_Swap) {
      break;
    } else {
      has_Swap = false;
    }
  }
}

// 2. selection sort
void SelectionSort(int *arr, int len) {
  cout << "selection sort..." << endl;
  for (int i = 0; i < len-1; i++) {
    int min_idx = i;
    for (int j = i+1; j < len; j++) {
      if (arr[j] < arr[min_idx]) {
        min_idx = j;
      }
    }
    if (min_idx != i) {
      Swap(arr, i, min_idx);
    }
    ShowArr(arr, len);
  }
}

// 3. insertion sort
void InsertionSort(int *arr, int len) {
  cout << "insertion sort..." << endl;
  for (int i = 1; i < len; i++) {
    int j = i;
    int cur = arr[j];
    while (j >= 1 && cur < arr[j-1]) {
      arr[j] = arr[j-1];
      j--;
    }
    arr[j] = cur;
    ShowArr(arr, len);
  }
}

// 4. shell sort
void ShellSort(int *arr, int len) {
  cout << "shell sort..." << endl;
  for (int step = len/2; step > 0; step /= 2) {
    cout << "step: " << step << endl;
    for (int i = step; i < len; i++) {
      int j = i;
      int cur = arr[j];
      while (j >= step && cur < arr[j-step]) {
        arr[j] = arr[j-step];
        j -= step;
      }
      arr[j] = cur;
    }
    ShowArr(arr, len);
  }
}

// 5. merge sort
void Merge(int * arr, int *left_arr, int left_len, int *right_arr, int right_len) {
  int l = 0;
  int r = 0;
  int k = 0;
  while (l < left_len && r < right_len) {
    if (left_arr[l] <= right_arr[r]) {
      arr[k++] = left_arr[l++];
    } else {
      arr[k++] = right_arr[r++];
    }
  }

  while (l < left_len) {
      arr[k++] = left_arr[l++];
  }

  while (r < right_len) {
      arr[k++] = right_arr[r++];
  }
}

void MergeSort(int *arr, int len) {
  if (len < 2) {
    return;
  }

  int mid = len / 2;
  int *left_arr = new int[mid];
  for (int i = 0; i < mid; i++) {
    left_arr[i] = arr[i];
  }
  int *right_arr = new int[len-mid];
  for (int i = 0; i < len-mid; i++) {
    right_arr[i] = arr[i+mid];
  }

  MergeSort(left_arr, mid);
  MergeSort(right_arr, len-mid);
  Merge(arr, left_arr, mid, right_arr, len-mid);


  cout << "result len: " << len << endl;
  ShowArr(arr, len);

  delete[] left_arr;
  delete[] right_arr;
}

// 6. quick sort
int Partition(int *arr, int left, int right) {
  int pivot = left;
  int index = pivot + 1;
  for (int i = index; i <= right; i++) {
    if (arr[i] < arr[pivot]) {
      Swap(arr, i, index);
      index++;
    }
  }
  Swap(arr, pivot, index-1);
  return index-1;
}

void do_QuickSort(int *arr, int left, int right) {
  if (left < right) {
    int s = Partition(arr, left, right);
    do_QuickSort(arr, left, s-1);
    do_QuickSort(arr, s+1, right);
  }
}

void QuickSort(int *arr, int len) {
  cout << "quick sort..." << endl;
  do_QuickSort(arr, 0, len-1);
}

// 7. heap sort
void Heapify(int *arr, int len, int i) {
  int left = 2 * i + 1;
  int right = 2 * i + 2;
  int max_idx = i;
  if (left < len && arr[left] > arr[max_idx]) {
    max_idx = left;
  }
  if (right < len && arr[right] > arr[max_idx]) {
    max_idx = right;
  }
  if (i != max_idx) {
    Swap(arr, i, max_idx);
    Heapify(arr, len, max_idx);
  }
}

void BuildMaxHeap(int *arr, int len) {
  for (int i = len / 2; i >= 0; --i) {
    Heapify(arr, len, i);
  }
}

void HeapSort(int *arr, int len) {
  BuildMaxHeap(arr, len);
  for (int i = len-1; i >=1; --i) {
    Swap(arr, 0, i);
    Heapify(arr, i, 0);
    cout << "i: " << i << endl;
    ShowArr(arr, len);
  }
}

int main() {
  int len = 10;
  int arr[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
  ShowArr(arr, len, ">>>");

  // BubbleSort(arr, len);

  // SelectionSort(arr, len);

  // InsertionSort(arr, len);

  // ShellSort(arr, len);

  // MergeSort(arr, len);

  // QuickSort(arr, len);

  HeapSort(arr, len);

  ShowArr(arr, len, "<<<");
  return 0;
}

使用

g++ sort.cc -o sort && ./sort

引用

• 十大经典排序算法（动图演示）