#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdio.h>
#include <cstring>
#if _MSC_VER
#define snprintf _snprintf
#endif
using namespace std;
long get_a_target_long()
{
/******变量声明********/
long target = 0;
/**********************/
cout << "targer (0~" << RAND_MAX << "):";
cin >> target;
return target;
}
string get_a_target_string()
{
/******变量声明********/
long target = 0;
char buf[10];
/**********************/
cout << "targer (0~" << RAND_MAX << "):";
cin >> target;
snprintf(buf, 10, "%d", target);
return string(buf);
}
//与后面的比较函数中回调参数对应
int compareLongs(const void* l1, const void* l2)
{
return (*(long*)l1 - *(long*)l2);
}
int compareStrings(const void* s1, const void* s2)
{
if (*(string*)s1 > *(string*)s2)
return 1;
if (*(string*)s1 < *(string*)s2)
return -1;
return 0;
}
/************************************************************************/
/*测试数组 */
/************************************************************************/
#include <array>
#include <iostream>
#include <algorithm>
#include <ctime>
#include <cstdlib>
#define ASIZE 500000 //由于数组声明需要使用常量值,故在这里写死
//500000个long---4000000Byte---4M
//数组Array测试
namespace jj01
{
void test_array()
{
cout << "
test_array()*******" << endl;
/******变量声明:数组初始********/
array<long, ASIZE> arr;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < ASIZE; i++)
arr[i] = rand(); //0-32767,所以有重复
cout << "inti array use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "array.size:" << arr.size() << endl; //获取数组大小
cout << "array.front:" << arr.front() << endl; //获取数组首元素
cout << "array.back:" << arr.back() << endl; //获取数组尾元素
cout << "array.data:" << arr.data() << endl; //获取数组首地址
/******变量声明:获取我们要查询的数********/
long target = get_a_target_long();
timeStart = clock();
//qsort和bsearch是C编译器自带的快速排序和二分查找算法
qsort(arr.data(), ASIZE, sizeof(long), compareLongs);
/******变量声明:pItem是我们获取的返回的元素地址********/
long* pItem =
(long*)bsearch(&target, arr.data(), ASIZE, sizeof(long), compareLongs);
cout << "qsort()+bsearch(),milli-seconds:" << clock() - timeStart << endl;
if (pItem != NULL)
cout << "found:" << *pItem << endl;
else
cout << "not found!" << endl;
random_shuffle(arr.begin(), arr.end()); //乱序
//STL排序查找算法
timeStart = clock();
sort(arr.begin(), arr.end());
/******变量声明:flag布尔型判断是否找到数据********/
bool flag =
binary_search(arr.begin(), arr.end(), target);
cout << "sort()+binary_search(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << *pItem << endl;
else
cout << "not found!" << endl;
//使用find方法进行查找
timeStart = clock();
auto pI = find(arr.begin(), arr.end(), target);
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
}
}
#include <vector>
#include <string>
//容器vector测试
namespace jj02
{
void test_vector(long& v_size)
{
cout << "
test_vector()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:vector初始********/
vector<string> vec;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < v_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
vec.push_back(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti vector use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "vector.size:" << vec.size() << endl; //获取vector大小
cout << "vector.front:" << vec.front() << endl; //获取vector首元素
cout << "vector.back:" << vec.back() << endl; //获取vector尾元素
cout << "vector.data:" << vec.data() << endl; //获取vector首地址
cout << "vector.capacity:" << vec.capacity() << endl; //获取vector容量
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//STL排序查找算法
timeStart = clock();
sort(vec.begin(), vec.end());
/******变量声明:flag布尔型判断是否找到数据********/
bool flag =
binary_search(vec.begin(), vec.end(), target);
cout << "sort()+binary_search(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << target << endl;
else
cout << "not found!" << endl;
random_shuffle(vec.begin(), vec.end()); //乱序
timeStart = clock();
//qsort和bsearch是C编译器自带的快速排序和二分查找算法
qsort(vec.data(), vec.size(), sizeof(string), compareStrings);
/******变量声明:pItem是我们获取的返回的元素地址********/
string* pItem =
(string*)bsearch(&target, vec.data(), vec.size(), sizeof(string), compareStrings);
cout << "qsort()+bsearch(),milli-seconds:" << clock() - timeStart << endl;
if (pItem != NULL)
cout << "found:" << *pItem << endl;
else
cout << "not found!" << endl;
//使用find方法进行查找
timeStart = clock();
auto pI = find(vec.begin(), vec.end(), target);
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
}
}
#include <list>
namespace jj03
{
void test_list(long& l_size)
{
cout << "
test_list()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:list初始********/
list<string> lt;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < l_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
lt.push_back(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti vector use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "list.size:" << lt.size() << endl; //获取list大小
cout << "list.max_size:" << lt.max_size() << endl; //获取list所允许的最大长度
cout << "list.front:" << lt.front() << endl; //获取list首元素
cout << "list.back:" << lt.back() << endl; //获取list尾元素
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//注意list是链表实现,算法中sort不能使用,sort用在顺序表中
//qsort和bsearch是C编译器自带的快速排序和二分查找算法
//但是list不维护data首地址(一直变),所以这个查找方法不能使用
//使用find方法进行查找:find不需要进行排序,查找时间可能较短<因为是迭代查找>(若是一次查找的话,耗时少,但是多次查找,那么先排序效率更好)
timeStart = clock();
auto pItem = find(lt.begin(), lt.end(), target); //auto变量用得好
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (pItem!=lt.end())
cout << "found:" << *pItem << endl;
else
cout << "not found!" << endl;
//使用list自带sort方法进行排序,节省时间 需要排序,所以耗时长于find
timeStart = clock();
lt.sort(); //使用list自带sort方法进行排序,节省时间
cout << "list.sort(),milli-seconds:" << clock() - timeStart << endl;
timeStart = clock();
/******变量声明:flag布尔型判断是否找到数据********/
bool flag =
binary_search(lt.begin(), lt.end(), target);
cout << "binary_search(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << target << endl;
else
cout << "not found!" << endl;
}
}
#include <forward_list>
namespace jj04
{
void test_flist(long& l_size)
{
cout << "
test_list()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:forward_list初始********/
forward_list<string> fl;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < l_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
fl.push_front(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti vector use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "list.max_size:" << fl.max_size() << endl; //获取forward_list所允许的最大长度
cout << "list.front:" << fl.front() << endl; //获取forward_list首元素
//为了效率,forward_list并不维护size和back
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//注意forward_list是链表实现,算法中sort不能使用,sort用在顺序表中
//qsort和bsearch是C编译器自带的快速排序和二分查找算法
//但是forward_list不维护data首地址(一直变),所以这个查找方法不能使用
//使用find方法进行查找:find不需要进行排序,查找时间可能较短<因为是迭代查找>(若是一次查找的话,耗时少,但是多次查找,那么先排序效率更好)
timeStart = clock();
auto pItem = find(fl.begin(), fl.end(), target); //auto变量用得好
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (pItem != fl.end())
cout << "found:" << *pItem << endl;
else
cout << "not found!" << endl;
//使用forward_list自带sort方法进行排序,节省时间 需要排序,所以耗时长于find
timeStart = clock();
fl.sort(); //使用list自带sort方法进行排序,节省时间
/******变量声明:flag布尔型判断是否找到数据********/
cout << "list.sort()milli-seconds:" << clock() - timeStart << endl;
timeStart = clock();
bool flag =
binary_search(fl.begin(), fl.end(), target);
cout << "binary_search(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << target << endl;
else
cout << "not found!" << endl;
}
}
#include <deque>
namespace jj05
{
void test_deque(long& d_size)
{
cout << "
test_deque()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:vector初始********/
deque<string> deq;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < d_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
deq.push_back(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti deque use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "deque.size:" << deq.size() << endl; //获取vector大小
cout << "deque.max_size:" << deq.max_size() << endl; //获取vector尾元素
cout << "deque.front:" << deq.front() << endl; //获取vector首元素
cout << "deque.back:" << deq.back() << endl; //获取vector尾元素
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//STL排序查找算法
timeStart = clock();
sort(deq.begin(), deq.end());
/******变量声明:flag布尔型判断是否找到数据********/
bool flag =
binary_search(deq.begin(), deq.end(), target);
cout << "sort()+binary_search(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << target << endl;
else
cout << "not found!" << endl;
random_shuffle(deq.begin(), deq.end()); //乱序
//使用find方法进行查找
timeStart = clock();
auto pI = find(deq.begin(), deq.end(), target);
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (flag != false)
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
//等待一段时间释放,因为在destroy中
}
}
#include <stack>
namespace jj06
{
void test_stack(long& s_size)
{
cout << "
test_stack()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:vector初始********/
stack<string> stk;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < s_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
stk.push(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti stack use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "stack.size:" << stk.size() << endl; //获取stack大小
cout << "stack.top:" << stk.top() << endl; //获取stack栈顶元素
stk.pop(); //出栈一个元素
cout << "stack.size:" << stk.size() << endl; //获取stack大小
cout << "stack.top:" << stk.top() << endl; //获取栈顶尾元素
}
}
#include <queue>
namespace jj07
{
void test_queue(long& q_size)
{
cout << "
test_queue()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:vector初始********/
queue<string> que;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < q_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
que.push(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti queue use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "queue.size:" << que.size() << endl; //获取stack大小
cout << "queue.front:" << que.front() << endl; //获取stack栈顶元素
cout << "queue.back:" << que.back() << endl; //获取stack栈顶元素
que.pop(); //出栈一个元素
cout << "queue.size:" << que.size() << endl; //获取stack大小
cout << "queue.top:" << que.front() << endl; //获取栈顶尾元素
cout << "queue.back:" << que.back() << endl; //获取stack栈顶元素
}
}
#include <set>
//测试muliset-->元素可以重复
namespace jj08
{
void test_multiset(long& ms_size)
{
cout << "
test_multiset()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:vector初始********/
multiset<string> ms;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < ms_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
ms.insert(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti multiset use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "multiset.size:" << ms.size() << endl; //获取multiset大小
cout << "multiset.max_size:" << ms.max_size() << endl; //获取multiset所允许最大长度
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//使用::find方法进行查找
timeStart = clock();
auto pI = find(ms.begin(), ms.end(), target);
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != ms.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
//使用muliset.find查找
timeStart = clock();
pI = ms.find(target);
cout << "muliset.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != ms.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
}
}
#include <map>
//测试multimap-->元素可以重复
namespace jj09
{
void test_multimap(long& mm_size)
{
cout << "
test_multimap()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:multimap初始********/
multimap<long,string> mm;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < mm_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
mm.insert(pair<long,string>(i,string(buf)));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti multimap use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "multimap.size:" << mm.size() << endl; //获取multimap大小
cout << "multimap.max_size:" << mm.max_size() << endl; //获取multimap所允许最大长度
/******变量声明:获取我们要查询的数********/
long target = get_a_target_long(); //根据key查找
//multimap没有全局::find方法可用,::find找值,multimap找键,两者不同,不可以混用
//使用muliset.find查找
timeStart = clock();
auto pI = mm.find(target);
cout << "multimap.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != mm.end())
cout << "found:" << (*pI).first<<":" << (*pI).second << endl;
else
cout << "not found!" << endl;
}
}
#include <set>
//测试set-->元素不可以重复
namespace jj10
{
void test_set(long& s_size)
{
cout << "
test_set()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:set初始********/
set<string> s;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < s_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
s.insert(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti set use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "set.size:" << s.size() << endl; //获取set大小
cout << "set.max_size:" << s.max_size() << endl; //获取set所允许最大长度
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//使用::find方法进行查找
timeStart = clock();
auto pI = find(s.begin(), s.end(), target);
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != s.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
//使用muliset.find查找
timeStart = clock();
pI = s.find(target);
cout << "set.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != s.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
}
}
#include <map>
//测试map-->元素不可以重复
namespace jj11
{
void test_map(long& m_size)
{
cout << "
test_map()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:map初始********/
map<long, string> m;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < m_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
m.insert(pair<long, string>(i, string(buf)));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti map use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "map.size:" << m.size() << endl; //获取map大小
cout << "map.max_size:" << m.max_size() << endl; //获取map允许最大长度
/******变量声明:获取我们要查询的数********/
long target = get_a_target_long(); //根据key查找
//map没有全局::find方法可用,::find找值,map找键,两者不同,不可以混用
//使用map.find查找
timeStart = clock();
auto pI = m.find(target);
cout << "map.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != m.end())
cout << "found:" << (*pI).first << ":" << (*pI).second << endl;
else
cout << "not found!" << endl;
}
}
#include <unordered_set>
//测试unordered_multiset-->元素可以重复
namespace jj12
{
void test_unordered_multiset(long& us_size)
{
cout << "
test_unordered_multiset()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:unordered_multiset初始********/
unordered_multiset<string> ums;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < us_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
ums.insert(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti unordered_multiset use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "unordered_multiset.size:" << ums.size() << endl; //获取unordered_multiset大小
cout << "unordered_multiset.max_size:" << ums.max_size() << endl; //获取unordered_multiset允许最大长度
cout << "unordered_multiset.bucket_count:" << ums.bucket_count() << endl; //获取篮子数--表长
cout << "unordered_multiset.load_factor:" << ums.load_factor() << endl; //获取加载因子
cout << "unordered_multiset.max_load_factoe:" << ums.max_load_factor() << endl; //获取最大加载因子--1
cout << "unordered_multiset.max_bucket_count:" << ums.max_bucket_count() << endl; //获取存在最大篮子数--表长
//打印前20个篮子
for (int i = 0; i < 20; i++)
cout << "Key #" << i << " has " <<
ums.bucket_size(i) //该篮子中有几个元素
<< " elements" << endl;
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//使用::find方法进行查找
timeStart = clock();
auto pI = find(ums.begin(), ums.end(), target);
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != ums.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
//使用unordered_multiset.find查找
timeStart = clock();
pI = ums.find(target); //比::find块得多,直接定位查询,
cout << "unordered_multiset.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != ums.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
}
}
#include <unordered_map>
//测试unordered_multimap-->元素可以重复
namespace jj13
{
void test_unordered_multimap(long& mm_size)
{
cout << "
test_unordered_multimap()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:unordered_multimap初始********/
unordered_multimap<long, string> umm;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < mm_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
umm.insert(pair<long, string>(i, string(buf)));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti unordered_multimap use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "unordered_multimap.size:" << umm.size() << endl; //获取unordered_multimap大小
cout << "unordered_multimap.max_size:" << umm.max_size() << endl; //获取unordered_multimap所允许最大
cout << "unordered_multimap.bucket_count:" << umm.bucket_count() << endl; //获取篮子数--表长
cout << "unordered_multimap.load_factor:" << umm.load_factor() << endl; //获取加载因子
cout << "unordered_multimap.max_load_factoe:" << umm.max_load_factor() << endl; //获取最大加载因子--1
cout << "unordered_multimap.max_bucket_count:" << umm.max_bucket_count() << endl; //获取存在最大篮子数--表长
//打印前20个篮子
for (int i = 0; i < 20; i++)
cout << "Key #" << i << " has " <<
umm.bucket_size(i) //该篮子中有几个元素
<< " elements" << endl;
/******变量声明:获取我们要查询的数********/
long target = get_a_target_long(); //根据key查找
//unordered_multimap没有全局::find方法可用,::find找值,multimap找键,两者不同,不可以混用
//使用unordered_multimap.find查找
timeStart = clock();
auto pI = umm.find(target);
cout << "unordered_multimap.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != umm.end())
cout << "found:" << (*pI).first << ":" << (*pI).second << endl;
else
cout << "not found!" << endl;
}
}
#include <unordered_set>
//测试unordered_set-->元素不可以重复
namespace jj14
{
void test_unordered_set(long& us_size)
{
cout << "
test_unordered_set()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:unordered_set初始********/
unordered_set<string> us;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < us_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
us.insert(string(buf));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti unordered_multiset use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "unordered_set.size:" << us.size() << endl; //获取unordered_set大小
cout << "unordered_set.max_size:" << us.max_size() << endl; //获取unordered_set允许最大
cout << "unordered_set.bucket_count:" << us.bucket_count() << endl; //获取篮子数--表长
cout << "unordered_set.load_factor:" << us.load_factor() << endl; //获取加载因子
cout << "unordered_set.max_load_factoe:" << us.max_load_factor() << endl; //获取最大加载因子--1
cout << "unordered_set.max_bucket_count:" << us.max_bucket_count() << endl; //获取存在最大篮子数--表长
//打印前20个篮子
for (int i = 0; i < 20; i++)
cout << "Key #" << i << " has " <<
us.bucket_size(i) //该篮子中有几个元素
<< " elements" << endl;
/******变量声明:获取我们要查询的数********/
string target = get_a_target_string();
//使用::find方法进行查找
timeStart = clock();
auto pI = find(us.begin(), us.end(), target);
cout << "::find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != us.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
//使用unordered_set.find查找
timeStart = clock();
pI = us.find(target); //比::find块得多,直接定位查询,
cout << "unordered_set.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != us.end())
cout << "found:" << *pI << endl;
else
cout << "not found!" << endl;
}
}
#include <unordered_map>
//测试unordered_map-->元素不可以重复
namespace jj15
{
void test_unordered_map(long& um_size)
{
cout << "
test_unordered_map()*******" << endl;
/******变量声明:数组初始********/
char buf[10];
/******变量声明:unordered_multimap初始********/
unordered_map<long, string> um;
/******变量声明:记录时间********/
clock_t timeStart = clock(); //开始时间
for (long i = 0; i < um_size; i++)
{
try
{
snprintf(buf, 10, "%d", rand());
um.insert(pair<long, string>(i, string(buf)));
}
catch (exception& e)
{
cout << e.what() << endl;
cout << "Max_size:" << i << endl;
abort(); //终止
}
}
cout << "inti unordered_map use milli-seconds:" << (clock() - timeStart) << endl; //获取初始化数组耗时
cout << "unordered_map.size:" << um.size() << endl; //获取unordered_map大小
cout << "unordered_map.max_size:" << um.max_size() << endl; //获取unordered_map允许最大
cout << "unordered_map.bucket_count:" << um.bucket_count() << endl; //获取篮子数--表长
cout << "unordered_map.load_factor:" << um.load_factor() << endl; //获取加载因子
cout << "unordered_map.max_load_factoe:" << um.max_load_factor() << endl; //获取最大加载因子--1
cout << "unordered_map.max_bucket_count:" << um.max_bucket_count() << endl; //获取存在最大篮子数--表长
//打印前20个篮子
for (int i = 0; i < 20; i++)
cout << "Key #" << i << " has " <<
um.bucket_size(i) //该篮子中有几个元素
<< " elements" << endl;
/******变量声明:获取我们要查询的数********/
long target = get_a_target_long(); //根据key查找
//unordered_map没有全局::find方法可用,::find找值,unordered_map找键,两者不同,不可以混用
//使用unordered_map.find查找
timeStart = clock();
auto pI = um.find(target);
cout << "unordered_map.find(),milli-seconds:" << clock() - timeStart << endl;
if (pI != um.end())
cout << "found:" << (*pI).first << ":" << (*pI).second << endl;
else
cout << "not found!" << endl;
}
}
void main()
{
/******变量声明:choose用于选择所测试的容器********/
int choose;
cout << "select:";
cin >> choose;
/******变量声明:size用于创建容器大小********/
long size;
cout << "create size:";
cin >> size;
switch (choose)
{
case 1:
jj01::test_array();
break;
case 2:
jj02::test_vector(size);
break;
case 3:
jj03::test_list(size);
break;
case 4:
jj04::test_flist(size);
break;
case 5:
jj05::test_deque(size);
break;
case 6:
jj06::test_stack(size);
break;
case 7:
jj07::test_queue(size);
break;
case 8:
jj08::test_multiset(size);
break;
case 9:
jj09::test_multimap(size);
break;
case 10:
jj10::test_set(size);
break;
case 11:
jj11::test_map(size);
break;
case 12:
jj12::test_unordered_multiset(size);
break;
case 13:
jj13::test_unordered_multimap(size);
break;
case 14:
jj14::test_unordered_set(size);
break;
case 15:
jj15::test_unordered_map(size);
break;
default:
break;
}
system("pause");
}