1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
#ifdef _WIN32
#include <windows.h>
struct Chrono
{
LARGE_INTEGER liStart;
LARGE_INTEGER liStop;
void Start()
{
QueryPerformanceCounter(&liStart);
}
double Stop()
{
QueryPerformanceCounter(&liStop);
LONGLONG llTimeDiff = liStop.QuadPart - liStart.QuadPart;
// To get duration in milliseconds
LARGE_INTEGER Frequency;
QueryPerformanceFrequency(&Frequency);
return llTimeDiff * 1000.0 / (double) Frequency.QuadPart;
}
};
#else
#include <time>
struct Chrono
{
clock_t stopTime;
clock_t startTime;
void Start()
{
startTime = clock();
}
double Stop()
{
stopTime = clock();
return (stopTime - startTime) / (CLOCKS_PER_SEC / (double) 1000.0);
}
};
#endif
#include <vector>
#include <algorithm>
#include <set>
#include <iostream>
using namespace std;
template <typename T>
double loadvect(T* dtab,int n,bool tosort)
{
vector<T> v1;
Chrono c;
c.Start();
for(int i=0;i<n;i++) v1.push_back(dtab[i]);
if(tosort) sort(v1.begin(),v1.end());
return c.Stop();
}
template <typename T>
double loadvectrange(T* dtab,int n,bool tosort)
{
Chrono c;
c.Start();
vector<T> v2(dtab, dtab+n);
if(tosort) sort(v2.begin(),v2.end());
return c.Stop();
}
template <typename T>
double loadset(T* dtab,int n, bool tosort)
{
set<T> m1;
Chrono c;
c.Start();
if(tosort) for(int i=0;i<n;i++) m1.insert(dtab[i]);
else for(int i=0;i<n;i++) m1.insert(m1.end(),dtab[i]);
return c.Stop();
}
template <typename T>
double loadsetrange(T* dtab,int n)
{
Chrono c;
c.Start();
std::set<T> m2(dtab,dtab+n);
return c.Stop();
}
template <int size>
struct S
{
S(){}
S(char d){d_[0] = d;}
char d_[size];
bool operator<(const S& s) const {return d_[0] < s.d_[0];}
};
#include <fstream>
#include <iostream>
#include <vector>
#include <iterator>
int wmain()
{
bool tosort = true;
const int size = 1000000;
double *dtab=new double[size];
S<3>* s3tab=new S<3>[size];
S<10>* s10tab = new S<10>[size];
S<20>* s20tab = new S<20>[size];
S<100>* s100tab = new S<100>[size];
srand(281);
generate(dtab, dtab + size, rand);
generate(s3tab, s3tab + size, rand);
generate(s10tab, s10tab + size, rand);
generate(s20tab, s20tab + size, rand);
generate(s100tab, s100tab + size, rand);
std::cout << "\ndouble, sort\n";
double time5 = loadvect(dtab,size,tosort);
std::cout << time5 <<std::endl;
double time6 = loadvectrange(dtab,size,tosort);
std::cout << time6 <<std::endl;
double time7 = loadset(dtab,size,tosort);
std::cout << time7 <<std::endl;
double time8 = loadsetrange(dtab,size);
std::cout << time8 <<std::endl;
std::cout << "\ns3, sort\n";
double time9 = loadvect(s3tab,size,tosort);
std::cout << time9 <<std::endl;
double time10 = loadvectrange(s3tab,size,tosort);
std::cout << time10 <<std::endl;
double time11 = loadset(s3tab,size,tosort);
std::cout << time11 <<std::endl;
double time12 = loadsetrange(s3tab,size);
std::cout << time12 <<std::endl;
std::cout << "\ns10, sort\n";
double time13 = loadvect(s10tab,size,tosort);
std::cout << time13 <<std::endl;
double time14 = loadvectrange(s10tab,size,tosort);
std::cout << time14 <<std::endl;
double time15 = loadset(s10tab,size,tosort);
std::cout << time15 <<std::endl;
double time16 = loadsetrange(s10tab,size);
std::cout << time16 <<std::endl;
std::cout << "\ns20, sort\n";
double time17 = loadvect(s20tab,size,tosort);
std::cout << time17 <<std::endl;
double time18 = loadvectrange(s20tab,size,tosort);
std::cout << time18 <<std::endl;
double time19 = loadset(s20tab,size,tosort);
std::cout << time19 <<std::endl;
double time20 = loadsetrange(s20tab,size);
std::cout << time20 <<std::endl;
std::cout << "\ns100, sort\n";
double time21 = loadvect(s100tab,size,tosort);
std::cout << time17 <<std::endl;
double time22 = loadvectrange(s100tab,size,tosort);
std::cout << time18 <<std::endl;
double time23 = loadset(s100tab,size,tosort);
std::cout << time19 <<std::endl;
double time24 = loadsetrange(s100tab,size);
std::cout << time20 <<std::endl;
delete dtab;
return 0;
} |
Tableaux associatifs fixes
Répondre avec citation
Envoyé par JolyLoic
Partager