《算法与数据结构》

最近学了以下是几种排序方法，记录一下.

选择排序

let sort = (numbers) => {
for(let i=0; i< numbers.length -1; i++){
console.log(`----`) //这个log很精髓
console.log(`i: ${i}`)
let index = minIndex(numbers.slice(i))+ i
console.log(`index: ${index}`)
console.log(`min: ${numbers[index]}`)
if(index!==i){
  swap(numbers, index, i)
  console.log(`swap ${index}: ${i}`)
  console.log(numbers)
}
}
return numbers
}

let swap = (array, i, j) => {
let temp = array[i]
array[i] = array[j]
array[j] = temp
}
let minIndex = (numbers) => {
let index = 0
for(let i=1; i<numbers.length; i++){
if(numbers[i] < numbers[index]){
  index = i
}
 }
  return index
}

---

快速排序

   let quickSort = arr => {
   if (arr.length <= 1) { return arr; } 
   let pivotIndex = Math.floor(arr.length / 2); 
   let pivot = arr.splice(pivotIndex, 1)[0];
   let left = [];
   let right = [];
   for (let i = 0; i < arr.length; i++){
   if (arr[i] < pivot) { left.push(arr[i])
   } else { right.push(arr[i]) } 
   }
   return quickSort(left).concat( 
   [pivot], quickSort(right) )
   }
  

---

归并排序

let mergeSort = arr =>{
let k = arr.length
if(k===1){return arr}
let left = arr.slice(0, Math.floor(k/2))
let right = arr.slice(Math.floor(k/2))
return merge(mergeSort(left), mergeSort(right))
}
let merge = (a, b) => {
if(a.length === 0) return b
if(b.length === 0) return a
return a[0] > b[0] ?
 [b[0]].concat(merge(a, b.slice(1))) :
 [a[0]].concat(merge(a.slice(1), b))
}

---

计数排序

let countSort = arr =>{
let hashTable = {}, max = 0, result = []
for(let i=0; i<arr.length; i++){ // 遍历数组
if(!(arr[i] in hashTable)){ 
  hashTable[arr[i]] = 1
}else{
  hashTable[arr[i]] += 1
}
if(arr[i] > max) {max = arr[i]}
}
for(let j=0; j<=max; j++){ // 遍历哈希表
if(j in hashTable){
  for(let i = 0; i<hashTable[j]; i++){
    result.push(j)
  }
}
}
return result
}

---

更新一下新学的数据结构，链表代码和注解

const createList = value => {
return createNode(value);
};
const appendList = (list, value) => {
const node = createNode(value);
let x = list;
while (x.next) {
x = x.next;
}
// x.next === null //x 是最后一个节点
x.next = node;
return node;
};
const removeFromList = (list, node) => {
let x = list;
let p = node; // 将 p 初始化为 node
while (x !== node && x !== null) { // 对 null 进行处理，如果 node 不在 list 中，x 就可能为 null
p = x;
x = x.next;
 }
if(x === null){ // 若 x 为 null，则不需要删除，直接 return， false 表示无法删除不在list里的节点
return false
}else if(x === p){ // 这说明要删除的节点是第一个节点
p = x.next
return p // 如果删除的是第一个节点，那么就要把新 list 的头节点 p 返回给外面，即 newList = removeFromList(list, list)
}else{
p.next = x.next;
return list // 如果删除的不是第一个节点，返回原来的 list 即可
 }
};

const createNode = value => {
 return {
data: value,
next: null
 };
};

const travelList = (list, fn) => {
 let x = list;
 while (x !== null) {
   fn(x);
x = x.next;
}
};

const list = createList(10);
const node2 = appendList(list, 20);
const node3 = appendList(list, 30);
const node4 = appendList(list, 40);
travelList(list, node => {
 console.log(node.data);
});

---

树代码

const createTree = value => {
 return {
data: value,
children: null,
parent: null
};
};
const addChild = (node, value) => {
const newNode = {
data: value,
children: null,
parent: node
};
node.children = node.children || [];
node.children.push(newNode);
return newNode;
};
const travel = (tree, fn) => {
fn(tree);
if (!tree.children) {
return;
}
for (let i = 0; i < tree.children.length; i++) {
travel(tree.children[i], fn);
}
};

const find = (tree, node) => {
if (tree === node) {
return tree;
} else if (tree.children) {
for (let i = 0; i < tree.children.length; i++) {
  const result = find(tree.children[i], node);
  if (result) {
    return result;
  }
}
return undefined;
} else {
return undefined;
}
};

const removeNode = (tree, node) => {
 const siblings = node.parent.children;
let index = 0;
for (let i = 1; i < siblings.length; i++) {
if (siblings[i] === node) {
  index = i;
}
}
siblings.splice(index, 1);
};

const tree = createTree(10);
const node2 = addChild(tree, 20);
const node3 = addChild(tree, 30);
addChild(tree, 40);
const node5 = addChild(tree, 50);
addChild(node2, 201);
addChild(node2, 202);
addChild(node2, 203);
addChild(node2, 204);
console.log(tree);

const fn = node => {
 console.log(node.data);
};

removeNode(tree, node5);
console.log(tree);

---

日常学习记录，有错误还请指正.