标签：nums int void C++ ++ 九大 vector heap 排序

• Quciksort
• Mergesort
• Insertionsort
• Bubblesort
• Selectionsort
• Shellsort
• Heapsort
• Countsort
• Radixsort
• Summary

Quciksort

void quick_sort(vector<int> &nums, int l, int r) {
  if (l + 1 >= r) {
    return;
  }
  int first = l, last = r - 1, key = nums[first];
  while (first < last) {
    while (first < last && nums[last] >= key) {
      --last;
    }
    nums[first] = nums[last];
    while (first < last && nums[first] <= key) {
      ++first;
    }
    nums[last] = nums[first];
  }
  nums[first] = key;
  quick_sort(nums, l, first);
  quick_sort(nums, first + 1, r);
}

Mergesort

void merge_sort(vector<int> &nums, int l, int r, vector<int> &temp) {
  if (l + 1 >= r) {
    return;
  }
  // divide
  int m = l + (r - l) / 2;
  merge_sort(nums, l, m, temp);
  merge_sort(nums, m, r, temp);
  // conquer
  int p = l, q = m, i = l;
  while (p < m || q < r) {
    if (q >= r || (p < m && nums[p] <= nums[q])) {
      temp[i++] = nums[p++];
    } else {
      temp[i++] = nums[q++];
    }
  }
  for (i = l; i < r; ++i) {
    nums[i] = temp[i];
  }
}

Insertionsort

void insertion_sort<vector<int> &nums, int n){
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < nums[j]; ++j) {
      swap(nums[j], nums[j - 1]);
    }
  }
}

Bubblesort

void bubble_sort(vector<int> &nums, int n) {
  bool swapped;
  for (int i = 1; i < n; ++i) {
    swapped = false;
    for (int j = 1; j < n - i + 1; ++j) {
      if (nums[j] < nums[j - 1]) {
        swap(nums[j], nums[j - 1]);
        swapped = true;
      }
    }
    if (!swapped) {
      break;
    }
  }
}

Selectionsort

void selection_sort(vector<int> &nums, int n) {
  int mid;
  for (int i = 0; i < n - 1; ++i) {
    mid = i;
    for (int j = 0; j < n; ++j) {
      if (nums[j] < nums[mid]) mid = j;
    }
    swap(nums[mid], nums[i]);
  }
}

Shellsort

void shellSort(vector<int> &q) {
  int gap = q.size() / 2;
  while (gap) {
    for (int i = gap; i < q.size(); i += gap) {
      int t = q[i], j;
      for (j = i - gap; j >= 0; j -= gap) {
        if (q[j] > t)
          q[j + gap] = q[j];
        else
          break;
      }
      q[j + gap] = t;
    }
    gap /= 2;
  }
}

Heapsort

void push_down(vector<int> &heap, int size, int u) {
  int t = u, left = u * 2, right = u * 2 + 1;
  if (left <= size && heap[left] > heap[t]) t = left;
  if (right <= size && heap[right] > heap[t]) t = right;
  if (u != t) {
    swap(heap[u], heap[t]);
    push_down(heap, size, t);
  }
}

void push_up(vector<int> &heap, int u) {
  while (u / 2 && heap[u / 2] < heap[u]) {
    swap(heap[u / 2], heap[u]);
    u /= 2;
  }
}

void heapSort(vector<int> &q, int n) {
  int size = n;
  for (int i = 1; i <= n; i++) push_up(q, i);
  for (int i = 1; i <= n; i++) {
    swap(q[1], q[size]);
    size--;
    push_down(q, size, 1);
  }
}

Countsort

void countingSort(vector<int> &q, int n) {
  vector<int> cnt(101, 0);
  for (int i = 0; i < n; i++) cnt[q[i]]++;
  for (int i = 0, k = 0; i <= 100; i++) {
    while (cnt[i]) {
      q[k++] = i;
      cnt[i]--;
    }
  }
}

Radixsort

不超过999

int get(int x, int i) {
  while (i--) x /= 10;
  return x % 10;
}

void radixSort(vector<int> &q, int n) {
  vector<vector<int>> cnt(10);
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 10; j++) cnt[j].clear();
    for (int j = 0; j < n; j++) cnt[get(q[j], i)].push_back(q[j]);
    for (int j = 0, k = 0; j < 10; j++) {
      for (int x : cnt[j]) q[k++] = x;
    }
  }
}

Summary

标签：nums,int,void,C++,++,九大,vector,heap,排序
来源： https://www.cnblogs.com/sonnet/p/15187498.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。