赞
踩
目录
每次从一个有序序列开始,将待排元素与有序序列中的元素从后往前逐个比较,
若有序序列中的元素大于待排元素,则将较大的元素往后覆盖;
否则,将待排元素插入其前面,并结束此轮比较。
- void InsertSort(int* a, int n)
- {
- for (int i = 0; i < n - 1; i++)
- {
- int end = i;
- int x = a[end + 1];
- while (end >= 0)
- {
- if (a[end] > x)
- {
- a[end + 1] = a[end];
- end--;
- }
- else
- break;
- }
- a[end + 1] = x;
- }
- }
先选定一个整数作为 gap ,将待排序列以 gap 为间隔分成 gap 组,
先对每组进行直接插入排序,
然后再适当缩小 gap ,重复上述步骤。
当 gap = 1 时,此时序列已经进行了多次预排序,接近有序。
这时再对序列进行直接插入排序,就能达到优化的效果。
- void ShellSort(int* a, int n)
- {
- //多次预排序(gap > 1) + 直接插入( gap == 1)
- int gap = n;
- while (gap > 1)
- {
- //使gap最后一次一定能到1
- gap = gap / 3 + 1;
- //多组一起排
- for (int i = 0; i < n - gap; ++i)
- {
- int end = i;
- int x = a[end + gap];
- while (end >= 0)
- {
- if (a[end] > x)
- {
- a[end + gap] = a[end];
- end -= gap;
- }
- else
- break;
- }
- a[end + gap] = x;
- }
- }
- }
每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始(末尾)位置,直到全部待排序的数据元素排完 。
以每次选出最小值为例
- void Swap(int* px, int* py)
- {
- int tmp = *px;
- *px = *py;
- *py = tmp;
- }
-
- void SelectSort(int* a, int n)
- {
- int begin = 0;
- while (begin < n - 1)
- {
- int mini = begin;
- for (int i = begin; i < n; i++)
- {
- if (a[i] < a[mini])
- mini = i;
- }
- Swap(&a[begin], &a[mini]);
- ++begin;
- }
- }
小堆根上的元素是堆中最小的元素,大堆根上的元素是堆中最大的元素。
先将待排序列建成小(大)堆,
获取堆根上的元素,这样就达到了选出待排序列中最小(大)元素的目的,
然后再将其放至正确位置。
若将待排序列建成小堆,则每次可将待排序列中最小的元素放至正确的位置,但每次排除堆根后,剩下元素组成的堆结构被打乱,需要对剩下待排序列重新建堆,反而增加的问题的复杂性。
故我们将其建成大堆,每次将堆根上的元素(待排序列中最大的元素)与待排序列中最后一个元素进行交换,将大堆根上的元素换至正确位置,然后再使用向下调整算法,将交换上来的元素调整至一个大堆中的合适位置。
- void Swap(int* px, int* py)
- {
- int tmp = *px;
- *px = *py;
- *py = tmp;
- }
-
- //建大堆的向下调整算法
- void AdjustDown(int* a, int n, int parent)
- {
- int child = parent * 2 + 1;
- while (child < n)
- {
- if (child + 1 < n && a[child + 1] > a[child])
- ++child;
- if (a[child] > a[parent])
- {
- Swap(&a[child], &a[parent]);
- parent = child;
- child = parent * 2 + 1;
- }
- else
- break;
- }
- }
-
- void HeapSort(int* a, int n)
- {
- //先使用向下调整算法,从最后一个元素的父亲开始建堆
- for (int i = (n - 1 - 1) / 2; i >= 0; --i)
- {
- AdjustDown(a, n, i);
- }
- //先交换,再调整
- for (int end = n - 1; end > 0; --end)
- {
- Swap(&a[0], &a[end]);
- AdjustDown(a, end, 0);
- }
- }
从待排序列的首元素开始,从前往后依次进行比较,
若大于则交换,将其继续与后面元素比较,直到被放至正确位置。
否则迭代至与其比较的元素,重复上面的步骤。
- void Swap(int* px, int* py)
- {
- int tmp = *px;
- *px = *py;
- *py = tmp;
- }
-
- void BubbleSort(int* a, int n)
- {
- for (int j = 0; j < n; j++)
- {
- for (int i = 0; i < n - j - 1; i++)
- {
- if (a[i] > a[i + 1])
- {
- Swap(&a[i], &a[i + 1]);
- }
- }
- }
- }
任取待排序元素序列中的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止。
- void QuickSort(int* a, int left, int right)
- {
- if (left >= right)
- return;
-
- //先将选定的基准值排好
- int keyi = Partion(a, left, right);
-
- //再通过递归排序其左右子序列
- QuickSort(a, left, keyi - 1);
- QuickSort(a, keyi + 1, right);
- }
Partion函数在这里的作用是:
将选定的基准值排到正确位置,并将待排序列分成比基准值小的左子序列,比基准值大的右子序列。
将区间按照基准值划分为左右两半部分的常见方式有:
1.hoare版本
基本思想:
选择待排序列的最左值的下标为基准值所指下标,当区间左下标小于区间右下标时,先从右开始找比基准值小的值,找到后再从左开始找比基准值大的值,都找到后,将左右下标对应的值交换,然后从右开始重复上述步骤,直到左右下标相等。当左右下标相等时,将下标所指向的值与基准值互换。
动图演示:
代码实现:
- //hoare版本
- int Partion(int* a, int left, int right)
- {
- int keyi = left;
- while (left < right)
- {
- //右边先走,找小
- while (left < right && a[right] >= a[keyi])
- {
- --right;
- }
- //左边走,找大
- while (left < right && a[left] <= a[keyi])
- {
- ++left;
- }
- Swap(&a[left], &a[right]);
- }
- Swap(&a[keyi], &a[left]);
- return left;
- }
2.挖坑法
基本思想:
选择待排序列的最左值为基准值,将其下标记为坑的下标。当区间左下标小于区间右下标时,先从右开始找比基准值小的值,找到后将其放在当前坑上,并将坑替换到所找位置。再从左开始找比基准值大的值,找到后同样将其放在当前坑上,然后从右开始重复上述步骤,直到左右下标相等。当左右下标相等时,把基准值放到当前坑所在位置。
动图演示:
代码实现:
- //挖坑法
- int Partion(int* a, int left, int right)
- {
- int key = a[left];
- int pivot = left;
- while (left < right)
- {
- //右边先走,找小
- while (left < right && a[right] >= key)
- {
- --right;
- }
- //值覆盖,坑替换
- a[pivot] = a[right];
- pivot = right;
- //左边走,找大
- while (left < right && a[left] <= key)
- {
- ++left;
- }
- //值覆盖,坑替换
- a[pivot] = a[left];
- pivot = left;
- }
- a[pivot] = key;
- return pivot;
- }
3.前后指针法
基本思想:
选择最左值的下标为基准值下标,并设定指向前后位置的两个下标 cur , prev 。使 prev 指向基准值的位置,cur 指向基准值的前一个位置。当 cur <= right,也就是 cur 指向的位置小于等于右区间的位置时,从 cur 开始找比基准值小的值,并将其与 prev 所在位置的前一个交换。当 cur 跳出右区间时,将基准值与 prev 所指向的值交换。
动图演示:
代码实现:
- //前后指针法 ——更推荐
- int Partion(int* a, int left, int right)
- {
- int keyi = left;
- int cur = left + 1;
- int prev = left;
- while (cur <= right)
- {
- //cur找小,把小的换到左边
- if (a[cur] < a[keyi])
- {
- ++prev;
- Swap(&a[cur], &a[prev]);
- }
- ++cur;
- }
- Swap(&a[prev], &a[keyi]);
- return prev;
- }
小结:
hoare版本与挖坑法都需要注意,不管是从右开始找还是从左开始找,始终都要注意左下标要小于右下标,若没有此限定条件,当从任一方向开始找值时,一旦没有找到我们所预想的值,就会导致越界情况产生。
而前后指针法是从一个方向开始,遍历搜索一次待排序列,只需设定一次限定条件。
故这里更推荐使用前后指针法来实现快速排序。
由于每次是以基准值为准,将待排序列分成左右两个子序列,若每次能保证选到的基准值的正确位置在待排序列的中间部分,则每次分序列时,都能大致将待排序列分成均衡的两部分,从而将排序次数减少。
这里使用到三数取中的方法:
再排序前,先将最左值、中间值与最右值进行比较,选出三个数中的中间值,并将其与最左值交换,这样每次以最左值为基准值时,都能选到一个大致在中间部分的数。
代码:
- //三数取中
- int GetMidIndex(int* a, int left, int right)
- {
- int mid = (left + right) / 2;
- if (a[left] > a[mid])
- {
- if (a[mid] > a[right])
- return mid;
- else if (a[left] < a[right])
- return left;
- else
- return right;
- }
- else
- {
- if (a[mid] < a[right])
- return mid;
- else if (a[left] > a[right])
- return left;
- else
- return right;
- }
- }
- //三数取中
- int GetMidIndex(int* a, int left, int right)
- {
- //int mid = (left + right) / 2;
- int mid = left + ((right - left) >> 1);
- if (a[left] > a[mid])
- {
- if (a[mid] > a[right])
- return mid;
- else if (a[left] < a[right])
- return left;
- else
- return right;
- }
- else
- {
- if (a[mid] < a[right])
- return mid;
- else if (a[left] > a[right])
- return left;
- else
- return right;
- }
- }
-
- void Swap(int* px, int* py)
- {
- int tmp = *px;
- *px = *py;
- *py = tmp;
- }
-
- //前后指针法
- int Partion(int* a, int left, int right)
- {
- int midi = GetMidIndex(a, left, right);
- Swap(&a[midi], &a[left]);
-
- int keyi = left;
- int cur = left + 1;
- int prev = left;
- while (cur <= right)
- {
- //cur找小,把小的换到左边
- if (a[cur] < a[keyi] && ++prev != cur)
- {
- Swap(&a[cur], &a[prev]);
- }
- ++cur;
- }
- Swap(&a[prev], &a[keyi]);
- return prev;
- }
-
- void QuickSort(int* a, int left, int right)
- {
- if (left >= right)
- return;
-
- int keyi = Partion3(a, left, right);
-
- QuickSort(a, left, keyi - 1);
- QuickSort(a, keyi + 1, right);
- }
归并排序是将待排序列先分解至单个子序列,再将已有序的子序列合并一个临时数组中,得到完全有序的序列后再拷贝回原数组。即先使左右子序列有序,再将其归并为一个完整的有序序列。
- void _MergeSort(int* a, int left, int right, int* tmp)
- {
- if (left >= right)
- return;
- int mid = left + ((right - left) >> 1);
- _MergeSort(a, left, mid, tmp);
- _MergeSort(a, mid + 1, right, tmp);
-
- //归并
- int begin1 = left, end1 = mid;
- int begin2 = mid + 1, end2 = right;
- int i = left;
- while (begin1 <= end1 && begin2 <= end2)
- {
- if (a[begin1] <= a[begin2])
- {
- tmp[i++] = a[begin1++];
- }
- else
- {
- tmp[i++] = a[begin2++];
- }
- }
- while (begin1 <= end1)
- {
- tmp[i++] = a[begin1++];
- }
- while (begin2 <= end2)
- {
- tmp[i++] = a[begin2++];
- }
-
- //把排序后的元素拷贝回原来的数组
- for (int j = left; j <= right; ++j)
- {
- a[j] = tmp[j];
- }
- }
-
- void MergeSort(int* a, int n)
- {
- int* tmp = (int*)malloc(sizeof(int) * n);
- if (tmp == NULL)
- {
- printf("malloc fail\n");
- exit(-1);
- }
-
- _MergeSort(a, 0, n - 1, tmp);
-
- free(tmp);
- tmp = NULL;
- }
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。