[Algorithms] 分治算法(二分查找, 合并排序, 插入排序, 快速排序(coming))

分治算法::二分查找

template <class T>
int BinarySearch(T a[], const T& x, int n)
{
int left = 0;
int right = n - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (x == a[mid])
return mid;
if (x > a[mid])
left = mid + 1;
else
right = mid - 1;
}
return (-1);
}

时间复杂度: O(lgn): 每执行一次算法的while循环，数组减小为原来的一半

分治算法::插入排序

/* Refer to Intro to Algorithms
* Author: Dooit.Lee@gmail.com
*/
#ifndef _dl_merge_h
#define _dl_merge_h
#include "dl_sort_template.h"
template <class T>
class InsertSort : public SortTemplate<T> {
public:
InsertSort() {}
InsertSort(std::istream& is) : SortTemplate<T>(is) {}
bool doSorting();
};
template <class T>
bool InsertSort<T>::doSorting()
{
SortTemplate<T>::sortedArray.resize(SortTemplate<T>::rawArray.size());
std::copy(SortTemplate<T>::rawArray.begin(),
SortTemplate<T>::rawArray.end(),
SortTemplate<T>::sortedArray.begin());
if (!NDEBUG) { SortTemplate<T>::printRawArray(); }
typename std::vector<T>::iterator j, i;
for (j = SortTemplate<T>::sortedArray.begin() + 1;
j != SortTemplate<T>::sortedArray.end(); j++) {
i = j - 1;
while ((i >= SortTemplate<T>::sortedArray.begin())
&& (*i > *(i + 1))) {
swap(*(i + 1), *i);
--i;
}
}
return true;
}
#endif

时间复杂度: 最坏情况和平均情况都是大O(n^2), 具体查阅Intro to Algorithms

分治算法::合并排序

/* Refer to Intro to Algorithms
* Author: Dooit.Lee@gmail.com
*/
#ifndef _dl_merge_sort_h
#define _dl_merge_sort_h
#include "dl_sort_template.h"
#include <cstddef>
#include <algorithm>
#include <vector>
template <class T>
class MergeSort : public SortTemplate<T> {
public:
MergeSort() {}
MergeSort(std::istream& is) : SortTemplate<T>(is) {}
bool doSorting();
private:
void doMerge(std::vector<T>& A, typename std::vector<T>::iterator p,
typename std::vector<T>::iterator q,
typename std::vector<T>::iterator r);
void doMergeSort(std::vector<T>& A,
typename std::vector<T>::iterator p,
typename std::vector<T>::iterator r);
};
template <class T>
void MergeSort<T>::doMerge(std::vector<T>& A,
typename std::vector<T>::iterator p,
typename std::vector<T>::iterator q,
typename std::vector<T>::iterator r)
{
if (!(p <= q && q < r))
return;
int n1 = q - p + 1;
int n2 = r - q;
std::vector<T> left(n1), right(n2);
std::copy(p, q + 1, left.begin());
std::copy(q + 1, r + 1, right.begin());
std::size_t i = 0, j = 0;
typename std::vector<T>::iterator k; // k = p to r
for (k = p; k <= r; k++) {
if (i < left.size() &&
(j == right.size() || left[i] <= right[j])) {
A[k - A.begin()] = left[i];
i++;
} else if (j < right.size()) {
A[k - A.begin()] = right[j];
j++;
}
}
}
template <class T>
void MergeSort<T>::doMergeSort(std::vector<T>& A,
typename std::vector<T>::iterator p,
typename std::vector<T>::iterator r)
{
if (p < r) {
typename std::vector<T>::iterator q = p + (r - p) / 2;
doMergeSort(A, p, q);
doMergeSort(A, q + 1, r);
doMerge(A, p, q, r);
}
}
template <class T>
bool MergeSort<T>::doSorting()
{
// copy rawArray to sortedArray
SortTemplate<T>::sortedArray.resize(SortTemplate<T>::rawArray.size());
std::copy(SortTemplate<T>::rawArray.begin(),
SortTemplate<T>::rawArray.end(),
SortTemplate<T>::sortedArray.begin());
typename std::vector<T>::iterator p, r;
p = SortTemplate<T>::sortedArray.begin();
r = SortTemplate<T>::sortedArray.end() - 1; // NOTE here substract 1
// do merge-sort
doMergeSort(SortTemplate<T>::sortedArray, p, r);
return true;
}
#endif

时间复杂度: O(n * lgn), 比插入排序的O(n^2) 小很多。