js数据结构与算法
一、javascript基础
1.javascript的数据类型有：数字、字符串、函数、对象、undefined、null和数组、日期、正则表达式。
2.变量作用域：本地变量和全局变量。在一个函数里，变量没有使用var 关键字，则是申明或者引用了全局变量。
3.转换为布尔值为假值的有
|undefined|
|-null-|
| +0，-0，NaN |
"" 空字符串
4.创建对象两种方式：构造函数和字面量方式创建
5.数组
- 一维数组
添加：结尾：push ；开头：unshift
删除：结尾：pop ;删除第一个元素：shift()
任意位置删除或添加元素splice
numbers.splice(5,3):删除从数组索引5开始的3个元素
numbers.splice(5,0,2,3,4):从索引5开始，删除0个元素，之后3个参数就是要添加到数组里的值
- 二维和多维数组
用数组嵌套实现矩阵或多维数组
- 数组的核心方法
| 方法名 | 描述 |
| every | 对数组的每一项运行给定函数，如果该函数对每一项都返回true，则返回true |
| filter | 对数组的每一项运行给定函数，返回该函数会返回true的项组成的数组 |
| forEach | 对数组的每一项运行给定函数，这个方法没有返回值 |
| indexOf | 返回第一个与给定参数相等的数组元素的索引 |
| map | 对数组的每一项运行给定函数，返回每次函数调用的结果组成的数组 |
| slice | 传入索引值，将数组里对应索引范围内的元素作为新数组返回 |
| splice | 可以对数组任意索引位置处进行增加和删除 |
如果需要迭代整个数组，可以用forEach 。
返回新数组的遍历方法
map 返回的数组里面包含了传入map方法的函数的运行结果（返回值）
filter 返回的新数由使函数返回true的元素组成
reduce 接收一个函数作为参数，这个函数有4个参数，previousValue、currentValue、index、array.返回一个将被叠加到累加器的值，reduce方法停止执行后会返回这个累加器。
二、栈：后进先出
实现栈，用数组来保存栈里的元素
function Stack(){
var items=[];
this.push=function(el){ //入栈
items.push(el);
}
this.pop=function(el){ //出栈
items.push(el);
}
this.peek=function(el){ //返回栈顶元素
return items[items.length-1];
}
this.isEmpty=function(el){ //判断栈是否为空
return items.length==0;
}
this.clear=function(){
items=[];
}
}使用：
var stack=new Stack();
stack.push(5);
stack.push(8);
stack.pop(); //移除8
stack.peek(); //栈顶元素此时为5三、队列：先进先出
function Queue(){
var items=[];
this.enqueue=function(el){ //向队列尾部添加元素
items.push(el);
}
this.dequeue=function(){ //移除队列的第一项，并返回被移除的元素
items.shift();
}
this.front=function(){ //返回队列最前面的项
return items[0];
}
}使用：
var queue=new Queue();
queue.enqueue("Jhon")
queue.enqueue("lisa")
queue.dequeue() //剩余lisa优先队列：元素的添加和移除是基于优先级的
function PriorityQueue(){
var items=[];
function QueueElement(Value,Priority){
this.value=Value;
this.proiority=Priority
}
this.enqueue=function(el,priority) { //给队列添加元素，必须传入两个参数，一个是元素的值，一个是优先级
var queueElement=new QueueElement(el,priority) //生成QueueElement对象实例
if(this.isEmpty()){ //如果是空队列，则直接压入
items.push(queueElement)
}else{ //如果不是，则逐个比较优先级，将本元素插入比自己优先级低的元素之前
var flag=false;
for(var i=0;i四、集合：用对象来实现
集合是一组无序且唯一的项组成的（不重复）
function Set(){
var items={};
this.has=function(value){
return items.hasOwnProperty(value);
};
this.add=function(value){
if(!this.has(value)){
items[value]=value;
return ture;
}
return false;
};
this.remove=function(value){
if(this.has(value)){
delete items[value];
return ture;
}
return false;
};
this.values=function(){
return Object.keys(items);
}
}Object.keys 返回一个所有元素为字符串的数组，其元素来自于从给定的object上面可直接枚举的属性。这些属性的顺序与手动遍历该对象属性时的一致
五、树
二叉搜索树BST：只允许你在左侧节点存储比父节点小的值，在右侧节点存储比父节点大或等于的值。
function BinarySearchTree(){
var Node=function(key){
this.key=key;
this.left=null;
this.right=null;
};
var root=null;
this.insert()=function(key){ //向树中插入一个键
var newNode=new Node(key);
if(root===null){
root=newNode;
}else{
insertNode(root,newNode)
}
}
var insertNode=function(node,newNode){
if(newNode.key树的遍历
1、中序遍历
this.inOrderTraverse=function(callback){
inOrderTraverseNode(root,callback);
}
var inOrderTraverseNode=function(node,callback){
if(node!==null){
inOrderTraverseNode(node.left,callback);
callback(node.key);
inOrderTraverseNode(node.right,callback);
}
}2、先序遍历
this.preOrderTraverse=function(callback){
preOrderTraverseNode(root,callback);
}
var preOrderTraverseNode=function(node,callback){
if(node!==null){
callback(node.key);
preOrderTraverseNode(node.left,callback);
preOrderTraverseNode(node.right,callback);
}
}3、后序遍历
this.postOrderTraverse=function(callback){
preOrderTraverseNode(root,callback);
}
var postOrderTraverseNode=function(node,callback){
if(node!==null){
callback(node.key);
postOrderTraverseNode(node.left,callback);
postOrderTraverseNode(node.right,callback);
}
}六、排序和搜索算法
1、冒泡排序
//冒泡排序算法
function bubbleSort(arr){
for(var i=0; iarr[j+1]){
var temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
} 改进
function bubbleSort(arr){
for(var i=0; iarr[j+1]){
var temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
} 2、选择排序
找到数据结构中的最小值将其放在第一位，找到第二小的值放在第二位。
function selection(ary){
var min;
for (var i=0;iary[j]) {
ary[min]=ary[j]
}
}
if( ary[min]!==ary[i]){
var temp=ary[i];
ary[i]=ary[min];
ary[min]=temp;
}
}
} 3、插入排序：假设第一项已经排序，判断第二项应该插入第一项前面还是原位
function insert(ary){
var j,temp;
for(var i=0;i0&&ary[j-1]>temp){
ary[j]=ary[j-1];
j--;
}
ary[j]=temp;
}
} 4、归并排序：把原始数组切分成小的数组，直到每个小数组只有一个位置，接着将小数组归并成大的数组
var mergeSort=function(ary){
var len=ary.length;
if(len===1){return ary}
var mid=Math.floor(length/2);
left=ary.slice(0,mid);
right=ary.slice(mid,len);
return merge(mergeSort(left),mergeSort(right));
}
var merge=function(left,right){
var result=[],il=0,ir=0;
while(il5、快速排序
//快速排序算法
function quickSort(arr){
if(arr.length <= 1){
return arr;
}
var left = [];
var right =[];
var pivotkey = arr[0];
for(var i=1; i二分搜索
this.binarySearch = function(item){
var low=0,high=ary.length-1,mid,ele;
while(low<=high){
mid=Math.floor((low+high)/2);
ele=ary[mid];
if(eleitem){
high=mid-1;
}else{
return mid;
}
}
return -1;
} 八：贪心算法
最少硬币找零问题d1=1,d2=5,d3=10,d4=25;
我的实现
function minCoinChange(coins){
var count=0;//用来存储硬币个数
var result=[];
var digui=function(coins)
{
if (Math.floor(coins / 25)) { //大于25美分
var num=Math.floor(coins / 25);
count += num;
coins = coins - 25*num;
console.log(coins)
for(var i=0;i可以看到，有大量重复代码，并且调用多次递归，四次执行的代码思想都一样
改进：
function MinCoinChange0(coins){
var coins=coins;
this.makeChange=function(amount){
var change=[];
var total=0;
for(var i=coins.length;i>=0;i--){
var coin=coins[i];
while(total+coin<=amount){
change.push(coin);
total+=coin
}
}
return (change)
}
}
var minCoinChange0=new MinCoinChange0([1,5,10,25])
console.log(minCoinChange0.makeChange(36))这样就可以随便指定零钱的基数，并且核心代码也比较少。这里，注意用的是while而不是if，If的话就只进入一次，比如找零是20，那么0+10<20；则会给结果数组压入10，继续for循环，coins[2]变为5，再压入5，最后压入1.结果为【10,5,1】
所以必须用while,当第一次0+10<20,total=10，会再次判断10+10<=20.再进入本次循环，压入10，结果为【10,10】