пошаговый набор инструкций для выполнения задачи

Алгоритм должен представлять процесс решения задачи как последовательное выполнение простых                                       (или ранее определенных) шагов.                                       Каждое действие, предусмотренное алгоритмом, исполняется только после выполнения предыдущего шага.

Алгоритм должен приводить к решению поставленной задачи за конечное число шагов.

Алгоритм решения задачи разрабатывается в общем виде, т.е. он должен быть применим для некоторого класса задач, различающихся только исходными данными.         

... – это вызов функции самой себя, как правило, с другими аргументами.

Math.pow(2,3); //8

// pow(x, n) = x * pow(x, n - 1);
// pow(2, 3) = 2 * pow(2, 2)

function pow(x, n) {
  return n !== 1 ? x * pow(x, n - 1) : x;
}

Любая рекурсия может быть переделана в цикл. Как правило, вариант с циклом будет эффективнее.

function pow(x, n) {
    let result = x;
    for (let i = 1; i < n; i++) {
        result *= x;
    }
    return result;
}

При любом вложенном вызове JavaScript запоминает текущий контекст выполнения в специальной внутренней структуре данных – «стеке контекстов».

У каждого вызова функции есть свой «контекст выполнения» (execution context).

var recursive = function(n) {
    if(n <= 2) {
        return 1;
    } else {
        return this.recursive(n - 1) + this.recursive(n - 2);
    }
};

let loopingFib = function(n) {
    let a = 0, b = 1, f = 1;
    for(let i = 2; i <= n; i++) {
        f = a + b;
        a = b;
        b = f;
    }
    return f;
};

формула...

где:

где:

    let memo = [];
    
    let fib = function(n) {
      if (memo[n] !== undefined) return memo[n];
    
      let current = 0;
      let next = 1;
    
      for (let i = 0; i < n; i++) {
        memo[i] = current;
        [current, next] = [next, current + next]; //swap
      }
    
      return current;
    };

Мемоизация — сохранение результатов выполнения функций для предотвращения повторных вычислений. Это один из способов оптимизации

Для больших чисел n количество вызовов функции растёт очень быстро. Уже для n=50 это порядка 40 миллиардов вызовов.

Используя идею мемоизации, то есть кеширования промежуточного результата, можно добиться уменьшения количества вызовов для n=50 до всего лишь 99.

    
    result = ++variable  
    result = --variable  
    result = variable++  
    result = variable-- 

  /*************************/
    variable = 1;
    result1 = variable++;
    result2 = ++variable;

    variable //3
    result1 //1
    result2 //3

function decToBinary(decNumber) {
    

    








    




   
}

if ( array[i] >= max ) { ...

Когда мы анализируем алгоритмы, мы чаще всего рассматриваем наихудший сценарий.

Таким образом, в наихудшем случае в теле цикла из нашего кода запускается четыре инструкции, и мы имеем f( n ) = 4 + 2n + 4n = 6n + 4.

Поэтому первое, что мы сделаем, 
это отбросим 4 и оставим только 
f( n ) = 6n.

Второй вещью, на которую можно не обращать внимания, является множитель перед n. Так что наша функция превращается в f( n ) = n.

function bubbleSort(array) {

















   return array;
}

var things = ['word', 'Word', '1 Word', '2 Words'];
things.sort(); // ['1 Word', '2 Words', 'Word', 'word'];

  

   function compare(a, b) {
      if (a < b) {
        return -1;
      }
      if (a > b) {
        return 1;
      }
      // a === b
      return 0;
   }

// sort by value
items.sort(function (a, b) {
  return a.value - b.value;
});

// sort by name
items.sort(function(a, b) {
  var nameA = a.name.toUpperCase(); // ignore upper and lowercase
  var nameB = b.name.toUpperCase(); // ignore upper and lowercase

  if (nameA < nameB) {
    return -1;
  }

  if (nameA > nameB) {
    return 1;
  }

  // names must be equal
  return 0;
});

function Node(data) {
  this.data = data;
  this.next = null;
}

function SinglyLinkedList() {
  this.head = null;
  this.tail = null;
  this.numberOfValues = 0;
}

SinglyLinkedList.prototype.length = function() {
  return this.numberOfValues;
};

SinglyLinkedList.prototype.add = function(data) {
    var node = new Node(data);
    if(!this.head) {
        this.head = node;
        this.tail = node;
    } else {
        this.tail.next = node;
        this.tail = node;
    }
    this.numberOfValues++;
};

SinglyLinkedList.prototype.remove = function(data){
    var previous = this.head;
    var current = this.head;

    while(current) {
        if(current.data === data) {
            if(current === this.head) {
                this.head = this.head.next;
            }
            
            if(current === this.tail) {
                this.tail = previous;
            }
            
            previous.next = current.next;
            this.numberOfValues--;
        } else {
            previous = current;
        }
        
        current = current.next;
    }
};

....insertAfter = function(data, afterElement) {

}

var list = new SinglyLinkedList();

list.add(1);
list.add(2);
list.add(3);
list.length(); //3

list.remove(2);
list.insertAfter(1, 2); //1,2,3

var node = new Node(data);

function Stack() {
    this.stack = [];
}

Stack.prototype.push = function(value) {
    this.stack.push(value);
};

Stack.prototype.pop = function() {
    return this.stack.pop();
};

Stack.prototype.peek = function() {
    return this.stack[this.stack.length - 1];
};

var stack = new Stack();

stack.push(1);
stack.push(2); //1,2

stack.peek(); //2

stack.pop(); //1

function Queue() {
    this.queue = [];
}

Queue.prototype.enqueue = function(value) {
    this.queue.push(value);
};

Queue.prototype.dequeue = function() {
    return this.queue.shift();
};

Queue.prototype.peek = function() {
    return this.queue[0];
};

var queue = new Queue();

queue.enqueue(1);
queue.enqueue(2);

queue.peek();

queue.dequeue();

function Node(data) {
    this.data = data;
    this.left = null;
    this.right = null;
}

function BinarySearchTree() {
    this.root = null;
}

BinarySearchTree.prototype.add = function(data) {
    var node = new Node(data);
    if(!this.root) {
        this.root = node;
    } else {
        var current = this.root;
        
        while(current) {
            if(node.data < current.data) {
                if(!current.left) {
                    current.left = node;
                    break;
                }
                current = current.left;
            } else if (node.data > current.data) {
                if(!current.right) {
                  current.right = node;
                  break;
                }
                current = current.right;
            } else {
                break;
            }
        }
    }
};

var bsTree = new BinarySearchTree();
bsTree.add(5);
bsTree.add(3);
bsTree.add(7);
bsTree.add(2);
bsTree.add(4);
bsTree.add(4);
bsTree.add(6);
bsTree.add(8);  5 | 3 7 | 2 4 6 8

BinarySearchTree.prototype.getMax = function(node) {
    if(!node) {
        node = this.root;
    }
    while(node.right) {
        node = node.right;
    }
    
    return node.data;
};

BinarySearchTree.prototype.contains = function(data) {
    var current = this.root;
    while(current) {
        if(data === current.data) {
            return true;
        }
        if(data < current.data) {
            current = current.left;
        } else {
            current = current.right;
        }
    }
    return false;
};

BinarySearchTree.prototype.remove = function(data) {
    var that = this;

    var removeNode = function(node, data) {
        if(!node) {
          return null;
        }
        if(data === node.data) {
            if(!node.left && !node.right) {
                return null;
            }
            if(!node.left) {
                return node.right;
            }
            if(!node.right) {
                return node.left;
            }
            
           





        } else if(data < node.data) {
            node.left = removeNode(node.left, data);
            return node;
        } else {
            node.right = removeNode(node.right, data);
            return node;
        }
    };
  
    this.root = removeNode(this.root, data);
};

BinarySearchTree.prototype.traverse = function(fn) {
    var current = this.root;
    this.inOrder(current, fn);
};

BinarySearchTree.prototype.inOrder = function(node, fn) {
    if(node) {
        this.inOrder(node.left, fn);
        if(fn) {
            fn(node);
        }
        this.inOrder(node.right, fn);
    }
};

binarySearchTree.traverse(function(node) { console.log(node.data); });  //2 3 4 5 6 7 8

Представление графов