javaScript实现的数据结构_js散列读取一个文本文件,使用散列显示该文件中出现的单词和它们在文件中出现的次-CSDN博客

本文链接：https://blog.csdn.net/qq_26746521/article/details/52536357

javaScripts中的函数

javaScripts中的函数没有引用传递，只有值传递
但是数组作为参数传递给函数时，此时的数组是作为地址传递给函数的，可以理解为引用传递。

变量作用域

拥有全局作用域的变量：1、在函数外定义的变量
2、在函数体内没有经过var申明的变量
javaScripts拥有的函数作用域，没有块级作用域
什么是块级作用域：
任何一对花括号（｛和｝）中的语句集都属于一个块，在这之中定义的所有变量在代码块外都是不可见的，我们称之为块级作用域。
c、java等其他语言都是有块级作用域，但是javaScript没有块级作用域。

#include <stdio.h>  
void main()  
{  
   int i=2;  
   i--;  
   if(i)  
   {  
       int j=3;  
   }  
   printf("%d/n",j);  
}

会输出use an undefined variable:j的错误
但是在js中没有块级作用域

 function test(){
    for(var i=0;i<3;i++){
    }
    console.log(i);   //会输出3
  }
  test();

会输出3 在{}之外仍然可以访问到i
递归

 function he(i) {
      if(i==0){
        return i;
      }
     else{
        return  i+he(i-1);
      }
   }

实现的就是从0加到5利用递归实现

一维数组和数组的操作方法

创建数组

   var numbers=[];
     var cc=new Array();
     console.log(cc instanceof Array)   //检测是否为数组
      var cc=[1,'e',true];

数组中的元素可以不是数字
由字符串生成数组

  var aa="hello,jdisajd,djska";
    var cc=aa.split(",");
    console.log(cc.length)   //3

将数组转化为字符串
使用的是join()方法和tostring()方法
join()的方法

    var aa=[1,3,6,'dda',cc];
     console.log(aa.join("c"));

输出的结果是用C来连接数组中的每一个元素
改变数组的函数
向数组添加一个元素
push unshift

var aa=[1,3,6,'dda',cc];
    aa.push('21');   //在数组的末尾加一个元素
    aa.unshift('1212')  //在数组的开始添加一个元素

从数组中删除一个元素

 aa.pop()  //从数组的末尾删除一个元素
 aa.shift()  //从数组的开始删除一个元素

从数组的中间添加或者删除元素
splice()方法
实现为数组添加元素需要提供一下参数
1、开始索引
2、想要删除的元素的个数（添加是的时候为0）
3、想要添加的数组的元素

    var aa=[1,3,6,4,6];
    aa.splice(1,4,4,5,6,7);
    console.log(aa);  //[1, 4, 5, 6, 7]

第二个参数为要删除的个数，只是添加的话就为0，
后面的参数都是添加到数组的元素。
为数组排序
reverse()
这个方法知识实现了将数组的元素进行反转。
sort()
这个方法是将数组的元素按照ACII码来排序。但是可以改变这种排序的方式，通过传递一个函数。

/*    function compare(num1,num2){
       return num1-num2;
    }*/
function compare(num1,num2){
    if(num1>num2){
        return -1;
    }else{
        return 1
    }
}
    var aa=[1,3,6,12,4,6];
    aa.sort(compare);
    console.log(aa);  //[1, 4, 5, 6, 7]

上面的compare函数被传递给sort函数从而实现排序
迭代器方法、
1、不生成新数组的迭代器
不会产生一个新的数组，但是会对数组中的每一个元素都会进行一个操作。
forEach()函数接受的是一个函数，对数组中的每一个元素都执行这个函数

    function cc(num) {
        console.log(num*num);
    }
    var cc1=[1,2,3,4]
    cc1.forEach(cc);

every()函数接受的是一个返回值为布尔类型的函数。对数组每一个元素使用该函数，如果对于所有元素都返回true，该方法就会返回true，否则会返回false 与

 function cc(num) {
        return num%2==0;
    }
    var cc1=[2,4]
    console.log(cc1.every(cc));  //true

some()方法接受的是一个返回布尔值得函数，只有一个元素返回true就会使得这个函数返回true 或

  function cc(num) {
        return num%2==0;
    }
    var cc1=[1,3,2,4]
    console.log(cc1.some(cc));   //true

2、生成新数组的迭代器
map() 方法这个方法是和forEach()类似的功能，但是这个方法返回的的是一个新的数组，不会改变原来的数组。

  function cc(num) {
        return num+5;
    }
    var cc1=[1,3,2,4]
    console.log(cc1.forEach(cc));  //undefined
    console.log(cc1.map(cc));  //[6, 8, 7, 9]

filter()方法接受的也是一个返回值为布尔类型的函数，和every()方法不同的是当岁数组的所有的元素应用该函数时，会将结果为true的元素集合到一个数组中，会将结果为false的元素集合到一个数组中

  function even(num) {
        return num%2==0;
    }
    function odd(num) {
        return num%2==1;
    }
    var cc1=[1,3,2,4]
    console.log(cc1.filter(even));  //[2,4]
    console.log(cc1.filter(odd));  //[1,3]

indexOf()
方法着数组中的某一个元素

var aa="hello,jdisajd,djska";
    var cc=aa.split(",");
    console.log(cc.indexOf("hello"))

二维数组

js中本身没有二维数组，通过下边的方法模拟创建一个二维数组

   Array.martix=function(rows,cols,init){
        var arr=[];
       for(var i=0;i<rows;i++){
           var cc=[];
           for(var j=0;j<cols;j++){
               cc[j]=init;
           }
           arr[i]=cc;
       }
       return arr;
   }
    var ss=Array.martix(2,3,0);
    console.log(ss[0][0]); //0

列表 list 实现的是索引列表

js中列表可以是任意的数据类型
这里写图片描述
用js实现列表和对列表的操作
https://github.com/wenjuanzhao/git/blob/master/3.1-list.js

栈 -元素先进后出

js实现栈的数据结构
https://github.com/wenjuanzhao/git/blob/master/3.2-stack.js
栈是一种特殊的列表栈内的元素只能在一端访问元素。这一端称为栈顶
使用栈实现数值之间的进制转换

  function mulBase(num,base) {
      var s=new stack();
      do{
          s.push(num%base);
          num=Math.floor(num/base);
      }while(num>0)
      return s;
  }
  var cc="";
    var ss=mulBase(12,2);
   while(ss.length()>0){
       cc+=ss.pop();
   }
    console.log(cc);

使用栈来实现递归的过程

  function ff(n){
        var s=new stack();
        while(n>1){
            s.push(n--);
        }
        var product=1;
        while(s.length()>0){
            product*=s.pop();
        }
        return product;
    }
    console.log(ff(5));

使用栈实现了检测一个表达式中的括号是否匹配

 function validBraces(str) {
     let brackets = str.match(/[\[\]\(\)\{\}]/g),
             ss=new stack(), symbal;
     for(var i=0;i<brackets.length;i++){
         switch(brackets[i]){
             case "(":ss.push("(");break;
             case ")":
                 symbal=ss.pop();
                 if(symbal!="(")
                     return false;
                 break;
             case "{":ss.push("{");break;
             case "}":
                 symbal=ss.pop();
                 if(symbal!="{")
                     return false;
                 break;
         }
     }
      return ss.length()>0?false:true;
 }
    console.log(validBraces("2.3+23/12+{((1))}"))

队列

先进先出的数据结构
使用node从文件读取跳舞者的姓名和性别，js实现队列的算法来实现跳舞排队。一男一女一个组合剩下的男或者女按照队列的规则在排队
https://github.com/wenjuanzhao/git/tree/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/5.1-queue
队列实现基数排序
基数排序：http://baike.baidu.com/link?url=GjmU4fcHfrE0ls_w2fT8lxGjZwQoK9hapNCtU0b2up5Iax1Fp_UOs7oz7FxZA8kyGon0vs5rudQHw1rydm37G_
js利用实现基数排序：要实现这个算法需要9个队列。
https://github.com/wenjuanzhao/git/blob/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/5.4-queue.js

delete删除操作符

delete用于删除对象的属性但是不能删除变量和函数

    var o={x:1};
     //使用了delete来删除了对象的属性
    delete o.x;
    console.log(o.x)  //undefined
    function aa(){
        return 1;
    }
     //使用delete不能删除不了这个函数也删除不了定义的变量
    delete aa;
    console.log(typeof aa);  //function

链表

数组的缺点：在很多编程语言中数组的长度是固定的，
1、当数组中的被填满的时候，很难再扩充数组的长度，
2、数组中添加和删除都是比较困难的，因为一旦删除或者添加都必须移动其他的元素
所以在很多的编程语言中就封装了链表
链表是一个一个节点组成的集合
每一个节点都使用一个对象的引用指向它的后继。
头节点：链表最前面的一个特殊的节点。
设计一个基于对象的链表
注意：向链表中插入节点的时候1、首先创建一个节点，并将链表的头节点赋给新节点2、在链表上进行循环，如果当前的element属性和我们要找的信息不符，就从当前的节点移动到下一个节点。3、一旦找到可以插入的位置，首先将next属性设置为后面节点next属性对应的值。
实现插入的关键性语句
newNode.next=current.next;
current.next=newNode;
实现删除某个节点的时候必须是先找到被删除节点的前一个节点，用findPrev这个方法来找到
js实现单向链表
https://github.com/wenjuanzhao/git/blob/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/5.5-%E5%8D%95%E5%90%91%E9%93%BE%E8%A1%A8.js
js实现双向链表
这里写图片描述
改变了每一个节点的具体结构
https://github.com/wenjuanzhao/git/blob/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/5.6-%E5%8F%8C%E5%90%91%E5%88%97%E8%A1%A8.js
js实现循环列表

循环链表和单向链表相似，节点类型都是一样的。唯一的区别是，在创建循环链表时，让其头节点的 next 属性指向它本身，即：
head.next = head
让你果然有错误的约瑟夫问题

散列表

散列表的核心是设计一个碰撞很少的散列函数，数组的长度是特定的，要存储的键保存在数组中，保存在数组的特定的位置中。。键值映射的一个函数就是散列函数
减少碰撞的方法
1、开链法检测去除碰撞
https://github.com/wenjuanzhao/git/blob/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/8.3%E5%BC%80%E9%93%BE%E6%B3%95%E5%8E%BB%E9%99%A4%E7%A2%B0%E6%92%9E.js
2、线性探测法去除碰撞
https://github.com/wenjuanzhao/git/blob/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/8.4%E7%BA%BF%E6%80%A7%E6%8E%A2%E6%B5%8B%E5%8F%91%E5%8E%BB%E9%99%A4%E7%A2%B0%E6%92%9E.js
使用个散列结构读取文本文件中的单词，统计出现的单词和单词出现的次数
https://github.com/wenjuanzhao/git/tree/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/8.5hashTable/person

集合

包含不同元素的数据结构。
两个特性：
1、结合中的成员是无序的
2、不允许相同的成员在集合中
对集合的操作并集、交集、补集
js实现的类
https://github.com/wenjuanzhao/git/blob/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/9.1%E9%9B%86%E5%90%88.js

二叉树和二叉查找树

实现二叉查找树的算法
1、设置当前结点为根节点
2、如果被插入结点的值小于当前节点，则设一个新的当前结点为原来节点的左节点，反之执行第4步
3、如果当前左节点null，将新的节点插入这个位置退出循环，反之继续执行下一次循环
4、设置当前的节点为原来的节点的右节点
5、如果当前右节点null，将新的节点插入这个位置退出循环，反之继续执行下一次循环
js实现二叉树
https://github.com/wenjuanzhao/git/blob/master/javaScript%E5%AE%9E%E7%8E%B0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/9.2js%E5%AE%9E%E7%8E%B0%E4%BA%8C%E5%8F%89%E6%A0%91.js