前段时间,研究了下STL,实现了其中的算法过程中,发现STL把模板和算法分离的策略简直
太强大了,废话不说了,将主要代码贴下:
/*
* ccAlgorithm.h
* c++_common_codes
*
* Created by xichen on 12-2-11.
* Copyright 2012 cc_team. All rights reserved.
*
*/
#ifndef CC_ALGORITHM_H
#define CC_ALGORITHM_H
#include "ccCommon.h"
#include "ccBaseSTL.h"
#include <exception>
#define MACRO_SWAP(pa, pb, type) \
type temp = *pa, *pa = *pb, *pb = temp;
// it will get the count of number num in number from 1 to n;
// for example, getNumberCount(9, 1) = 1, getNumberCount(12, 1) = 5.
unsigned long getNumberCount(int n, int num);
template<class InputIterator, class Func>
inline
Func cc_for_each(InputIterator begin, InputIterator end, Func & func)
{
for(; begin != end; ++begin)
func(*begin);
return func;
}
// cc_find
template <class Iter, class EqualValue>
inline
Iter cc_find(Iter first, Iter end, const EqualValue & value)
{
while(*first != value && first != end)
++first;
return first;
}
// cc_find_if
template <class Iter, class PredicateClass>
Iter cc_find_if(Iter begin, Iter end, const PredicateClass & pred)
{
for(; begin != end; ++begin)
{
if(pred(*begin))
return begin;
}
return begin;
}
// cc_adjacent_find // not test ????
template <class Iter>
Iter cc_adjacent_find(Iter begin, Iter end)
{
for(; begin != end; ++begin)
if(*begin == *(begin + 1))
return begin;
return begin;
}
// cc_adjacent_find // not test ????
template <class Iter, class PredicateEqual>
Iter cc_adjacent_find(Iter begin, Iter end, const PredicateEqual & pred)
{
for(; begin != end; ++begin)
if(pred(*begin) == pred(*(begin + 1)))
return begin;
return begin;
}
// cc_find_first_of // not test ????
template <class Iter1, class Iter2>
Iter1 cc_find_first_of(Iter1 begin, Iter1 end, Iter2 beginTwo, Iter2 endTwo)
{
for(; begin != end; ++begin)
{
for(; beginTwo != endTwo; ++beginTwo)
if(*begin == *beginTwo)
return begin;
}
return begin;
}
// cc_find_first_of // not test ????
template <class Iter1, class Iter2, class PredicateEqual>
Iter1 cc_find_first_of(Iter1 begin, Iter1 end,
Iter2 beginTwo, Iter2 endTwo,
const PredicateEqual & pred)
{
for(; begin != end; ++begin)
{
for(; beginTwo != endTwo; ++beginTwo)
if(pred(*begin) == pred(*beginTwo))
return begin;
}
return begin;
}
// cc_count // not test ????
template <class Iter, class PredicateValue>
unsigned int cc_count(Iter begin, Iter end, const PredicateValue & pred)
{
unsigned int cnt = 0;
for(; begin != end; ++begin)
if(*begin == pred)
++cnt;
return cnt;
}
// cc_count // not test ????
template <class Iter, class PredicateValue, class Size>
void cc_count(Iter begin, Iter end,
const PredicateValue & pred,
Size & n)
{
unsigned int cnt = 0;
for(; begin != end; ++begin)
if(*begin == pred)
++cnt;
n = cnt;
}
// cc_count_if // not test ????
template <class Iter, class PredicateTrue>
unsigned int cc_count_if(Iter begin, Iter end, const PredicateTrue & pred)
{
unsigned int cnt = 0;
for(; begin != end; ++begin)
if(pred(*begin))
++cnt;
return cnt;
}
// cc_count_if // not test ????
template <class Iter, class PredicateTrue, class Size>
void cc_count_if(Iter begin, Iter end,
const PredicateTrue & pred,
Size & n)
{
unsigned int cnt = 0;
for(; begin != end; ++begin)
if(pred(*begin))
++cnt;
n = cnt;
}
// cc_mismatch // not test ????
template <class Iter1, class Iter2>
pair<Iter1, Iter2> cc_mismatch(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin)
{
for(; firstBegin != firstEnd; ++firstBegin, ++secondBegin)
{
if(*firstBegin == *secondBegin)
continue;
}
return pair<Iter1, Iter2>(firstBegin, secondBegin);
}
// cc_mismatch // not test ????
template <class Iter1, class Iter2, class PredicateEqual>
pair<Iter1, Iter2> cc_mismatch(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin,
const PredicateEqual & pred)
{
for(; firstBegin != firstEnd; ++firstBegin, ++secondBegin)
{
if(pred(*firstBegin) == pred(*secondBegin))
continue;
}
return pair<Iter1, Iter2>(firstBegin, secondBegin);
}
// cc_equal // not test ????
template <class Iter1, class Iter2>
bool cc_equal(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin)
{
for (; firstBegin != firstEnd; ++firstBegin, ++firstEnd)
{
if(*firstBegin != *firstEnd)
return false;
}
return true;
}
// cc_equal // not test ????
template <class Iter1, class Iter2, class PredicateEqual>
bool cc_equal(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin,
const PredicateEqual & pred)
{
for (; firstBegin != firstEnd; ++firstBegin, ++firstEnd)
{
if(pred(*firstBegin) != pred(*firstEnd))
return false;
}
return true;
}
// cc_search // not test ????
template <class Iter1, class Iter2>
Iter1 cc_search(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd)
{
Iter1 temp1 = firstBegin;
for (; temp1 != firstEnd; ++temp1)
{
int i = 0;
Iter2 temp2 = secondBegin;
for (; temp2 != secondEnd; ++temp2)
{
if(*(temp1 + i) != *(temp2 + i))
break;
}
if(temp2 == secondEnd)
break;
}
return temp1;
}
// cc_search // not test ????
template <class Iter1, class Iter2, class PredicateEqual>
Iter1 cc_search(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
const PredicateEqual & pred)
{
Iter1 temp1 = firstBegin;
for (; temp1 != firstEnd; ++temp1)
{
int i = 0;
Iter2 temp2 = secondBegin;
for (; temp2 != secondEnd; ++temp2)
{
if(pred(*(temp1 + i)) != pred(*(temp2 + i)))
break;
}
if(temp2 == secondEnd)
break;
}
return temp1;
}
// cc_search_n // not test ????
template <class Iter, class CountType, class ValueType>
Iter cc_search_n(Iter begin, Iter end, CountType cnt, const ValueType & value)
{
for(; begin != (end - cnt + 1); ++begin)
{
int i = 0;
for(; i < cnt; ++i)
if(*(begin + i) != value)
break;
if(i == cnt)
break;
}
return begin;
}
// cc_search_n // not test ????
template <class Iter, class CountType, class ValueType, class PredicateEqual>
Iter cc_search_n(Iter begin, Iter end,
CountType cnt, const ValueType & value,
const PredicateEqual & pred)
{
for(; begin != (end - cnt + 1); ++begin)
{
int i = 0;
for(; i < cnt; ++i)
if(pred(*(begin + i)) != value)
break;
if(i == cnt)
break;
}
return begin;
}
// cc_find_end // not test ????
template <class Iter1, class Iter2>
Iter1 cc_find_end(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd)
{
Iter1 temp1 = firstEnd - (secondEnd - secondBegin);
for (; temp1 != (firstBegin - 1); --temp1)
{
int i = 0;
Iter2 temp2 = secondBegin;
for (; temp2 != secondEnd; ++temp2)
{
if(*(temp1 + i) != *(temp2 + i))
break;
}
if(temp2 == secondEnd)
break;
}
if(temp1 == (firstBegin - 1))
temp1 = firstEnd;
return temp1;
}
// cc_find_end // not test ????
template <class Iter1, class Iter2, class PredicateEqual>
Iter1 cc_find_end(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
const PredicateEqual & pred)
{
Iter1 temp1 = firstEnd - (secondEnd - secondBegin);
for (; temp1 != (firstBegin - 1); --temp1)
{
int i = 0;
Iter2 temp2 = secondBegin;
for (; temp2 != secondEnd; ++temp2)
{
if(pred(*(temp1 + i)) != pred(*(temp2 + i)))
break;
}
if(temp2 == secondEnd)
break;
}
if(temp1 == (firstBegin - 1))
temp1 = firstEnd;
return temp1;
}
// cc_copy // not test ????
template <class Iter1, class Iter2>
Iter2 cc_copy(Iter1 firstBegin, Iter1 firstEnd, Iter2 result)
{
for (; firstBegin != firstEnd; ++firstBegin, ++result)
{
*result = *firstBegin;
}
return result;
}
// cc_copy_n // not test ????
template <class Iter1, class Size, class Iter2>
Iter2 cc_copy_n(Iter1 firstBegin, Size cnt, Iter2 result)
{
for (int i = 0; i < cnt; ++i)
{
*(result + i) = *(firstBegin + i);
}
return result + cnt;
}
// cc_copy_backward // not test ????
template <class Iter1, class Iter2>
Iter2 cc_copy_backward(Iter1 begin, Iter1 end, Iter2 result)
{
for (int i = 1; i < end - begin + 1; ++i)
{
*(result - i) = *(end - i);
}
return (result - (end - begin));
}
// cc_swap // not test ????
template <class Iter1, class Iter2>
inline
void cc_iter_swap(Iter1 a, Iter2 b)
{
cc_swap(*a, *b);
}
// cc_swap_ranges // not test ????
template <class Iter1, class Iter2>
Iter2 cc_swap_ranges(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin)
{
int temp = firstEnd - firstBegin;
for (int i = 0; i < temp; ++i)
{
cc_swap(*(firstBegin + i), *(secondBegin + i));
}
return (secondBegin + temp);
}
// cc_transform // not test ????
template <class Iter1, class Iter2, class FunctionClass>
Iter2 cc_transform(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, const FunctionClass & func)
{
int temp = firstEnd - firstBegin;
for (int i = 0; i < temp; ++i)
{
*(secondBegin + i) = func(*(firstBegin + i));
}
return (secondBegin + temp);
}
// cc_transform // not test ????
template <class Iter1, class Iter2, class ResultIter, class FunctionClass>
Iter2 cc_transform(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin,
ResultIter result,
const FunctionClass & func)
{
int temp = firstEnd - firstBegin;
for (int i = 0; i < temp; ++i)
{
*(result + i) = func(*(firstBegin + i), *(secondBegin + i));
}
return (result + temp);
}
// cc_replace
template <class T>
void cc_replace(T * begin, T * end, const T & replacedObj, const T & replaceObj)
{
while(begin != end)
{
if(*begin == replacedObj)
*begin = replaceObj;
++begin;
}
}
// cc_replace // not test ????
template <class Iter, class T>
void cc_replace(Iter begin, Iter end, const T & oldValue, const T & newValue)
{
for(; begin != end; ++begin)
if(*begin == oldValue)
*begin = newValue;
}
// cc_replace_if // not test ????
template <class Iter, class PredicateClass, class T>
void cc_replace_if(Iter begin, Iter end, const PredicateClass & pred, const T & newValue)
{
for(; begin != end; ++begin)
if(pred(*begin))
*begin = newValue;
}
// cc_replace_copy // not test ????
template <class Iter1, class Iter2, class T>
Iter2 cc_replace_copy(Iter1 begin, Iter1 end, Iter2 result, const T & oldValue, const T & newValue)
{
int temp = end - begin;
for (int i = 0; i < temp; ++i)
{
if(*(begin + i) == oldValue)
*(result + i) = newValue;
else
*(result + i) = *(begin + i);
}
return (result + temp);
}
// cc_replace_copy_if // not test ????
template <class Iter1, class Iter2, class FuncClass, class T>
Iter2 cc_replace_copy_if(Iter1 begin, Iter1 end, Iter2 result,
const FuncClass & func, const T & newValue)
{
int temp = end - begin;
for (int i = 0; i < temp; ++i)
{
if(func(*(begin + i)))
*(result + i) = newValue;
else
*(result + i) = *(begin + i);
}
return (result + temp);
}
// cc_fill // not test ????
template <class Iter, class T>
void cc_fill(Iter begin, Iter end, const T & value)
{
for (; begin != end; ++begin)
{
*begin = value;
}
}
// cc_fill_n // not test ????
template <class Iter, class Size, class T>
Iter cc_fill_n(Iter begin, Size n, const T & value)
{
for (int i = 0; i < n; ++i)
{
*(begin + i) = value;
}
return begin + n;
}
// cc_generate // not test ????
template <class Iter, class GenerateClass>
void cc_generate(Iter begin, Iter end, const GenerateClass & gen)
{
for (; begin != end; ++begin)
{
*begin = gen();
}
}
// cc_generate_n // not test ????
template <class Iter, class Size, class GenerateClass>
Iter cc_generate_n(Iter begin, Size n, const GenerateClass & gen)
{
FOR(n)
{
*(begin + i) = gen();
}
return begin + n;
}
// cc_remove
template <class Iter, class T>
Iter cc_remove(Iter begin, Iter end, const T & value)
{
int moveSize = 0;
for (; begin != end; ++begin)
{
if(*begin == value)
++moveSize;
else
*(begin - moveSize) = *begin;
}
return (end - moveSize);
}
// cc_remove_if // not test ????
template <class Iter, class PredicateTrue>
Iter cc_remove_if(Iter begin, Iter end, const PredicateTrue & pred)
{
int moveSize = 0;
for (; begin != end; ++begin)
{
if(pred(*begin))
++moveSize;
else
*(begin - moveSize) = *begin;
}
return (end - moveSize);
}
// cc_remove_copy // not test ????
template <class Iter, class OutputIter, class T>
OutputIter cc_remove_copy(Iter begin, Iter end, OutputIter result, const T & value)
{
int copyIndex = 0;
for (; begin != end; ++begin)
{
if(*begin != value)
{
*(result + copyIndex) = *begin;
++copyIndex;
}
}
return result + copyIndex;
}
// cc_remove_copy_if // not test ????
template <class Iter, class OutputIter, class PredicateClass>
OutputIter cc_remove_copy_if(Iter begin, Iter end, OutputIter result, const PredicateClass & pred)
{
int copyIndex = 0;
for (; begin != end; ++begin)
{
if(!pred(*begin))
{
*(result + copyIndex) = *begin;
++copyIndex;
}
}
return result + copyIndex;
}
// cc_unique // not test ????
template <class Iter>
Iter cc_unique(Iter begin, Iter end)
{
int uniqueEndIndex = 1;
int i;
for(Iter temp = begin + 1; temp != end; ++temp)
{
for(i = 0; i < uniqueEndIndex; ++i)
if(*(begin + i) == *temp)
break;
if(i == uniqueEndIndex)
*(begin + uniqueEndIndex) = *temp, ++uniqueEndIndex;
}
return begin + uniqueEndIndex;
}
// cc_unique // not test ????
template <class Iter, class PredicateFunc>
Iter cc_unique(Iter begin, Iter end, const PredicateFunc & func)
{
int uniqueEndIndex = 1;
for(Iter temp = begin + 1; temp != end; ++temp)
{
if(func(*temp, *(temp - 1)))
continue;
else
*(begin + uniqueEndIndex) = *temp, ++uniqueEndIndex;
}
return begin + uniqueEndIndex;
}
// cc_unique_copy // not test ????
template <class Iter, class OutputIter>
OutputIter cc_unique_copy(Iter begin, Iter end, OutputIter result)
{
int uniqueEndIndex = 1;
int i;
*result = *begin;
for(Iter temp = begin + 1; temp != end; ++temp)
{
for(i = 0; i < uniqueEndIndex; ++i)
if(*(begin + i) == *temp)
break;
if(i == uniqueEndIndex)
*(result + uniqueEndIndex) = *temp, ++uniqueEndIndex;
}
return result + uniqueEndIndex;
}
// cc_unique_copy // not test ????
template <class Iter, class OutputIter, class PredicateFunc>
OutputIter cc_unique_copy(Iter begin, Iter end, OutputIter result, const PredicateFunc & func)
{
int uniqueEndIndex = 1;
*result = *begin;
for(Iter temp = begin + 1; temp != end; ++temp)
{
if(pred(*temp, *(temp - 1)))
continue;
else
*(result + uniqueEndIndex) = *temp, ++uniqueEndIndex;
}
return result + uniqueEndIndex;
}
// cc_reverse
template <class Iter>
void cc_reverse(Iter begin, Iter end)
{
int i = (end - begin) / 2;
Iter loopEnd = begin + i;
int j = 1;
for(; begin != loopEnd; ++begin, ++j)
cc_swap(*begin, *(end - j));
}
// cc_reverse_copy // not test ????
template <class Iter, class OutputIter>
OutputIter cc_reverse_copy(Iter begin, Iter end, OutputIter result)
{
int temp = end - begin;
int j = 0;
for(Iter copyIter = end - 1; copyIter != begin - 1; --copyIter, ++j)
*(result + j) = *copyIter;
return result + temp;
}
// cc_rotate
// To reduce the time complexity, it will alloc memory for temp storage
template <class Iter>
Iter cc_rotate(Iter begin, Iter mid, Iter end)
{
if(mid == begin || mid == end)
return begin;
int cnt = end - begin;
Iter allocMem = (Iter)::malloc(sizeof(*begin) * cnt);
if(allocMem == NULL)
throw std::bad_alloc();
for(int i = 0; i < mid - begin; ++i)
*(allocMem + (cnt - (mid - begin + i))) = *(begin + i);
for(int i = mid - begin; i < cnt; ++i)
*(allocMem + (i - (mid - begin))) = *(begin + i);
int i = 0;
for(; begin != end; ++begin, ++i)
*begin = *(allocMem + i);
::free(allocMem);
return begin + (end - mid);
}
// cc_rotate_copy // not test ????
template <class Iter, class OutputIter>
OutputIter cc_rotate_copy(Iter begin, Iter mid, Iter end, OutputIter result)
{
int cnt = end - begin;
for(int i = 0; i < mid - begin; ++i)
*(result + (cnt - (mid - begin + i))) = *(begin + i);
for(int i = mid - begin; i < cnt; ++i)
*(result + (i - (mid - begin))) = *(begin + i);
return result + (end - begin);
}
// cc_random_shuffle // not test ????
template <class Iter>
void cc_random_shuffle(Iter begin, Iter end)
{
int cnt = end - begin;
for(Iter temp = begin; temp != end; ++temp)
cc_iter_swap(temp, begin + rand() % cnt);
}
// cc_random_shuffle // not test ????
template <class Iter, class RandomClass>
void cc_random_shuffle(Iter begin, Iter end, const RandomClass & randomObj)
{
int cnt = end - begin;
for(Iter temp = begin; temp != end; ++temp)
cc_iter_swap(temp, begin + randomObj() % cnt);
}
// cc_random_sample // not test ????
template <class Iter, class OutputIter>
OutputIter cc_random_sample(Iter begin, Iter end, OutputIter outBegin, OutputIter outEnd)
{
int cnt = end - begin;
int outCnt = outEnd - outBegin;
int minValue = cc_min(cnt, outCnt);
int currRandomCnt = 0;
for (int i = 0; i < minValue; ++i)
{
loop:
Iter temp = begin + rand() % cnt;
for (int j = 0; j < currRandomCnt; ++j)
{
if(*temp == *(outBegin +j))
goto loop;
}
*(outBegin + currRandomCnt) = *temp;
++currRandomCnt;
}
return (outBegin + minValue);
}
// cc_random_sample // not test ????
template <class Iter, class OutputIter, class RandomGenClass>
OutputIter cc_random_sample(Iter begin, Iter end,
OutputIter outBegin, OutputIter outEnd,
const RandomGenClass & randGen)
{
int cnt = end - begin;
int outCnt = outEnd - outBegin;
int minValue = cc_min(cnt, outCnt);
int currRandomCnt = 0;
for (int i = 0; i < minValue; ++i)
{
loop:
Iter temp = begin + randGen() % cnt;
for (int j = 0; j < currRandomCnt; ++j)
{
if(*temp == *(outBegin +j))
goto loop;
}
*(outBegin + currRandomCnt) = *temp;
++currRandomCnt;
}
return (outBegin + minValue);
}
// cc_random_sample_n // not test ????
template <class Iter, class OutputIter, class Size>
OutputIter cc_random_sample_n(Iter begin, Iter end, OutputIter outBegin, Size n)
{
int cnt = end - begin;
int minValue = cc_min(cnt, n);
int currRandomCnt = 0;
for (int i = 0; i < minValue; ++i)
{
loop:
Iter temp = begin + rand() % cnt;
for (int j = 0; j < currRandomCnt; ++j)
{
if(*temp == *(outBegin +j))
goto loop;
}
*(outBegin + currRandomCnt) = *temp;
++currRandomCnt;
}
return (outBegin + minValue);
}
// cc_random_sample_n // not test ????
template <class Iter, class OutputIter, class Size, class RandomGenClass>
OutputIter cc_random_sample_n(Iter begin, Iter end,
OutputIter outBegin, Size n,
const RandomGenClass & randGen)
{
int cnt = end - begin;
int minValue = cc_min(cnt, n);
int currRandomCnt = 0;
for (int i = 0; i < minValue; ++i)
{
loop:
Iter temp = begin + randGen() % cnt;
for (int j = 0; j < currRandomCnt; ++j)
{
if(*temp == *(outBegin +j))
goto loop;
}
*(outBegin + currRandomCnt) = *temp;
++currRandomCnt;
}
return (outBegin + minValue);
}
// cc_partition // not test ????
template <class Iter, class PredicateClass>
Iter cc_partition(Iter begin, Iter end, const PredicateClass & pred)
{
int rightSideCnt = 0;
for (Iter temp = begin; temp != (end - rightSideCnt); ++temp)
{
if(!pred(*temp))
cc_iter_swap(temp, end - rightSideCnt), ++rightSideCnt, --temp;
}
return end - rightSideCnt;
}
// cc_stable_partition // not test ????
template <class Iter, class PredicateClass>
Iter cc_stable_partition(Iter begin, Iter end, const PredicateClass & pred)
{
int canReplacePos = 0;
for (Iter temp = begin; temp != end; ++temp)
{
if(temp + 1 != end)
{
if(pred(*temp))
++canReplacePos;
if(!pred(*temp) && pred(*(temp + 1)))
{
int currPos = temp + 1 - begin;
for(; currPos > canReplacePos; --currPos)
cc_iter_swap(begin + currPos, begin + currPos - 1);
++canReplacePos;
}
}
}
return begin + canReplacePos;
}
// cc_sort
// it uses quick sort algorithm
// it uses cc_quick_sort_partition func
template<class Iter>
void cc_sort(Iter begin, Iter end)
{
Iter mid = cc_quick_sort_partition(begin, end);
if(mid != begin && mid != end)
{
cc_sort(begin, mid);
cc_sort(mid + 1, end);
}
}
// cc_quick_sort_partition
// it is used by cc_sort
template <class Iter>
Iter cc_quick_sort_partition(Iter begin, Iter end)
{
Iter basePos = begin;
int rightSideCnt = 1;
for(Iter temp = begin + 1; temp != end - rightSideCnt + 1; ++temp)
{
if(*basePos < *temp)
cc_iter_swap(temp, end - rightSideCnt), ++rightSideCnt, --temp;
else if(*temp < *basePos)
cc_iter_swap(temp, basePos), basePos = temp;
}
return basePos;
}
// cc_quick_sort_partition // not test ????
// it is used by cc_sort
template <class Iter, class PredicateLess>
Iter cc_quick_sort_partition(Iter begin, Iter end, const PredicateLess & pred)
{
Iter basePos = begin;
int rightSideCnt = 1;
for(Iter temp = begin + 1; temp != end - rightSideCnt + 1; ++temp)
{
if(!pred(*temp, *basePos))
cc_iter_swap(temp, end - rightSideCnt), ++rightSideCnt, --temp;
else
cc_iter_swap(temp, basePos), basePos = temp;
}
return basePos;
}
// cc_sort // not test ????
// it uses quick sort algorithm
// it uses cc_quick_sort_partition func
template<class Iter, class PredicateLess>
void cc_sort(Iter begin, Iter end, const PredicateLess & pred)
{
Iter mid = cc_quick_sort_partition(begin, end, pred);
if(mid != begin && mid != end)
{
cc_sort(begin, mid, pred);
cc_sort(mid + 1, end, pred);
}
}
// cc_stable_sort
// it uses quick sort algorithm
// it uses cc_stable_quick_sort_partition func
template<class Iter>
void cc_stable_sort(Iter begin, Iter end)
{
Iter mid = cc_stable_quick_sort_partition(begin, end);
if(mid != begin && mid != end)
{
cc_stable_sort(begin, mid);
cc_stable_sort(mid + 1, end);
}
}
// cc_stable_quick_sort_partition
// it is used by cc_stable_sort
template <class Iter>
Iter cc_stable_quick_sort_partition(Iter begin, Iter end)
{
Iter basePos = begin;
for (Iter temp = begin; temp != end; ++temp)
{
if(*temp < *basePos)
{
int currPos = temp - basePos;
for(; currPos > 0; --currPos)
cc_iter_swap(basePos + currPos, basePos + currPos - 1);
++basePos;
}
}
return basePos;
}
// cc_stable_sort
// it uses quick sort algorithm
// it uses cc_stable_quick_sort_partition func
template<class Iter, class PredicateLess>
void cc_stable_sort(Iter begin, Iter end, const PredicateLess & pred)
{
Iter mid = cc_stable_quick_sort_partition(begin, end, pred);
if(mid != begin && mid != end)
{
cc_stable_sort(begin, mid, pred);
cc_stable_sort(mid + 1, end, pred);
}
}
// cc_stable_quick_sort_partition
// it is used by cc_stable_sort
template <class Iter, class PredicateLess>
Iter cc_stable_quick_sort_partition(Iter begin, Iter end, const PredicateLess & pred)
{
Iter basePos = begin;
for (Iter temp = begin; temp != end; ++temp)
{
if(pred(*temp, *basePos))
{
int currPos = temp - basePos;
for(; currPos > 0; --currPos)
cc_iter_swap(basePos + currPos, basePos + currPos - 1);
++basePos;
}
}
return basePos;
}
// cc_is_sorted // not test ????
template <class Iter>
bool cc_is_sorted(Iter begin, Iter end)
{
for (; begin != end - 1; ++begin)
{
if(*(begin + 1) < *begin)
return false;
}
return true;
}
// cc_is_sorted // not test ????
template <class Iter, class PredicateLess>
bool cc_is_sorted(Iter begin, Iter end, const PredicateLess & pred)
{
for (; begin != end - 1; ++begin)
{
if(pred(*(begin + 1), *begin))
return false;
}
return true;
}
// cc_exist // not test ????
template <class Iter, class EqualValue>
inline
bool cc_exist(Iter first, Iter end, const EqualValue & value)
{
return (cc_find(first, end, value) != end);
}
// cc_lower_bound // not test ???? // not coding ok
template <class Iter, class T>
Iter cc_lower_bound(Iter begin, Iter end, const T & value)
{
Iter temp = begin + (end - begin) / 2;
while(!(value < *temp) || *(temp + 1) < value)
{
if(temp == end - 1)
{
if(!(value < *temp))
{
++temp;
break;
}
}
}
return begin;
}
// cc_lower_bound // not test ???? // not coding ok
template <class Iter, class T, class PredicateTrue>
Iter cc_lower_bound(Iter begin, Iter end, const T & value, const PredicateTrue & pred)
{
for (; begin != end; ++begin)
{
if(!pred(*begin, value))
break;
}
return begin;
}
// cc_upper_bound // not test ???? // not coding ok
template <class Iter, class T>
Iter cc_upper_bound(Iter begin, Iter end, const T & value)
{
for (; begin != end; ++begin)
{
if(value < *begin)
break;
}
return begin;
}
// cc_upper_bound // not test ???? // not coding ok
template <class Iter, class T, class PredicateTrue>
Iter cc_upper_bound(Iter begin, Iter end, const T & value, const PredicateTrue & pred)
{
for (; begin != end; ++begin)
{
if(pred(value, *begin))
break;
}
return begin;
}
// cc_equal_range // not test ????
template <class Iter, class T>
pair<Iter, Iter> cc_equal_range(Iter begin, Iter end, const T & value)
{
return pair<Iter, Iter>(cc_lower_bound(begin, end, value),
cc_upper_bound(begin, end, value));
}
// cc_equal_range // not test ????
template <class Iter, class T, class OrderingClass>
pair<Iter, Iter> cc_equal_range(Iter begin, Iter end, const T & value, const OrderingClass & order)
{
return pair<Iter, Iter>(cc_lower_bound(begin, end, value, order),
cc_upper_bound(begin, end, value, order));
}
// cc_binary_search_bool // not test ????
template <class Iter, class T>
bool cc_binary_search_bool(Iter begin, Iter end, const T & value)
{
return cc_binary_search(begin, end, value) != NULL;
}
// cc_binary_search_bool // not test ???? // not coding ok
template <class Iter, class T, class PredicateEqual>
bool cc_binary_search_bool(Iter begin, Iter end, const T & value, const PredicateEqual & pred)
{
return cc_binary_search(begin, end, value, pred) != NULL;
}
// cc_merge
template <class Iter1, class Iter2, class ResultIter>
ResultIter cc_merge(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin, Iter2 secondEnd, ResultIter result)
{
Iter2 curr = secondBegin;
for (Iter1 temp1 = firstBegin; temp1 != firstEnd; ++temp1)
{
for (Iter2 temp2 = curr; temp2 != secondEnd; ++temp2)
{
if(*temp1 < *temp2)
{
*result++ = *temp1;
break;
}
else
{
*result++ = *temp2;
curr = temp2 + 1;
continue;
}
}
if(curr == secondEnd)
*result++ = *temp1;
}
return result;
}
// cc_merge // not test ????
template <class Iter1, class Iter2, class ResultIter, class PredicateLess>
ResultIter cc_merge(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin, Iter2 secondEnd,
ResultIter result, const PredicateLess & lessFunc)
{
Iter2 curr = secondBegin;
for (Iter1 temp1 = firstBegin; temp1 != firstEnd; ++temp1)
{
for (Iter2 temp2 = curr; temp2 != secondEnd; ++temp2)
{
if(lessFunc(*temp1, *temp2))
{
*result++ = *temp1;
break;
}
else
{
*result++ = *temp2;
curr = temp2 + 1;
continue;
}
}
if(curr == secondEnd)
*result++ = *temp1;
}
return result;
}
// cc_inplace_merge // not test ???? // not coding ok
template <class Iter1>
void cc_inplace_merge(Iter1 begin, Iter1 mid, Iter1 end)
{
Iter1 curr = mid;
Iter1 result = begin;
for (Iter1 temp1 = begin; temp1 != mid; ++temp1)
{
for (Iter1 temp2 = mid; temp2 != end; ++temp2)
{
if(*temp2 < *temp1)
{
cc_iter_swap(result, temp2);
++temp1;
--temp2;
++result;
continue;
}
else
{
*result++ = *temp2;
curr = temp2 + 1;
continue;
}
}
if(curr == end)
*result++ = *temp1;
}
return result;
}
// cc_includes
template <class Iter1, class Iter2>
bool cc_includes(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin, Iter2 secondEnd)
{
Iter1 currTemp1 = firstBegin;
for(Iter2 temp2 = secondBegin; temp2 != secondEnd; ++temp2)
{
for (Iter1 temp1 = currTemp1; temp1 != firstEnd; ++temp1)
{
if(!(*temp1 < *temp2) && !(*temp2 < *temp1))
{
++currTemp1;
break;
}
}
}
if(currTemp1 - firstBegin == secondEnd - secondBegin)
return true;
return false;
}
// cc_includes // not test ????
template <class Iter1, class Iter2, class PredicateLess>
bool cc_includes(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
const PredicateLess & pred)
{
Iter1 currTemp1 = firstBegin;
for(Iter2 temp2 = secondBegin; temp2 != secondEnd; ++temp2)
{
for (Iter1 temp1 = currTemp1; temp1 != firstEnd; ++temp1)
{
if(!pred(*temp1, *temp2) && !pred(*temp2, *temp1))
{
++currTemp1;
break;
}
}
}
if(currTemp1 - firstBegin == secondEnd - secondBegin)
return true;
return false;
}
// cc_set_union // not test ????
template <class Iter1, class Iter2, class OutputIter>
OutputIter cc_set_union(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result)
{
Iter2 currTemp2 = secondBegin;
int breakFlag;
for (Iter1 temp1 = firstBegin; temp1 != firstEnd; ++temp1)
{
breakFlag = 0;
for (Iter2 temp2 = currTemp2; temp2 != secondEnd; ++temp2)
{
if(*temp1 < *temp2)
{
*result++ = *temp1;
breakFlag = 1;
break;
}
else if (*temp2 < *temp1)
{
*result++ = *temp2;
++currTemp2;
breakFlag = 0;
continue;
}
else
{
*result++ = *temp1;
++currTemp2;
breakFlag = 1;
break;
}
}
if(!breakFlag && currTemp2 == secondEnd)
*result++ = *temp1;
}
return result;
}
// cc_set_union // not test ????
template <class Iter1, class Iter2, class OutputIter, class PredicateLess>
OutputIter cc_set_union(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result,
const PredicateLess & pred)
{
Iter2 currTemp2 = secondBegin;
int breakFlag;
for (Iter1 temp1 = firstBegin; temp1 != firstEnd; ++temp1)
{
breakFlag = 0;
for (Iter2 temp2 = currTemp2; temp2 != secondEnd; ++temp2)
{
if(pred(*temp1, *temp2))
{
*result++ = *temp1;
breakFlag = 1;
break;
}
else if(pred(*temp2, *temp1))
{
*result++ = *temp2;
++currTemp2;
breakFlag = 0;
continue;
}
else
{
*result++ = *temp1;
++currTemp2;
breakFlag = 1;
break;
}
}
if(!breakFlag && currTemp2 == secondEnd)
*result++ = *temp1;
}
return result;
}
// cc_set_intersection
template <class Iter1, class Iter2, class OutputIter>
OutputIter cc_set_intersection(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result)
{
Iter2 currTemp2 = secondBegin;
for (Iter1 temp1 = firstBegin; temp1 != firstEnd; ++temp1)
{
for (Iter2 temp2 = currTemp2; temp2 != secondEnd; ++temp2)
{
if(*temp1 < *temp2)
{
break;
}
else if(*temp2 < *temp1)
{
++currTemp2;
continue;
}
else
{
*result++ = *temp1;
++currTemp2;
break;
}
}
}
return result;
}
// cc_set_intersection // not test ????
template <class Iter1, class Iter2, class OutputIter, class PredicateLess>
OutputIter cc_set_intersection(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result,
const PredicateLess & lessFunc)
{
Iter2 currTemp2 = secondBegin;
for (Iter1 temp1 = firstBegin; temp1 != firstEnd; ++temp1)
{
for (Iter2 temp2 = currTemp2; temp2 != secondEnd; ++temp2)
{
if(lessFunc(*temp1, *temp2))
{
break;
}
else if(lessFunc(*temp2, *temp1))
{
++currTemp2;
continue;
}
else
{
*result++ = *temp1;
++currTemp2;
break;
}
}
}
return result;
}
// cc_set_difference
template <class Iter1, class Iter2, class OutputIter>
OutputIter cc_set_difference(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result)
{
while(firstBegin != firstEnd && secondBegin != secondEnd)
{
if(*firstBegin < *secondBegin)
{
*result++ = *firstBegin;
++firstBegin;
}
else if(*secondBegin < *firstBegin)
{
++secondBegin;
}
else
{
++firstBegin;
++secondBegin;
}
}
while(firstBegin != firstEnd)
*result++ = *firstBegin, ++firstBegin;
return result;
}
// cc_set_difference
template <class Iter1, class Iter2, class OutputIter, class PredicateLess>
OutputIter cc_set_difference(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result,
const PredicateLess & pred)
{
while(firstBegin != firstEnd && secondBegin != secondEnd)
{
if(pred(*firstBegin, secondBegin))
{
*result++ = *firstBegin;
++firstBegin;
}
else if(pred(*secondBegin, firstBegin))
{
++secondBegin;
}
else
{
++firstBegin;
++secondBegin;
}
}
while(firstBegin != firstEnd)
*result++ = *firstBegin, ++firstBegin;
return result;
}
// cc_set_symmetric_difference
template <class Iter1, class Iter2, class OutputIter>
OutputIter cc_set_symmetric_difference(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result)
{
while(firstBegin != firstEnd && secondBegin != secondEnd)
{
if(*firstBegin < *secondBegin)
{
*result++ = *firstBegin;
++firstBegin;
}
else if(*secondBegin < *firstBegin)
{
*result++ = *secondBegin;
++secondBegin;
}
else
{
++firstBegin;
++secondBegin;
}
}
while(firstBegin != firstEnd)
*result++ = *firstBegin, ++firstBegin;
while(secondBegin != secondEnd)
*result++ = *secondBegin, ++secondBegin;
return result;
}
// cc_set_symmetric_difference // not test ????
template <class Iter1, class Iter2, class OutputIter, class PredicateLess>
OutputIter cc_set_symmetric_difference(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
OutputIter result,
const PredicateLess & pred)
{
while(firstBegin != firstEnd && secondBegin != secondEnd)
{
if(pred(*firstBegin, *secondBegin))
{
*result++ = *firstBegin;
++firstBegin;
}
else if(pred(*secondBegin, *firstBegin))
{
*result++ = *secondBegin;
++secondBegin;
}
else
{
++firstBegin;
++secondBegin;
}
}
while(firstBegin != firstEnd)
*result++ = *firstBegin, ++firstBegin;
while(secondBegin != secondEnd)
*result++ = *secondBegin, ++secondBegin;
return result;
}
// cc_lexicographically_compare // not test ????
template <class Iter1, class Iter2>
bool cc_lexicographically_compare(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd)
{
while(firstBegin != firstEnd && secondBegin != secondEnd)
{
if(*firstBegin < *secondBegin)
return true;
else if(*secondBegin < *firstBegin)
{
return false;
}
++firstBegin, ++secondBegin;
}
if(firstBegin == firstEnd && secondBegin == secondEnd)
return false;
else if(firstBegin == firstEnd && secondBegin != secondEnd)
return true;
else
return false;
}
// cc_lexicographically_compare // not test ????
template <class Iter1, class Iter2, class PredicateLess>
bool cc_lexicographically_compare(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd,
const PredicateLess & pred)
{
while(firstBegin != firstEnd && secondBegin != secondEnd)
{
if(pred(*firstBegin, *secondBegin))
return true;
else if(pred(*secondBegin, *firstBegin))
{
return false;
}
++firstBegin, ++secondBegin;
}
if(firstBegin == firstEnd && secondBegin == secondEnd)
return false;
else if(firstBegin == firstEnd && secondBegin != secondEnd)
return true;
else
return false;
}
// cc_lexicographically_compare // not test ????
template <class Iter1, class Iter2>
int cc_lexicographically_compare_3way(Iter1 firstBegin, Iter1 firstEnd,
Iter2 secondBegin, Iter2 secondEnd)
{
while(firstBegin != firstEnd && secondBegin != secondEnd)
{
if(*firstBegin < *secondBegin)
return -1;
else if(*secondBegin < *firstBegin)
{
return 1;
}
++firstBegin, ++secondBegin;
}
if(firstBegin == firstEnd && secondBegin == secondEnd)
return 0;
else if(firstBegin == firstEnd && secondBegin != secondEnd)
return -1;
else
return 1;
}
// cc_itoa // not test ????
template <class Iter, class T>
void cc_itoa(Iter begin, Iter end, const T & value)
{
unsigned cnt = end - begin;
for(int i = 0; i < cnt; ++i)
{
*(begin + 1) = value + i;
}
}
// cc_accumulate // not test ????
template <class Iter, class T>
T cc_accumulate(Iter begin, Iter end, T init)
{
for (; begin != end; ++begin)
{
init = init + *begin;
}
return init;
}
// cc_accumulate // not test ????
template <class Iter, class T, class AccumulateFunc>
T cc_accumulate(Iter begin, Iter end, T init, const AccumulateFunc & accu)
{
for (; begin != end; ++begin)
{
init = accu(init, *begin);
}
return init;
}
// cc_inner_product // not test ????
template <class Iter1, class Iter2, class T>
T cc_inner_product(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin, T init)
{
Iter1 beginBackup = firstBegin;
for (; firstBegin != firstEnd; ++firstBegin)
{
init = init + *firstBegin * *(secondBegin + (firstBegin - beginBackup));
}
return init;
}
// cc_inner_product // not test ????
template <class Iter1, class Iter2, class T, class InnerProduct1, class InnerProduct2>
T cc_inner_product(Iter1 firstBegin, Iter1 firstEnd, Iter2 secondBegin,
T init,
const InnerProduct1 & innerProd1,
const InnerProduct2 & innerProd2)
{
Iter1 beginBackup = firstBegin;
for (; firstBegin != firstEnd; ++firstBegin)
{
init = innerProd1(init, innerProd2(*firstBegin, *(secondBegin + (firstBegin - beginBackup))));
}
return init;
}
// cc_partial_sum // not test ????
template <class Iter, class OutputIter>
OutputIter cc_partial_sum(Iter begin, Iter end, OutputIter result)
{
*result++ = *begin++;
int cnt = end - begin;
for (int i = 1; i < cnt; ++i)
{
*(result + i) = *(result + i - 1) + *begin;
}
return result;
}
// cc_partial_sum // not test ????
template <class Iter, class OutputIter, class BinaryFunc>
OutputIter cc_partial_sum(Iter begin, Iter end, OutputIter result, const BinaryFunc & func)
{
*result++ = *begin++;
int cnt = end - begin;
for (int i = 1; i < cnt; ++i)
{
*(result + i) = func(*(result + i - 1), *begin);
}
return result;
}
// cc_adjacent_difference // not test ????
template <class Iter, class OutputIter>
OutputIter cc_adjacent_difference(Iter begin, Iter end, OutputIter result)
{
*result++ = *begin++;
for (; begin != end; ++begin)
{
*result++ = *begin - *(begin - 1);
}
return result;
}
// cc_adjacent_difference // not test ????
template <class Iter, class OutputIter, class BinaryFunc>
OutputIter cc_adjacent_difference(Iter begin, Iter end, OutputIter result, const BinaryFunc & func)
{
*result++ = *begin++;
for (; begin != end; ++begin)
{
*result++ = func(*begin, *(begin - 1));
}
return result;
}
// cc_power // not test ????
template <class T, class Size>
T cc_power(T x, Size n)
{
T result = 1;
for (int i = 0; i < n; ++i)
{
result = result * x;
}
return result;
}
// cc_power // not test ????
template <class T, class Size, class BinaryFunc>
T cc_power(T x, Size n, const BinaryFunc & func)
{
T result = 1;
for (int i = 0; i < n; ++i)
{
result = func(result, x);
}
return result;
}
#endif
很多基本的算法并不复杂,就像简单的加减法一样。
注:里面有标识为// not test的代码,表示没有很好地进行过测试,如果有问题,欢迎指正。