---
title: Plots
layout: plots
group: "navigation"
navbar_link: <span class="glyphicon glyphicon-th-large"></span>&nbsp;Plots
---
<h1>Plots</h1>

<p>The platform under which the plots were produced was:</p>

<table class="table table-bordered reasonable-width">
  <tr>
    <th>CPU</th>
    <td><a href="http://ark.intel.com/products/58917">Intel Atom N2800</a></td>
  </tr>
  <tr>
    <th>OS</th>
    <td>Windows 7 Professional Service Pack 1</td>
  </tr>
  <tr>
    <th>Python</th>
    <td>3.4.1</td>
  </tr>
  <tr>
    <th>matplotlib</th>
    <td>1.4.0</td>
  </tr>
</table>

<div id="plots">
  <p class="text-muted">Javascript-generated plot table is supposed to appear here.</p>
</div>
<script type="text/javascript">
var userName = 'egor-tensin';
var repoName = 'sorting_algorithms';

var plotsUrl = 'https://github.com/{userName}/{repoName}/raw/master/plots/'.format({
  userName: userName,
  repoName: repoName
});

var previewsPath = '{{ site.baseurl }}/img/previews/';

function Algorithm(codename, name, briefName,
                   minLength, maxLength,
                   repetitions, complexity) {
  this.codename = codename;
  this.name = name;
  this.briefName = briefName;
  this.minLength = minLength;
  this.maxLength = maxLength;
  this.repetitions = repetitions;
  this.complexity = complexity;
}

Algorithm.prototype.getRepetitions = function(input) {
  switch (typeof this.repetitions) {
    case 'number':
      return this.repetitions;
    case 'object':
      return this.repetitions[input];
  }
}

Algorithm.prototype.getComplexity = function(input) {
  switch (typeof this.complexity) {
    case 'string':
      return this.complexity;
    case 'object':
      return this.complexity[input];
  }
}

Algorithm.prototype.buildPlotStem = function(input) {
  return '{codename}_{repetitions}_{input}_{minLength}_{maxLength}'.format({
    codename: this.codename,
    input: input,
    repetitions: this.getRepetitions(input),
    minLength: this.minLength,
    maxLength: this.maxLength
  });
}

Algorithm.prototype.buildPlotFileName = function(input) {
  return this.buildPlotStem(input) + '.png';
}

Algorithm.prototype.buildPreviewFileName = function(input) {
  return this.buildPlotStem(input) + '.jpg';
}

Algorithm.prototype.buildPlotUrl = function(input) {
  return plotsUrl + this.buildPlotFileName(input);
}

Algorithm.prototype.buildPreviewPath = function(input) {
  return previewsPath + this.buildPreviewFileName(input);
}

Algorithm.prototype.buildPlotCaptionHtml = function(input) {
  return '\
<div class="caption">\n\
<strong>{name}</strong><br/>\n\
<strong>Input:</strong> {input}<br/>\n\
<strong>Complexity:</strong> {complexity}<br/>\n\
</div>\n'.format({name: this.name,
                  input: input,
                  complexity: this.getComplexity(input)});
}

Algorithm.prototype.buildPlotHtml = function(input) {
  return '\
<div class="col-xs-12 col-sm-6 col-md-4">\n\
  <div class="thumbnail">\
    <a class="thumbnail" href="{plotUrl}">\n\
      <img class="img-responsive" src="{previewPath}"/>\n\
    </a>\n\
    {captionHtml}\n\
  </div>\n\
</div>\n'.format({previewPath: this.buildPreviewPath(input),
                  plotUrl: this.buildPlotUrl(input),
                  captionHtml: this.buildPlotCaptionHtml(input)});
}

var algorithms = [
  new Algorithm('bubble', 'Bubble sort', 'Bubble sort', 0, 200,
                {sorted: 1000, randomized: 100, reversed: 100},
                {sorted: 'O(<var>n</var>)',
                 randomized: 'O(<var>n</var><sup>2</sup>)',
                 reversed: 'O(<var>n</var><sup>2</sup>)'}),
  new Algorithm('bubble_optimized', 'Optimized bubble sort',
                '&hellip; optimized', 0, 200,
                {sorted: 1000, randomized: 100, reversed: 100},
                {sorted: 'O(<var>n</var>)',
                 randomized: 'O(<var>n</var><sup>2</sup>)',
                 reversed: 'O(<var>n</var><sup>2</sup>)'}),
  new Algorithm('heap', 'Heapsort', 'Heapsort', 0, 200,
                100, 'O(<var>n</var> log <var>n</var>)'),
  new Algorithm('insertion', 'Insertion sort', 'Insertion sort', 0, 200,
                {sorted: 1000, randomized: 100, reversed: 100},
                {sorted: 'O(<var>n</var>)',
                 randomized: 'O(<var>n</var><sup>2</sup>)',
                 reversed: 'O(<var>n</var><sup>2</sup>)'}),
  new Algorithm('merge', 'Merge sort', 'Merge sort', 0, 200,
                100, 'O(<var>n</var> log <var>n</var>)'),
  new Algorithm('quick_first', 'Quicksort (first element as pivot)',
                'Quicksort (first element as pivot)', 0, 200,
                100, {sorted: 'O(<var>n</var><sup>2</sup>)',
                      randomized: 'O(<var>n</var> log <var>n</var>)',
                      reversed: 'O(<var>n</var><sup>2</sup>)'}),
  new Algorithm('quick_second', 'Quicksort (second element as pivot)',
                '&hellip; second element&hellip;', 0, 200,
                100, {sorted: 'O(<var>n</var><sup>2</sup>)',
                      randomized: 'O(<var>n</var> log <var>n</var>)',
                      reversed: 'O(<var>n</var><sup>2</sup>)'}),
  new Algorithm('quick_middle', 'Quicksort (middle element as pivot)',
                '&hellip; middle element&hellip;', 0, 200,
                100, 'O(<var>n</var> log <var>n</var>)'),
  new Algorithm('quick_last', 'Quicksort (last element as pivot)',
                '&hellip; last element&hellip;', 0, 200,
                100, {sorted: 'O(<var>n</var><sup>2</sup>)',
                      randomized: 'O(<var>n</var> log <var>n</var>)',
                      reversed: 'O(<var>n</var><sup>2</sup>)'}),
  new Algorithm('quick_random', 'Quicksort (random element as pivot)',
                '&hellip; random element&hellip;', 0, 200,
                100, 'O(<var>n</var> log <var>n</var>)'),
  new Algorithm('selection', 'Selection sort', 'Selection sort', 0, 200,
                100, 'O(<var>n</var><sup>2</sup>)')
];

function buildPlotsAlgorithm(algorithm) {
  return '\
<a id="plots_{codename}"></a>\n\
<h3>{name}</h3>\n\
<div class="row">\n\
{sorted}\
{randomized}\
{reversed}\n\
</div>\n'.format({name: algorithm.name,
                  codename: algorithm.codename,
                  sorted: algorithm.buildPlotHtml('sorted'),
                  randomized: algorithm.buildPlotHtml('randomized'),
                  reversed: algorithm.buildPlotHtml('reversed')});
}

function buildPlotsAllAlgorithms() {
  var html = '';
  for (var i = 0; i < algorithms.length; ++i) {
    html += buildPlotsAlgorithm(algorithms[i]);
  }
  return html;
}

function buildComplexityTableRow(algorithm) {
  return '\
<tr>\n\
  <td><a href="#plots_{codename}">{briefName}</a></td>\n\
  <td>{sorted}</td>\n\
  <td>{randomized}</td>\n\
  <td>{reversed}</td>\n\
</tr>\n'.format({codename: algorithm.codename,
                 briefName: algorithm.briefName,
                 sorted: algorithm.getComplexity('sorted'),
                 randomized: algorithm.getComplexity('randomized'),
                 reversed: algorithm.getComplexity('reversed')});
}

function buildComplexityTable() {
  var html = '\
<div class="row">\n\
  <div class="col-xs-12 col-sm-10 col-md-8">\n\
    <table id="complexity_table" class="table table-bordered table-hover">\n\
      <thead>\n\
        <tr>\n\
          <th class="text-center" rowspan="2">Algorithm</th>\n\
          <th class="text-center" colspan="3">Complexity</th>\n\
        </tr>\n\
        <tr>\n\
          <th class="text-center">sorted</th>\n\
          <th class="text-center">randomized</th>\n\
          <th class="text-center">reversed</th>\n\
        </tr>\n\
      </thead>\n\
      <tbody>\n';
  for (var i = 0; i < algorithms.length; ++i) {
    html += buildComplexityTableRow(algorithms[i]);
  }
  html += '\
      </tbody>\n\
    </table>\n\
  </div>\n\
</div>\n';
  return html;
}

document.getElementById('plots').innerHTML = buildComplexityTable() + buildPlotsAllAlgorithms();
</script>