Latest Publications

基数排序

Posted in 2009-12-25 5:54 PMJulius ChenNo Comments »

基数排序和计数排序一样，是非基于比较的排序算法，它借助“分配”和“收集”两种操作对单逻辑关键字进行排序（基于箱/桶排序），它的排序速度很快，时间复杂度为线性，但由于需要的辅助空间太大（n(radix+1)），因此长期无法应用。直到1954年有人提出用“计数”代替“分配”才得以使它能在计算机上实现。此后，又有人提出用链表作为存储数据的结构，这样又能减少一些辅助空间，这也是一种比较好的实现方法（只是算法要较复杂）。

基数排序分为MSD（最高位优先）基数排序和LSD（最低位优先）基数排序，MSD从左到右处理关键字的位数，首先处理最重要的数字。它比较符合常规的思维，所需处理的信息量也较少。但按MSD进行排序，必须将序列逐层分割成若干个子序列，然后对各子序列分别进行排序；而LSD则从右到左先处理最不重要的数字，这样虽然可能花费了一些时间来处理不会影响结果的信息，但它不用分子序列，对每个关键字都是整个序列参加排序，而且对具体的应用还可以对其进行改进。因此在很多排序应用中都选择这种方法。

基数排序（LSD/用计数排序）的C/C++代码实现：

  1. void radix_sort(int a[], int length)
  2. {
  3.     int i, j, digit;
  4.     int c[16];
  5.     int temp[ARRAY_SIZE];
  6.     for (i = 0; i < HEX; ++i) {
  7.         for (j = 0; j < 16; ++j) c[j] = 0;
  8.         for (j = 0; j < length; ++j) c[a[j]>>4*i&0xf]++;
  9.         for (j = 1; j < 16; ++j) c[j] += c[j-1];
  10.         for (j = length - 1; j >= 0; --j) {
  11.             digit = a[j] >> 4 * i & 0xf;
  12.             temp[c[digit]-1] = a[j];
  13.             c[digit]--;
  14.         }
  15.         for (j = 0; j < length; ++j) a[j] = temp[j];
  16.     }
  17. }

继续阅读 »

Sorting, ,

计数排序

Posted in 2009-12-24 6:34 PMJulius ChenNo Comments »

计数排序(Counting Sort)是一种非基于比较的排序方法，它要求所有的待排元素都必须是≥0的整数。它的排序步骤是首先根据数组中最大的元素值加1作为长度来定义一个计数数组C。然后统计待排数组中每个值为i的元素出现的次数，存入C的第i项中。再对所有的计数累加（从C中的第一项开始，每一项和前一项相加）。最后再反向填充辅助数组：将每个元素i放在辅助数组的第C(i)项，每放一个元素就将C(i)减去1。这样完成之后排序就已完毕，有序序列已存储在辅助数组中。如果结果想用原数组输出，则将它们从辅助数组考回到原数组即可。

计数排序的C/C++代码实现：

  1. void counting_sort(int a[], int length)
  2. {
  3.     int i;
  4.     int c[MAX_VALUE] = {0};
  5.     int temp[ARRAY_SIZE] = {0};
  6.     for (i = 0; i < length; ++i) c[a[i]]++;
  7.     for (i = 1; i < MAX_VALUE; ++i) c[i] += c[i-1];
  8.     for (i = length - 1; i >= 0; --i) {
  9.         temp[c[a[i]]-1] = a[i];
  10.         c[a[i]]--;
  11.     }
  12.     for (i = 0; i < length; ++i) a[i] = temp[i];
  13. }

继续阅读 »

Sorting, ,

归并排序

Posted in 2009-12-22 6:27 PMJulius ChenNo Comments »

归并排序是建立在归并操作（Merging）上的一种排序方法，它是采用分治法的一个非常典型的应用。归并是指将两个或两个以上的有序表合并成一个新的更大的有序表，归并排序则是递归的先将待排序列分割成n个序列，然后从最小的有序序列（只含一个元素）开始不断调用归并操作进行合并直到最后都合并成一个大的完整的有序表为止。

归并排序的C/C++代码实现：

  1. void merge(int array[], int low, int m, int high)
  2. {
  3.     int i, j, k;
  4.     static int temp[ARRAY_SIZE];
  5.     for (i = low, j = m + 1, k = 0; k < high - low + 1; ++k) {
  6.         if (i > m) {
  7.             temp[k] = array[j++];
  8.             continue;
  9.         }
  10.         if (j > high) {
  11.             temp[k] = array[i++];
  12.             continue;
  13.         }
  14.         temp[k] = array[i] < array[j] ? array[i++] : array[j++];
  15.     }
  16.     for (k = 0; k < high - low + 1; ++k)
  17.         array[low+k] = temp[k];
  18. }
  19.  
  20. void merge_sort(int sort_array[], int low, int high)
  21. {
  22.     if (low < high) {
  23.         int i = (low + high) / 2;
  24.         merge_sort(sort_array, low, i);
  25.         merge_sort(sort_array, i + 1, high);
  26.         merge(sort_array, low, i, high);
  27.     }
  28. }

继续阅读 »

Sorting,

堆排序

Posted in 2009-12-21 6:12 PMJulius ChenNo Comments »

堆排序是对树形选择排序的改进，它首先将整个待排序列构建成一个堆，然后将堆顶元素与最后一个元素交换，由此得到一个有序元素和一个长度减1的堆。由于交换后新的堆顶元素可能不满足堆的定义，因此需要将新的堆重新进行堆化（堆化无需重新建堆，只需做少许调整），在堆化完成之后再次将堆顶元素与堆的最后一个元素交换，由此再得到一个新的有序元素和一个长度减1的堆。然后再重新进行堆化，再交换。。。这样一直下去，直到整个堆只有一个元素为止。这样也就完成了对序列的排序。由这个排序的过程也可以知道，堆排序和简单选择排序不同，不是从前往后慢慢有序，而是从后往前慢慢有序。

堆排序的C/C++代码实现：

  1. void heapify(int sort_array[], int k, int m)
  2. {
  3.     int temp = sort_array[k];
  4.     for (int j = 2 * k; j < = m; j *= 2) {
  5.         if (j < m && sort_array[j] < sort_array[j+1]) ++j;
  6.         if (!(temp < sort_array[j])) break;
  7.         sort_array[k] = sort_array[j];
  8.         k = j;
  9.     }
  10.     sort_array[k] = temp;
  11. }
  12.  
  13. void heap_sort(int sort_array[], int length)
  14. {
  15.     int i, temp;
  16.     for (i = (length - 1) / 2; i >= 0; --i)
  17.         heapify(sort_array, i, length - 1);
  18.  
  19.     for (i = length - 1; i > 0; --i) {
  20.         temp = sort_array[0];
  21.         sort_array[0] = sort_array[i];
  22.         sort_array[i] = temp;
  23.         heapify(sort_array, 0, i - 1);
  24.     }
  25. }

继续阅读 »

Sorting, ,

快速排序

Posted in 2009-12-20 3:50 PMJulius ChenNo Comments »

快速排序是应用最广泛的排序算法，也是目前认为最好的一种内部排序方法（就平均时间而言）。它采用分治（divide-and-conquer）的策略，通过一趟排序将待排记录分割成独立的两个部分，使其中的一部分记录关键字均比另一部分记录关键字小（大），然后分别对两个部分继续进行排序，以达到整个序列有序。

快速排序的C/C++代码实现：

  1. int partition(int sort_array[], int low, int high)
  2. {
  3.     int pivotkey = sort_array[low];
  4.     while (low < high) {
  5.         while (low < high && pivotkey <= sort_array[high]) --high;
  6.         sort_array[low] = sort_array[high];
  7.         while (low < high && pivotkey >= sort_array[low]) ++low;
  8.         sort_array[high] = sort_array[low];
  9.     }
  10.     sort_array[low] = pivotkey;
  11.     return low;
  12. }
  13.  
  14. void quick_sort(int sort_array[], int low, int high)
  15. {
  16.     if (low < high) {
  17.         int i = partition(sort_array, low, high);
  18.         quick_sort(sort_array, low, i - 1);
  19.         quick_sort(sort_array, i + 1, high);
  20.     }
  21. }

继续阅读 »

Sorting, ,