Skip to content

Commit 985a96b

Browse files
stbrummestbrumme
committed
version 6
1 parent 83b9d8c commit 985a96b

File tree

5 files changed

+902
-39
lines changed

5 files changed

+902
-39
lines changed

‎container.h

+114
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,114 @@
1+
// //////////////////////////////////////////////////////////
2+
// container.h
3+
// Copyright (c) 2014 Stephan Brumme. All rights reserved.
4+
// see http://create.stephan-brumme.com/disclaimer.html
5+
//
6+
7+
#pragma once
8+
9+
10+
#include <iterator>
11+
#include <vector>
12+
13+
14+
// forward declaration
15+
class Container;
16+
17+
//#define BIDIRECTIONALITERATOR
18+
#define RANDOMACCESSITERATOR
19+
20+
/// can be forward iterator, bidirectional or random access (see #define above)
21+
class Iterator :
22+
#if !defined(BIDIRECTIONALITERATOR) && !defined(RANDOMACCESSITERATOR)
23+
public std::iterator<std::forward_iterator_tag, int>
24+
#elseif defined(BIDIRECTIONALITERATOR) && !defined(RANDOMACCESSITERATOR)
25+
public std::iterator<std::bidirectional_iterator_tag, int>
26+
#else
27+
public std::iterator<std::random_access_iterator_tag, int>
28+
#endif
29+
{
30+
public:
31+
typedef int value_type;
32+
33+
/// construct empty iterator
34+
Iterator() : iterator() {}
35+
/// construct new iterator
36+
Iterator(const std::vector<int>::iterator& ite) : iterator(ite) {}
37+
38+
/// only copy position, skip container
39+
void operator=(const Iterator& other) { iterator = other.iterator; }
40+
41+
/// step forward (prefix)
42+
Iterator& operator++() { ++iterator; return *this; }
43+
/// step forward (postfix)
44+
Iterator operator++(int) { Iterator result(*this); ++iterator; return result; }
45+
46+
#if defined(BIDIRECTIONALITERATOR) || defined(RANDOMACCESSITERATOR)
47+
/// step backward (prefix)
48+
Iterator& operator--() { --iterator; return *this; }
49+
/// step backward (postfix)
50+
Iterator operator--(int) { Iterator result(*this); ++iterator; return result; }
51+
#endif
52+
53+
#if defined(RANDOMACCESSITERATOR)
54+
/// leap forward
55+
Iterator operator+ (std::iterator_traits<Iterator>::difference_type howFar) const
56+
{ return iterator + howFar; }
57+
/// leap backward
58+
Iterator operator- (std::iterator_traits<Iterator>::difference_type howFar) const
59+
{ return iterator - howFar; }
60+
61+
/// leap forward
62+
Iterator operator+=(std::iterator_traits<Iterator>::difference_type howFar)
63+
{ iterator += howFar; return *this; }
64+
/// leap backward
65+
Iterator operator-=(std::iterator_traits<Iterator>::difference_type howFar)
66+
{ iterator -= howFar; return *this; }
67+
68+
/// ordered iterators
69+
bool operator<(const Iterator& other) const { return iterator < other.iterator; }
70+
/// ordered iterators
71+
bool operator>(const Iterator& other) const { return iterator > other.iterator; }
72+
73+
/// measure distance
74+
std::iterator_traits<Iterator>::difference_type operator-(const Iterator& other) const
75+
{ return iterator - other.iterator; }
76+
#endif
77+
78+
/// pointing to same element ?
79+
bool operator==(const Iterator& other) const { return iterator == other.iterator; }
80+
/// pointing to different element ?
81+
bool operator!=(const Iterator& other) const { return iterator != other.iterator; }
82+
83+
/// dereference
84+
int& operator*() { return *iterator; }
85+
/// dereference
86+
int operator*() const { return *iterator; }
87+
88+
private:
89+
/// has random-access iterator
90+
std::vector<int>::iterator iterator;
91+
};
92+
93+
94+
/// only implements iterators and element access
95+
class Container
96+
{
97+
public:
98+
/// construct vector
99+
Container(int initialSize = 0) : container(initialSize) {}
100+
101+
/// return iterator pointing to first element
102+
Iterator begin() { return container.begin(); }
103+
/// return iterator pointing beyond last element
104+
Iterator end() { return container.end(); }
105+
106+
/// read/write access to an element
107+
int& operator[](size_t pos) { return container[pos]; }
108+
/// read/write access to an element
109+
bool operator!=(const Container& other) const { return container != other.container; }
110+
111+
private:
112+
/// actually just a simple vector
113+
std::vector<int> container;
114+
};

‎count.cpp

+282
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,282 @@
1+
// //////////////////////////////////////////////////////////
2+
// count.cpp
3+
// Copyright (c) 2014 Stephan Brumme. All rights reserved.
4+
// see http://create.stephan-brumme.com/disclaimer.html
5+
//
6+
7+
// g++ -O3 count.cpp -o count
8+
// and -std=c++11 if possible
9+
10+
#include <cstdio>
11+
#include <cstdlib>
12+
13+
#include <vector>
14+
#include <algorithm> // std::sort, std::reverse
15+
16+
#include "sort.h"
17+
18+
19+
/// count assignments and comparisions
20+
class Number
21+
{
22+
public:
23+
/// set value
24+
Number(int x = 0) : value(x) { }
25+
/// copy constructor is counted as an assignment
26+
Number(const Number& other) : value(other.value) { ++numAssignments; }
27+
28+
static int numLessThan;
29+
/// count comparisons
30+
bool operator< (const Number& other) const { ++numLessThan; return value < other.value; }
31+
32+
static int numAssignments;
33+
/// count assignments
34+
void operator= (const Number& other) { ++numAssignments; value = other.value; }
35+
36+
bool operator==(const Number& other) const { return value == other.value; }
37+
38+
/// reset counters
39+
static void reset() { numLessThan = numAssignments = 0; }
40+
41+
private:
42+
/// actually just a simple integer
43+
int value;
44+
};
45+
46+
int Number::numLessThan = 0;
47+
int Number::numAssignments = 0;
48+
49+
50+
typedef std::vector<Number> Container;
51+
52+
53+
// protect server from overload:
54+
const int MaxSort = 100000;
55+
56+
57+
int main(int argc, char** argv)
58+
{
59+
// number of elements to be sorted
60+
int numElements = 100;
61+
if (argc == 2)
62+
numElements = atoi(argv[1]);
63+
64+
// only positive numbers
65+
if (numElements == 0)
66+
numElements = 100;
67+
if (numElements < 0)
68+
numElements = -numElements;
69+
// avoid server overload
70+
if (numElements > MaxSort)
71+
numElements = MaxSort;
72+
73+
printf("%d element%s", numElements, numElements == 1 ? "":"s");
74+
75+
// initialize containers
76+
// 0,1,2,3,4,...
77+
Container ascending(numElements);
78+
for (int i = 0; i < numElements; i++)
79+
ascending[i] = i;
80+
81+
// ...,4,3,2,1,0
82+
Container descending = ascending;
83+
std::reverse(descending.begin(), descending.end());
84+
85+
// just random
86+
Container random = ascending;
87+
srand(time(NULL));//0);
88+
std::random_shuffle(random.begin(), random.end());
89+
90+
// use this container for input data
91+
Container data;
92+
93+
// bubble sort
94+
printf("\nBubble Sort");
95+
data = ascending;
96+
Number::reset();
97+
bubbleSort(data.begin(), data.end());
98+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
99+
100+
data = descending;
101+
Number::reset();
102+
bubbleSort(data.begin(), data.end());
103+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
104+
105+
data = random;
106+
Number::reset();
107+
bubbleSort(data.begin(), data.end());
108+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
109+
110+
// selection sort
111+
printf("\nSelection Sort");
112+
data = ascending;
113+
Number::reset();
114+
selectionSort(data.begin(), data.end());
115+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
116+
117+
data = descending;
118+
Number::reset();
119+
selectionSort(data.begin(), data.end());
120+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
121+
122+
data = random;
123+
Number::reset();
124+
selectionSort(data.begin(), data.end());
125+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
126+
127+
// insertion sort
128+
printf("\nInsertion Sort");
129+
data = ascending;
130+
Number::reset();
131+
insertionSort(data.begin(), data.end());
132+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
133+
134+
data = descending;
135+
Number::reset();
136+
insertionSort(data.begin(), data.end());
137+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
138+
139+
data = random;
140+
Number::reset();
141+
insertionSort(data.begin(), data.end());
142+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
143+
144+
// shell sort
145+
printf("\nShell Sort");
146+
data = ascending;
147+
Number::reset();
148+
shellSort(data.begin(), data.end());
149+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
150+
151+
data = descending;
152+
Number::reset();
153+
shellSort(data.begin(), data.end());
154+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
155+
156+
data = random;
157+
Number::reset();
158+
shellSort(data.begin(), data.end());
159+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
160+
161+
// heap sort
162+
printf("\nHeap Sort");
163+
data = ascending;
164+
Number::reset();
165+
heapSort(data.begin(), data.end());
166+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
167+
168+
data = descending;
169+
Number::reset();
170+
heapSort(data.begin(), data.end());
171+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
172+
173+
data = random;
174+
Number::reset();
175+
heapSort(data.begin(), data.end());
176+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
177+
178+
// n-ary heap sort
179+
printf("\n8-ary Heap Sort");
180+
data = ascending;
181+
Number::reset();
182+
naryHeapSort<8>(data.begin(), data.end());
183+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
184+
185+
data = descending;
186+
Number::reset();
187+
naryHeapSort<8>(data.begin(), data.end());
188+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
189+
190+
data = random;
191+
Number::reset();
192+
naryHeapSort<8>(data.begin(), data.end());
193+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
194+
195+
// merge sort
196+
printf("\nMerge Sort");
197+
data = ascending;
198+
Number::reset();
199+
mergeSort(data.begin(), data.end());
200+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
201+
202+
data = descending;
203+
Number::reset();
204+
mergeSort(data.begin(), data.end());
205+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
206+
207+
data = random;
208+
Number::reset();
209+
mergeSort(data.begin(), data.end());
210+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
211+
212+
// in-place merge sort
213+
printf("\nMerge Sort in-place");
214+
data = ascending;
215+
Number::reset();
216+
mergeSortInPlace(data.begin(), data.end());
217+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
218+
219+
data = descending;
220+
Number::reset();
221+
mergeSortInPlace(data.begin(), data.end());
222+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
223+
224+
data = random;
225+
Number::reset();
226+
mergeSortInPlace(data.begin(), data.end());
227+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
228+
229+
// quick sort
230+
printf("\nQuick Sort");
231+
data = ascending;
232+
Number::reset();
233+
quickSort(data.begin(), data.end());
234+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
235+
236+
data = descending;
237+
Number::reset();
238+
quickSort(data.begin(), data.end());
239+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
240+
241+
data = random;
242+
Number::reset();
243+
quickSort(data.begin(), data.end());
244+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
245+
246+
// std::sort
247+
printf("\nstd::sort");
248+
data = ascending;
249+
Number::reset();
250+
std::sort(data.begin(), data.end());
251+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
252+
253+
data = descending;
254+
Number::reset();
255+
std::sort(data.begin(), data.end());
256+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
257+
258+
data = random;
259+
Number::reset();
260+
std::sort(data.begin(), data.end());
261+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
262+
263+
// std::stable_sort
264+
printf("\nstd::stable_sort");
265+
data = ascending;
266+
Number::reset();
267+
std::stable_sort(data.begin(), data.end());
268+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
269+
270+
data = descending;
271+
Number::reset();
272+
std::stable_sort(data.begin(), data.end());
273+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
274+
275+
data = random;
276+
Number::reset();
277+
std::stable_sort(data.begin(), data.end());
278+
printf("\t%d\t%d", Number::numLessThan, Number::numAssignments);
279+
280+
printf("\n");
281+
return 0;
282+
}

0 commit comments

Comments
 (0)