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

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

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

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

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

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).

function recursive (n) {
    if(n <= 2) {
        return 1;
    } else {
        return recursive(n - 1) + 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]) 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(2, 1); //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();

let map = new Map();

let obj = { key: 2 };
let arr = ['1', '2'];

map.set(0, 'val1');
map.set('1', 'val2');
map.set(obj, 'val3');
map.set(arr, 'val4');

map.get('1'); // 'val2'
map.get(obj); // 'val3'

map.size; // 4

map.delete(obj);

// необходимо передать итерируемый объект
let map = new Map([
  ['fruit1', 'apple'],
  ['fruit2', 'cherry'],
  ['fruit3', 'banana']
]);

for(let key of map.keys()) {  // итерация по ключам
  console.log(key);
}

for(let value of map.values()) {  // итерация по значениям
  console.log(value);
}

map.forEach( (value, key, map) => { // также есть метод forEach
  console.log(`${key}: ${value}`);
});

let set = new Set();

let apple = { fruit: 'Яблоко' };
let cherry = { fruit: 'Вишня' };
let banana = { fruit: 'Банан' };

set.add(apple);
set.add(cherry);
set.add(banana);
// Добавляет только уникальные значения
set.add(banana);

set.size // 3

set.has(apple) // true
set.has('1') // false

set.delete(apple);

set.clear()

// Для инициализации необходимо в конструктор передать 
// итерируемый объект
let set = new Set(['Яблоко', 'Вишня', 'Банан']);

// итерация по значениям (такой же эффект с set.keys()
for(let value of set.values()) {
  console.log(value);
}

// также есть метод forEach
set.forEach( (value, valueAgain, set) => {
  console.log(value);
});

let fruits = [
  {fruit: 'apple'},
  {fruit: 'cherry'},
  {fruit: 'banana'}
];

let weakMap = new WeakMap();

weakMap.set(fruits[0], 'one');
weakMap.set(fruits[1], 'two');
weakMap.set(fruits[2], 'three');

// Нельзя в качестве ключей хранить примитивы
weakMap.set('orange', 'four'); // Error

weakMap.get(fruits[0]) // 'one'

fruits.shift();

weakMap.get(fruits[0]) // 'two'

ES6 структуры данных, которые не препятствуют удалению хранимых объектов сборщиком мусора, если данные объекты были удалены из другого места в коде и более не используются.

Имеют урезанный функционал: в качестве ключей могут быть только объекты, отсутствует свойство size, отсутствуют методы clear, forEach, keys, values и нельзя перебрать при помощи итератора, .