// initialize

const arr = [];

const arr = new array(size).fill(0);  // [0,0,0,0,0]

const arr = array.from({length: n}, (_, i) => i);  // [0,1,2,...,n-1]

// basic operations

arr.push(element);     // add to end

arr.pop();            // remove from end

arr.unshift(element); // add to start

arr.shift();          // remove from start

// slicing and splicing

arr.slice(startidx, endidx);  // returns new array, endidx not included

arr.splice(startidx, deletecount, ...itemstoadd);

// common methods

arr.map(x => x * 2);           // returns new array

arr.filter(x => x > 0);        // returns new array

arr.reduce((acc, curr) => acc + curr, initialvalue);

arr.sort((a, b) => a - b);     // ascending

arr.reverse();

arr.join();                  // convert to string

arr.includes(element);         // check existence

arr.indexof(element);          // first occurrence

arr.lastindexof(element);      // last occurrence

登录后复制

// creation and access

const str = "hello";

str.length;

str[0] or str.charat(0);

// common methods

str.substring(startidx, endidx);   // endidx not included

str.substr(startidx, length);      // deprecated but good to know

str.slice(startidx, endidx);       // can use negative indices

str.split();                     // convert to array

str.tolowercase();

str.touppercase();

str.trim();                        // remove whitespace

str.replace(old, new);

str.replaceall(old, new);

str.startswith(prefix);

str.endswith(suffix);

str.includes(substr);

str.repeat(count);

登录后复制

// map

const map = new map();

map.set(key, value);

map.get(key);

map.has(key);

map.delete(key);

map.clear();

map.size;

// set

const set = new set();

set.add(value);

set.has(value);

set.delete(value);

set.clear();

set.size;

// object as hashmap

const obj = {};

obj[key] = value;

key in obj;                    // check existence

delete obj[key];

object.keys(obj);

object.values(obj);

object.entries(obj);

登录后复制

class node {

constructor(val) {

this.val = val;

this.next = null;

}

}

// quick object creation

const obj = { key1: value1, key2: value2 };

登录后复制

// queue using array

const queue = [];

queue.push(element);    // enqueue

queue.shift();         // dequeue

// stack using array

const stack = [];

stack.push(element);

stack.pop();

// linkedlist node

class listnode {

constructor(val = 0, next = null) {

this.val = val;

this.next = next;

}

}

// binary tree node

class treenode {

constructor(val = 0, left = null, right = null) {

this.val = val;

this.left = left;

this.right = right;

}

}

// trie node

class trienode {

constructor() {

this.children = new map();

this.isendofword = false;

}

}

登录后复制

// common operations

n << 1;               // multiply by 2

n >> 1;               // divide by 2

n & 1;                // check if odd

n & (n-1);            // remove last set bit

n & -n;               // get last set bit

n | (1 << pos);       // set bit at position

n & ~(1 << pos);      // clear bit at position

n ^ (1 << pos);       // toggle bit at position

登录后复制

// number operations

math.max(...arr);

math.min(...arr);

math.floor(n);

math.ceil(n);

math.abs(n);

number.max_safe_integer;

number.min_safe_integer;

infinity;

-infinity;

// random number

math.random();                     // [0, 1)

math.floor(math.random() * n);     // [0, n-1]

// character code

a.charcodeat(0);                 // 97

string.fromcharcode(97);           // a

// check type

number.isinteger(n);

array.isarray(arr);

typeof variable;

// parsing

parseint(str);

parsefloat(str);

登录后复制

// Two Pointers

let left = 0, right = arr.length - 1;

while (left < right) {

// process

left++;

right--;

}

// Sliding Window

let left = 0;

for (let right = 0; right < arr.length; right++) {

// add arr[right] to window

while (/* window condition */) {

// remove arr[left] from window

left++;

}

}

// Binary Search

let left = 0, right = arr.length - 1;

while (left <= right) {

const mid = Math.floor((left + right) / 2);

if (arr[mid] === target) return mid;

if (arr[mid] < target) left = mid + 1;

else right = mid - 1;

}

登录后复制