File: sort_test.ref

package info (click to toggle)
libitpp 4.3.1-14
  • links: PTS, VCS
  • area: main
  • in suites: sid
  • size: 9,952 kB
  • sloc: cpp: 73,628; makefile: 661; python: 548; sh: 261
file content (82 lines) | stat: -rw-r--r-- 3,879 bytes parent folder | download | duplicates (7)
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
-----------------
  Sorting Tests
-----------------

Vectors of length 15, using uniform random doubles (0,1):
Introsort:
    A (before sort): [0.793 0.881 0.395 0.029 0.583 0.427 0.930 0.065 0.946 0.773 0.158 0.358 0.856 0.677 0.156]
    A (after sort):  [0.029 0.065 0.156 0.158 0.358 0.395 0.427 0.583 0.677 0.773 0.793 0.856 0.881 0.930 0.946]
Quicksort:
    A (before sort): [0.163 0.512 0.913 0.616 0.855 0.591 0.013 0.533 0.415 0.538 0.950 0.709 0.932 0.479 0.603]
    A (after sort):  [0.013 0.163 0.415 0.479 0.512 0.533 0.538 0.591 0.603 0.616 0.709 0.855 0.913 0.932 0.950]
Heapsort:
    A (before sort): [0.409 0.462 0.659 0.214 0.014 0.304 0.468 0.958 0.193 0.219 0.250 0.839 0.018 0.024 0.613]
    A (after sort):  [0.014 0.018 0.024 0.193 0.214 0.219 0.250 0.304 0.409 0.462 0.468 0.613 0.659 0.839 0.958]
Insertion Sort:
    A (before sort): [0.745 0.422 0.150 0.716 0.899 0.025 0.543 0.764 0.921 0.439 0.017 0.216 0.748 0.763 0.118]
    A (after sort):  [0.017 0.025 0.118 0.150 0.216 0.422 0.439 0.543 0.716 0.745 0.748 0.763 0.764 0.899 0.921]
Introsort (index):
    A:    [0.427 0.179 0.917 0.036 0.678 0.873 0.892 0.845 0.125 0.343 0.697 0.535 0.015 0.414 0.553]
    I:    [12 3 8 1 9 13 0 11 14 4 10 7 5 6 2]
    A(I): [0.015 0.036 0.125 0.179 0.343 0.414 0.427 0.535 0.553 0.678 0.697 0.845 0.873 0.892 0.917]
Quicksort (index):
    A:    [0.988 0.843 0.644 0.171 0.201 0.051 0.259 0.767 0.179 0.355 0.375 0.846 0.035 0.489 0.031]
    I:    [14 12 5 3 8 4 6 9 10 13 2 7 1 11 0]
    A(I): [0.031 0.035 0.051 0.171 0.179 0.201 0.259 0.355 0.375 0.489 0.644 0.767 0.843 0.846 0.988]
Heapsort (index):
    A:    [0.710 0.032 0.366 0.256 0.058 0.425 0.772 0.481 0.819 0.753 0.086 0.687 0.081 0.333 0.469]
    I:    [1 4 12 10 3 13 2 5 14 7 11 0 9 6 8]
    A(I): [0.032 0.058 0.081 0.086 0.256 0.333 0.366 0.425 0.469 0.481 0.687 0.710 0.753 0.772 0.819]
Insertion sort (index):
    A:    [0.304 0.157 0.644 0.619 0.248 0.784 0.193 0.991 0.633 0.942 0.556 0.696 0.824 0.800 0.417]
    I:    [1 6 4 0 14 10 3 8 2 11 5 13 12 9 7]
    A(I): [0.157 0.193 0.248 0.304 0.417 0.556 0.619 0.633 0.644 0.696 0.784 0.800 0.824 0.942 0.991]


Vectors of length 20000, using uniform random doubles (0,1):
Introsort:                Successful!
Quicksort:                Successful!
Heapsort:                 Successful!
Introsort (index):        Successful!
Quicksort (index):        Successful!
Heapsort (index):         Successful!


Vectors of length 15, using uniform random integers (0,10):
Introsort:
    B (before sort): [9 2 5 5 5 0 5 5 8 6 2 7 0 4 7]
    B (after sort):  [0 0 2 2 4 5 5 5 5 5 6 7 7 8 9]
Quicksort:
    B (before sort): [2 6 8 9 1 7 1 8 8 3 4 5 7 0 1]
    B (after sort):  [0 1 1 1 2 3 4 5 6 7 7 8 8 8 9]
Heapsort:
    B (before sort): [7 3 0 4 2 8 9 2 5 0 8 3 3 8 3]
    B (after sort):  [0 0 2 2 3 3 3 3 4 5 7 8 8 8 9]
Insertion sort:
    B (before sort): [3 5 1 10 9 7 5 5 9 8 3 3 7 7 0]
    B (after sort):  [0 1 3 3 3 5 5 5 7 7 7 8 9 9 10]
Introsort (index):
    B:    [6 6 7 9 8 3 1 9 7 8 9 2 9 8 3]
    I:    [6 11 5 14 0 1 2 8 4 9 13 3 7 10 12]
    B(I): [1 2 3 3 6 6 7 7 8 8 8 9 9 9 9]
Quicksort (index):
    B:    [8 5 4 6 0 4 9 7 5 8 0 2 4 10 3]
    I:    [10 4 11 14 2 5 12 1 8 3 7 0 9 6 13]
    B(I): [0 0 2 3 4 4 4 5 5 6 7 8 8 9 10]
Heapsort (index):
    B:    [4 10 8 9 0 5 3 5 0 7 2 5 3 3 1]
    I:    [4 8 14 10 6 12 13 0 11 5 7 9 2 3 1]
    B(I): [0 0 1 2 3 3 3 4 5 5 5 7 8 9 10]
Insertion sort (index):
    B:    [9 10 2 2 1 2 8 7 6 10 9 5 1 2 5]
    I:    [4 12 2 3 5 13 11 14 8 7 6 0 10 1 9]
    B(I): [1 1 2 2 2 2 5 5 6 7 8 9 9 10 10]


Vectors of length 20000, using uniform random integers (0,10):
Introsort:                Successful!
Quicksort:                Successful!
Heapsort:                 Successful!
Introsort (index):        Successful!
Quicksort (index):        Successful!
Heapsort (index):         Successful!