データ構造の魂とアルゴリズム-js
（スペースで区切っ）タグ：未分類
データ構造：
スタック：高度（LIFO）の原理に準拠の順序付けられた集合の一種、スタックの一番上と呼ばれるスタックの最後に格納された新たに追加または削除する要素は、スタックの底にもう一方の端。スタックでは、新しい要素が近いスタックの最上部にある、古い要素は、スタックの最下部に近いです。
class Stack {
constructor() {
this.items = []
}
push(element) {
this.items.push(element)
}
pop() {
return this.items.pop()
}
clear() {
this.items = []
}
print() {
console.log(this.items.toString())
}
// 属性
get peek() {
return this.items[this.items.length - 1]
}
get size() {
return this.items.length
}
}キュー：フォローFIFO（FIFO /先入れ先出し）原則反対の項目の順序付きセット、最後尾にキューに追加された新しい要素、および要素が頭から削除されます。新しく追加された要素がキューの最後になければなりません。
class Queue {
constructor(items) {
this.items = items || []
}
// 普通队列
enqueue(element) {
this.items.push(element)
}
// 优先队列的构造方法
// enqueue(element, priority) {
// const queueElement = { element, priority }
// if (this.isEmpty) {
// this.items.push(queueElement)
// } else {
// const preIndex = this.items.findIndex((item) => queueElement.priority < item.priority)
// if (preIndex > -1) {
// this.items.splice(preIndex, 0, queueElement)
// } else {
// this.items.push(queueElement)
// }
// }
// }
dequeue() {
return this.items.shift()
}
front() {
return this.items[0]
}
clear() {
this.items = []
}
print() {
console.log(this.items.toString())
}
get size() {
return this.items.length
}
get isEmpty() {
return !this.items.length
}
}
// 循环队列,要点在于index的计算
class LoopQueue extends Queue {
constructor(items) {
super(items)
}
getIndex(index) {
const length = this.items.length
return index > length ? (index % length) : index
}
find(index) {
return !this.isEmpty ? this.items[this.getIndex(index)] : null
}
}リスト：要素の順序付けられた集合を格納するが、メモリ内のリストの要素が直列に配置されていない、配列は異なる、次の要素（ポインタ/リンク）に自ノードと基準ポイントと、記憶素子の各要素コンポーネント。
class linkNode {
constructor(ele) {
this.element = ele;
this.next = null;
}
}
class singLinkList {
constructor() {
this.item = [];
this.head = null;
this.length = 0;
}
append(ele) {
const node = new linkNode(ele);
let current = null;
if (this.head) {
this.head = node;
} else {
current = this.head;
while (current.next) {
current = current.next;
};
current.next = node;
}
this.length++;
}
insert(pos, ele) {
if (pos > 0 && pos <= this.length) {
const node = new linkNode(ele);
let current = this.head;
let previous = null;
let index = 0;
if (pos === 0) {
this.head = node;
} else {
while (index < pos) {
index++;
previous = current;
current = current.next;
}
node.next = current;
previous.next = node;
}
this.length++;
}
}
removeAt(pos) {
if (pos > -1 && pos < this.length) {
let current = this.head
let previous = null
let index = 0
if (pos === 0) {
this.head = current.next
} else {
while (index++ < pos) {
previous = current
current = current.next
}
previous.next = current.next
}
this.length--;
return current.element
}
}
findIndex(element) {
let current = this.head
let index = -1
while (current) {
if (element === current.element) {
return index + 1
}
index++
current = current.next
}
return -1
}
remove(element) {
const index = this.indexOf(element)
return this.removeAt(index)
}
size() {
return this.length
}
}セット：順不同のみ（すなわち重複しない）項目組成物のセットと、数学的概念の同じ制限されたセットで使用されるこのデータ構造が、コンピュータサイエンスのデータ構造のアプリケーション。ES6は実現するためにポイントが既に存在するかどうかを見つけることで、セットのタイプを構築しました。
辞書：フォームデータのデータ構造のIN [キー値]、キー名は、JavaScriptオブジェクトに似た特定の要素を照会することを特徴とします。
-
ハッシュ：キー値（キー、値）のデータ構造に直接アクセスによれば、それがキー値によって位置にマッピングされたルックアップテーブルをスピードアップするために、記録にアクセスするために、このマッピング関数は、ハッシュ関数と呼ばれ、ストレージレコードの配列をハッシュテーブルと呼ばれています。
スプリットリンク、リニアプローブとダブルハッシュ：ハッシュテーブルの競合を処理します。
分離方法は、リンクリストを作成含み、各要素のハッシュテーブル内の位置に格納されます。これは、競合を解決する最も簡単な方法ですが、それはまた、ハッシュテーブルのインスタンスの外に、追加のストレージ・スペースが必要です。
リニアプロービング：テーブルに新しい要素を結合する位置をご希望の場合は、インデックスの場所のためのインデックスがすでに占有されている場合は、位置インデックス+ 1を試してみてください。位置index + 1にも占有されている場合は、その上の位置インデックス+ 2を試してみてください、と。
class HashTable { constructor() { this.table = [] } // 散列函数 static loseloseHashCode(key) { let hash = 0 for (let codePoint of key) { hash += codePoint.charCodeAt() } return hash % 37 } // 使用链表处理冲突 put(key, value) { const position = HashTable.loseloseHashCode(key) if (this.table[position] === undefined) { this.table[position] = new LinkedList() } this.table[position].append({ key, value }) } get(key) { const position = HashTable.loseloseHashCode(key) if (this.table[position] === undefined) return undefined const getElementValue = node => { if (!node && !node.element) return undefined if (Object.is(node.element.key, key)) { return node.element.value } else { return getElementValue(node.next) } } return getElementValue(this.table[position].head) } remove(key) { const position = HashTable.loseloseHashCode(key) if (this.table[position] === undefined) return undefined const getElementValue = node => { if (!node && !node.element) return false if (Object.is(node.element.key, key)) { this.table[position].remove(node.element) if (this.table[position].isEmpty) { this.table[position] = undefined } return true } else { return getElementValue(node.next) } } return getElementValue(this.table[position].head) } // // 使用线性探查 // put(key, value) { // const position = HashTable.loseloseHashCode(key) // if (this.table[position] === undefined) { // this.table[position] = { key, value } // } else { // let index = position+1; // while (this.table[index] !== undefined) { // index++ // } // this.table[index] = { key, value } // } // } // get(key) { // const position = HashTable.loseloseHashCode(key) // const getElementValue = index => { // if (this.table[index] === undefined) return undefined // if (Object.is(this.table[index].key, key)) { // return this.table[index].value // } else { // return getElementValue(index + 1) // } // } // return getElementValue(position) // } } -
ツリー：n（nは> = 1）階層関係を持つノードの有限集合、それがルートであると言うことです逆さまの木のように見えるので、それは「木」と呼ばれて上向きに、葉と下方に、実質的に多くの関係は、ツリー図の特殊な形態として見ることができます。
-
ノード
ルート
内部ノード：非ルートノードと子ノードを持っています
外部ノード/ページノード：ノードがない子ノード
サブツリー：ノードは、大小の木で構成されています
深さ：ルートノードにノード番号
身長：木の高さは、すべてのノードの最大深さに依存します
レベル：あなたはまた、ノード・レベルで層別化することができます
-
バイナリツリーノードは、2つのつの子ノードまで持つことができます。ノードが左の子、他の右の子ノードです。これらの定義は、私たちは、ノードアルゴリズム/、木から挿入見つけて削除して、より効率的な作成に役立ちます。コンピュータサイエンスのアプリケーションバイナリツリーは非常に広いです。
バイナリ検索ツリー（BST）は二分木であり、それだけで使用すると、ノード格納し、右側大きな記憶ノード（親ノードの比）の小さな値（親ノードの比）（または等しい）値を左ことができます。
class binNode {
constructor(key) {
this.key = key
this.left = null
this.right = null
}
}
class BinarySearchTree {
constructor() {
this.root = null
}
insert(key) {
const newNode = new binNode(key)
const insertNode = (node, newNode) => {
if (newNode.key < node.key) {
if (node.left === null) {
node.left = newNode
} else {
insertNode(node.left, newNode)
}
} else {
if (node.right === null) {
node.right = newNode
} else {
insertNode(node.right, newNode)
}
}
}
if (!this.root) {
this.root = newNode
} else {
insertNode(this.root, newNode)
}
}
}
図：図は、ネットワーク構造の抽象モデルである;図は、エッジによって接続されたノード（頂点）のセットであるによって表される任意のバイナリ関係であってもよく、そのような共通のとおり道路地図図、多くの関係を示します。
アルゴリズム
-
ソートアルゴリズム
バブルソート：秒よりも第1の大きい場合は、そのスイッチ次に、隣接する2つの項目を比較するステップと、気泡は船の表面に上昇するかのような元素のアイテムは、正しい順序でその名を上昇しました。
選択ソート：ソートされた最小（または最大）から選択される各データ要素のシーケンスの開始位置に格納された要素の、このサイクルソートが完了するまで。
挿入ソート：データがにすでに新しいを取得するために命じたデータをソートし、加えて、シーケンスデータの数、このアルゴリズムは、少量のデータをソートするために適している、時間の複雑さはO（nはあります^ 2）。
のみ各小配列に小さな配列に元のシーケンスカットは、もはやセグメント化することができ、その後、マージを行い、唯一のソートだけ最後に、小さな配列の配列、ソートと比較大にマージのプロセスをマージする約：ソートマージしません大きいシーケンス、時間複雑度は、O（N Nログ）です。
高速ソーティング：すべてのデータの他の部分よりもデータの全ての部分が小さくなるように前記ソートトリップデータによっては、二つの別々の部分に分類することが、データの上記二つの部分のこの方法は、再帰的にソートされます順序付けられたシーケンスに全体のデータを得るために、時間複雑度は、O（N Nログ）です。
検索アルゴリズムオーダーを検索：同じ要素の特定の要素を見つけるまで、欠点は効率的では、各要素を比較して、リスト1でターゲット要素をしてみましょう。
バイナリ検索：中間基準値に順序付けられたリストでは、それがターゲット要素を発見するまで、この方法は、対象のサブリストに再帰的であるようにテイク目標値を中間要素と比較され、二つのサブリストに分割されます。
貪欲アルゴリズム：問題解決には、かかわらず、全体的な状況の、常にローカルに最適なソリューションを作ります。
動的計画法：グローバル最適なソリューションを導き出すために、ローカルに最適なソリューションにより、問題解決。
概念の複雑さ：時間リソース、スペースの資源：含めたライフサイクル全体で実行する方法、リソース消費のニーズ、。