整理了一下六种排序算法,分别是:
- 冒泡排序
- 插入排序
- 选择排序
- 快速排序
- 归并排序
- 堆排序
代码都经过了Lintcode的整数排序题目的测试。如下:
class Solution {
public:
/**
* @param A an integer array
* @return void
*/
void sortIntegers(vector<int>& A) {
// Write your code here
const int len = A.size();
// bubbleSort(A, len);
// insertSort(A, len);
// selectSort(A, len);
// quickSort(A, 0, len-1);
// mergeSort(A, 0, len-1);
maxHeapSort(A, len-1);
}
void bubbleSort(vector<int>& A, int len)
{
for (int i = 0; i < len; i++)
{
bool isSwap = false;
for (int j = 1; j < len - i; j++)
{
if (A[j-1] > A[j])
{
swap(A[j-1], A[j]);
isSwap = true;
}
}
if (!isSwap)
return;
}
}
bool insertSort(vector<int>& A, int len)
{
for (int i = 1; i < len; i++)
{
for (int j = i; j > 0 && A[j-1] > A[j]; j--)
{
swap(A[j-1], A[j]);
}
}
}
void selectSort(vector<int>& A, int len)
{
for (int i = 0; i < len; i++)
{
int minIndex = i;
for (int j = i + 1; j < len; j++)
{
if (A[j] < A[minIndex])
{
minIndex = j;
}
}
swap(A[i], A[minIndex]);
}
}
void quickSort(vector<int>& A, int start, int end)
{
if (start >= end)
return;
int p = partition(A, start, end);
quickSort(A, start, p-1);
quickSort(A, p+1, end);
}
int partition(vector<int>& A, int start, int end)
{
int lo = start;
int hi = start;
while (hi < end)
{
if (A[hi] < A[end])
{
swap(A[hi++], A[lo++]);
}
else
{
hi++;
}
}
swap(A[lo], A[end]);
return lo;
}
void mergeSort(vector<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 merge(vector<int>& A, int start, int mid, int end)
{
int lo = start;
int hi = mid + 1;
const int len = end - start + 1;
int tmp[len];
int k = 0;
while (lo <= mid && hi <= end)
{
if (A[lo] < A[hi])
{
tmp[k++] = A[lo++];
}
else
{
tmp[k++] = A[hi++];
}
}
while (lo <= mid)
tmp[k++] = A[lo++];
while (hi <= end)
tmp[k++] = A[hi++];
for (int i = 0; i < k; i++)
A[start+i] = tmp[i];
}
void maxHeapSort(vector<int>& A, int end)
{
makeMaxHeap(A, end);
for (int i = end; i > 0; i--)
{
swap(A[0], A[i]);
maxHeapFixDown(A, 0, i-1);
}
}
void makeMaxHeap(vector<int>& A, int end)
{
for (int i = (end - 1) / 2; i >= 0; i--)
{
maxHeapFixDown(A, i, end);
}
}
void maxHeapFixDown(vector<int>& A, int start, int end)
{
int par = start;
int maxChild = par * 2 + 1;
while (maxChild <= end)
{
if (maxChild + 1 <= end && A[maxChild] < A[maxChild+1])
maxChild++;
if (A[par] > A[maxChild])
return;
swap(A[par], A[maxChild]);
par = maxChild;
maxChild = par * 2 + 1;
}
}
};