前言

本节介绍set集合的相关算法,各自是并集set_union,差集set_difference,交集set_intersection

和对称差集set_symmetric_difference。这是个函数都提供了两个版本号的函数原型:第一个版本号是採用默认的排序比較方式operator<;第二个版本号是用户通过仿函数comp自行指定排序方式。注意:这四个算法接受的输入区间都是有序的,输出也是有序的。

以下对set算法进行剖析,详细凝视详见源代码,同一时候给出样例说明该算法的功能。本文源代码摘自SGI
STL中的<stl_algo.h>文件。

set算法源代码剖析

/*
下面是计算set集合的相关算法,各自是并集set_union。差集set_difference,交集set_intersection
和对称差集set_symmetric_difference。这是个函数都提供了两个版本号的函数原型
第一个版本号是採用默认的排序比較方式 operator<
第二个版本号是用户通过comp自行指定排序方式
注意:这四个算法接受的输入区间都是有序的,输出也是有序的
*/ // Set algorithms: includes, set_union, set_intersection, set_difference,
// set_symmetric_difference. All of these algorithms have the precondition
// that their input ranges are sorted and the postcondition that their output
// ranges are sorted. // 推断[first1, last1)是否包括[first2, last2),
// 注意: 两个区间要保证有序,默认排序方式是operator<。若要自行定义排序方式,则调用第二版本号;
template <class _InputIter1, class _InputIter2>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type,
_LessThanComparable);
while (__first1 != __last1 && __first2 != __last2)//遍历两个区间
if (*__first2 < *__first1)//first2小于first1表示不包括
return false;//返回FALSE
else if(*__first1 < *__first2)//若first1小于first2
++__first1;//寻找第一个区间下一个位置
else
++__first1, ++__first2;//若first2等于first1,遍历两区间的下一位置 return __first2 == __last2;//若第二个区间先到达尾端。则返回TRUE
} //版本号二:用户通过comp自行指定排序方式
template <class _InputIter1, class _InputIter2, class _Compare>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_BINARY_FUNCTION_CHECK(_Compare, bool,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first2, *__first1))
return false;
else if(__comp(*__first1, *__first2))
++__first1;
else
++__first1, ++__first2; return __first2 == __last2;
} //两个集合区间的并集。相同也有两个版本号
//求存在于[first1, last1)或存在于[first2, last2)内的全部元素
//注意:输入区间必须是已排序
/*
default (1) :默认是operator<操作的排序方式
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result);
custom (2) :用户指定的排序方式
template <class InputIterator1, class InputIterator2,
class OutputIterator, class Compare>
OutputIterator set_union (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp);
*/
//版本号一:默认是operator<操作的排序方式
template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type,
_LessThanComparable);
//两个区间都尚未到达区间尾端,运行下面操作
while (__first1 != __last1 && __first2 != __last2) {
/*
在两区间内分别移动迭代器,首先将元素较小者(如果为A区)记录在目标区result
移动A区迭代器使其前进。同一时候还有一个区的迭代器不变。然后进行一次新的比較,
记录较小值,移动迭代器...直到两区间中有一个到达尾端。若两区间存在元素相等,
默认记录第一区间的元素到目标区result.
*/
if (*__first1 < *__first2) {//first1小于first2
*__result = *__first1;//则result初始值为first1
++__first1;//继续第一个区间的下一个元素位置
}
else if (*__first2 < *__first1) {//first2小于first1
*__result = *__first2;//第二区间元素值记录到目标区
++__first2;//移动第二区间的迭代器
}
else {//若两区间存在相等的元素,把第一区间元素记录到目标区
//同一时候移动两个区间的迭代器
*__result = *__first1;
++__first1;
++__first2;
}
++__result;//更新目标区位置。以备进入下一次记录操作操作
}
/*
仅仅要两区间之中有一个区间到达尾端。就结束上面的while循环
下面将尚未到达尾端的区间剩余的元素复制到目标区
此刻,[first1, last1)和[first2, last2)至少有一个是空区间
*/
return copy(__first2, __last2, copy(__first1, __last1, __result));
}
//版本号二:用户依据仿函数comp指定排序规则
template <class _InputIter1, class _InputIter2, class _OutputIter,
class _Compare>
_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result, _Compare __comp) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_BINARY_FUNCTION_CHECK(_Compare, bool,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
while (__first1 != __last1 && __first2 != __last2) {
if (__comp(*__first1, *__first2)) {
*__result = *__first1;
++__first1;
}
else if (__comp(*__first2, *__first1)) {
*__result = *__first2;
++__first2;
}
else {
*__result = *__first1;
++__first1;
++__first2;
}
++__result;
}
return copy(__first2, __last2, copy(__first1, __last1, __result));
}
/*样例:
#include <iostream> // std::cout
#include <algorithm> // std::set_union, std::sort
#include <vector> // std::vector int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
std::vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
std::vector<int>::iterator it; std::sort (first,first+5); // 5 10 15 20 25
std::sort (second,second+5); // 10 20 30 40 50 it=std::set_union (first, first+5, second, second+5, v.begin());
// 5 10 15 20 25 30 40 50 0 0
v.resize(it-v.begin()); // 5 10 15 20 25 30 40 50 std::cout << "The union has " << (v.size()) << " elements:\n";
for (it=v.begin(); it!=v.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n'; return 0;
}
Output:
The union has 8 elements:
5 10 15 20 25 30 40 50
*/ //两个集合区间的交集,相同也有两个版本号
//求存在于[first1, last1)且存在于[first2, last2)内的全部元素
//注意:输入区间必须是已排序,输出区间的每一个元素的相对排序和第一个区间相对排序相同
/*
default (1) :默认是operator<操作的排序方式
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result); custom (2) :用户指定的排序方式
template <class InputIterator1, class InputIterator2,
class OutputIterator, class Compare>
OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp);
*/
//版本号一:默认是operator<操作的排序方式
template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type,
_LessThanComparable);
//若两个区间都尚未到达尾端。则运行下面操作
while (__first1 != __last1 && __first2 != __last2)
//在两个区间分别移动迭代器,直到遇到相等元素。记录到目标区
//继续移动迭代器...直到两区间之中有到达尾端
if (*__first1 < *__first2) //第一个区间元素小于第二区间元素
++__first1;//移动第一区间的迭代器。此时第二区间的迭代器不变
else if (*__first2 < *__first1) //第二区间的元素小于第一区间元素
++__first2;//移动第二区间元素,此时第一区间的迭代器不变
else {//若第一区间元素等于第二区间元素
*__result = *__first1;//按第一区间的相对排序记录到目标区
//分别移动两区间的迭代器
++__first1;
++__first2;
//更新目标区迭代器,以便继续记录元素
++__result;
}
//若有区间到达尾部,则停止while循环
//此时,返回目标区
return __result;
}
//版本号二:用户依据仿函数comp指定排序规则
template <class _InputIter1, class _InputIter2, class _OutputIter,
class _Compare>
_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result, _Compare __comp) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_BINARY_FUNCTION_CHECK(_Compare, bool,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type); while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first1, *__first2))
++__first1;
else if (__comp(*__first2, *__first1))
++__first2;
else {
*__result = *__first1;
++__first1;
++__first2;
++__result;
}
return __result;
}
/*样例:
#include <iostream> // std::cout
#include <algorithm> // std::set_intersection, std::sort
#include <vector> // std::vector int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
std::vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
std::vector<int>::iterator it; std::sort (first,first+5); // 5 10 15 20 25
std::sort (second,second+5); // 10 20 30 40 50 it=std::set_intersection (first, first+5, second, second+5, v.begin());
// 10 20 0 0 0 0 0 0 0 0
v.resize(it-v.begin()); // 10 20 std::cout << "The intersection has " << (v.size()) << " elements:\n";
for (it=v.begin(); it!=v.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n'; return 0;
}
Output:
The intersection has 2 elements:
10 20
*/ //两个集合区间的差集。相同也有两个版本号
//求存在于[first1, last1)但不存在于[first2, last2)内的全部元素
//注意:输入区间必须是已排序。输出区间的每一个元素的相对排序和第一个区间相对排序相同
/*
default (1) :默认是operator<操作的排序方式
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result); custom (2) :用户指定的排序方式
template <class InputIterator1, class InputIterator2,
class OutputIterator, class Compare>
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp);
*/
//版本号一:默认是operator<操作的排序方式
template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type,
_LessThanComparable);
//若两个区间都尚未到达尾端,则运行下面操作
while (__first1 != __last1 && __first2 != __last2)
/*
在两个区间分别移动迭代器。当第一区间元素等于第二区间元素时。表示两区间共同存在该元素
则同一时候移动迭代器;
当第一区间元素大于第二区间元素时。就让第二区间迭代器前进;
第一区间元素小于第二区间元素时,把第一区间元素记录到目标区
继续移动迭代器...直到两区间之中有到达尾端
*/
if (*__first1 < *__first2) {//第一区间元素小于第二区间元素
*__result = *__first1;//把第一区间元素记录到目标区
++__first1;//移动第一区间迭代器
++__result;//跟新目标区。以便继续记录数据
}
else if (*__first2 < *__first1)//当第一区间的元素大于第二区间的元素
++__first2;//移动第二区间迭代器,注意:这里不记录不论什么元素
else {//若两区间的元素相等时,同一时候移动两区间的迭代器
++__first1;
++__first2;
}
//若第二区间先到达尾端。则把第一区间剩余的元素复制到目标区
return copy(__first1, __last1, __result);
}
//版本号二:用户依据仿函数comp指定排序规则
template <class _InputIter1, class _InputIter2, class _OutputIter,
class _Compare>
_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result, _Compare __comp) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_BINARY_FUNCTION_CHECK(_Compare, bool,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type); while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first1, *__first2)) {
*__result = *__first1;
++__first1;
++__result;
}
else if (__comp(*__first2, *__first1))
++__first2;
else {
++__first1;
++__first2;
}
return copy(__first1, __last1, __result);
}
/*样例:
#include <iostream> // std::cout
#include <algorithm> // std::set_difference, std::sort
#include <vector> // std::vector int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
std::vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
std::vector<int>::iterator it; std::sort (first,first+5); // 5 10 15 20 25
std::sort (second,second+5); // 10 20 30 40 50 it=std::set_difference (first, first+5, second, second+5, v.begin());
// 5 15 25 0 0 0 0 0 0 0
v.resize(it-v.begin()); // 5 15 25 std::cout << "The difference has " << (v.size()) << " elements:\n";
for (it=v.begin(); it!=v.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n'; return 0;
}
Output:
The difference has 3 elements:
5 15 25
*/ //两个集合区间的对称差集,相同也有两个版本号
//求存在于[first1, last1)但不存在于[first2, last2)内的全部元素以及出如今[first2, last2)但不出如今[first1, last1)
//注意:输入区间必须是已排序
/*
default (1) :默认是operator<操作的排序方式
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result); custom (2) :用户指定的排序方式
template <class InputIterator1, class InputIterator2,
class OutputIterator, class Compare>
OutputIterator set_symmetric_difference (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp);
*/
//版本号一:默认是operator<操作的排序方式
template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter
set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_REQUIRES(typename iterator_traits<_InputIter1>::value_type,
_LessThanComparable);
//若两个区间都尚未到达尾端,则运行下面的操作
while (__first1 != __last1 && __first2 != __last2)
/*
情况1:若两区间元素相等,则同一时候移动两区间的迭代器.
情况2:若第一区间的元素小于第二区间元素,则把第一区间元素记录到目标区,且移动第一区间迭代器.
情况3:若第一区间的元素大于第二区间元素,则把第二区间元素记录到目标区,且移动第二区间迭代器.
*/
if (*__first1 < *__first2) {//属于情况2
*__result = *__first1;//把第一区间元素记录到目标区
++__first1;//移动第一区间迭代器.此时第二区间迭代器不变
++__result;
}
else if (*__first2 < *__first1) {//属于情况3
*__result = *__first2;//把第二区间元素记录到目标区
++__first2;//移动第二区间迭代器.此时第一区间迭代器不变
++__result;
}
else {//属于情况1
//同一时候移动两区间的迭代器
++__first1;
++__first2;
}
/*
仅仅要两区间之中有一个区间到达尾端,就结束上面的while循环
下面将尚未到达尾端的区间剩余的元素复制到目标区
此刻,[first1, last1)和[first2, last2)至少有一个是空区间
*/
return copy(__first2, __last2, copy(__first1, __last1, __result));
} //版本号二:用户依据仿函数comp指定排序规则
template <class _InputIter1, class _InputIter2, class _OutputIter,
class _Compare>
_OutputIter
set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
_InputIter2 __first2, _InputIter2 __last2,
_OutputIter __result,
_Compare __comp) {
__STL_REQUIRES(_InputIter1, _InputIterator);
__STL_REQUIRES(_InputIter2, _InputIterator);
__STL_REQUIRES(_OutputIter, _OutputIterator);
__STL_REQUIRES_SAME_TYPE(
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
__STL_BINARY_FUNCTION_CHECK(_Compare, bool,
typename iterator_traits<_InputIter1>::value_type,
typename iterator_traits<_InputIter2>::value_type);
while (__first1 != __last1 && __first2 != __last2)
if (__comp(*__first1, *__first2)) {
*__result = *__first1;
++__first1;
++__result;
}
else if (__comp(*__first2, *__first1)) {
*__result = *__first2;
++__first2;
++__result;
}
else {
++__first1;
++__first2;
}
return copy(__first2, __last2, copy(__first1, __last1, __result));
}
/*样例:
#include <iostream> // std::cout
#include <algorithm> // std::set_symmetric_difference, std::sort
#include <vector> // std::vector int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
std::vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
std::vector<int>::iterator it; std::sort (first,first+5); // 5 10 15 20 25
std::sort (second,second+5); // 10 20 30 40 50 it=std::set_symmetric_difference (first, first+5, second, second+5, v.begin());
// 5 15 25 30 40 50 0 0 0 0
v.resize(it-v.begin()); // 5 15 25 30 40 50 std::cout << "The symmetric difference has " << (v.size()) << " elements:\n";
for (it=v.begin(); it!=v.end(); ++it)
std::cout << ' ' << *it;
std::cout << '\n'; return 0;
}
Output:
The symmetric difference has 6 elements:
5 15 25 30 40 50
*/

參考资料:

《STL源代码剖析》侯捷

STL源代码剖析——STL算法之set集合算法的更多相关文章

  1. STL源代码剖析——STL算法stl_algo.h

    前言 在前面的博文中剖析了STL的数值算法.基本算法和set集合算法.本文剖析STL其它的算法,比如排序算法.合并算法.查找算法等等.在剖析的时候.会针对函数给出一些样例说明函数的使用.源代码出自SG ...

  2. STL源代码剖析——基本算法stl_algobase.h

    前言 在STL中.算法是常常被使用的,算法在整个STL中起到很关键的数据.本节介绍的是一些基本算法,包括equal.fill.fill_n,iter_swap.lexicographical_comp ...

  3. STL源代码剖析 读书总结

    <<STL源代码剖析>> 侯捷著 非常早就买了这本书, 一直没看, 如今在实验室师兄代码的时候发现里面使用了大量泛型编程的内容, 让我有了先看看这本书的想法. 看之前我对于泛型 ...

  4. STL源代码剖析(一) - 内存分配

    Allocaor allocator 指的是空间配置器,用于分配内存.STL中默认使用SGI STL alloc作为STL的内存分配器,尽管未能符合标准规格,但效率上更好.SGI STL也定义有一个符 ...

  5. 《STL源代码剖析》---stl_deque.h阅读笔记(2)

    看完,<STL源代码剖析>---stl_deque.h阅读笔记(1)后.再看代码: G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_deque. ...

  6. STL源代码剖析(二) - 迭代器与traits技法

    提要 先看一段用迭代器的代码: int a[] = {1, 2, 3, 4, 5}; vector<int> v1( a, a+5); vector<int>::iterato ...

  7. STL源代码分析——STL算法remove删除算法

    前言 因为在前文的<STL算法剖析>中,源代码剖析许多.不方便学习,也不方便以后复习,这里把这些算法进行归类.对他们单独的源代码剖析进行解说.本文介绍的STL算法中的remove删除算法. ...

  8. STL源代码分析——STL算法merge合并算法

    前言 因为在前文的<STL算法剖析>中.源代码剖析许多.不方便学习.也不方便以后复习,这里把这些算法进行归类.对他们单独的源代码剖析进行解说.本文介绍的STL算法中的merge合并算法. ...

  9. STL源代码分析——STL算法sort排序算法

    前言 因为在前文的<STL算法剖析>中,源代码剖析许多,不方便学习,也不方便以后复习.这里把这些算法进行归类,对他们单独的源代码剖析进行解说.本文介绍的STL算法中的sort排序算法,SG ...

随机推荐

  1. django实现github第三方本地登录

    1.安装 pip install social-auth-app-django 2.生成Client ID和Client Secret 3.修改setting.py INSTALLED_APPS = ...

  2. docker run redis

    #拉取 Redis 镜像 C:\Users\WYJ>docker pull redis Using default tag: latest latest: Pulling from librar ...

  3. pwnable.kr 之 passcode write up

    先看源码: #include <stdio.h> #include <stdlib.h> void login(){ int passcode1; int passcode2; ...

  4. 构造MaxTree

    链接:https://www.nowcoder.com/questionTerminal/a502c7c3c65e41fdaf65eec9e0654dcb 来源:牛客网 [编程题]构造MaxTree ...

  5. c++值传递和引用及指针传递区别

    以下程序各有何问题? ***************************************************************************************** ...

  6. Druid连接池简单配置

    Druid是阿里巴巴开源平台上的一个项目,整个项目由数据库连接池.插件框架和SQL解析器组成.该项目主要是为了扩展JDBC的一些限制,可以让程序员实现一些特殊的需求,比如向密钥服务请求凭证.统计SQL ...

  7. httpclient调用webservice接口的方法实例

    这几天在写webservice接口,其他的调用方式要生成客户端代码,比较麻烦,不够灵活,今天学习了一下httpclient调用ws的方式,感觉很实用,话不多说,上代码 http://testhcm.y ...

  8. zoj 1240

    IBM Minus One Time Limit: 2 Seconds      Memory Limit: 65536 KB You may have heard of the book '2001 ...

  9. [转]ORA-38500: USING CURRENT LOGFILE option not available without stand

    标签: oracle 10g 数据库 ora-38500 it 分类: IT author:skate time :2009/08/03 在dataguard启用实时恢复的时候,报如下错误: ORA- ...

  10. 飞行路线(BZOJ 2763)

    题目描述 Alice和Bob现在要乘飞机旅行,他们选择了一家相对便宜的航空公司.该航空公司一共在n个城市设有业务,设这些城市分别标记为0到n-1,一共有m种航线,每种航线连接两个城市,并且航线有一定的 ...