学习Javascript数据结构与算法,数据结构和算法学

作者:计算机知识

第 1 章 JavaScript简介

  • 使用 Node.js 搭建 Web 服务器
npm install http-server -g
http-server
  • JavaScript 的档期的顺序有数字、字符串、布尔值、函数和目的。还有 undefined 和 null ,以及数组、日期和正则表明式。

  • 操作符

    算数操作符 描述
    加法
    - 减法
    * 乘法
    / 除法
    % 取余
    递增
    -- 递减
    赋值操作符 描述
    = 赋值
    = 加/赋值 (x = y) == (x = x y)
    -= 减/赋值 (x -= y) == (x = x - y)
    *= 乘/赋值 (x = y) == (x = x y)
    /= 除/赋值 (x /= y) == (x = x / y)
    %= 取余/赋值 (x %= y) == (x = x % y)
    比较操作符 描述
    == 相等
    === 全等
    != 不等
    > 大于
    >= 大于等于
    < 小于
    <= 小于等于
    逻辑操作符 描述
    &&
    ||
    !
    位操作符 描述
    &
    |
    ~
    ^ 异或
    << 左移
    >> 右移
  • typeof 操作符能够回来变量或表达式的项目

  • JavaScript还帮助 delete 操作符,能够去除对象里的性质

    数值类型 转换成布尔值
    undefined false
    null false
    布尔值 true是 true ,false是 false
    数字 0 、 -0 和 NaN 都是 false ,其他都是 true
    字符串 如果字符串是空的(长度是0)就是 false ,其他都是 true
    对象 true
  • 相当于操作符( == 和 === )

类型(x) 类型(y) 结 果
null undefined true
undefined null true
数字 字符串 x == toNumber(y)
字符串 数字 toNumber(x) == y
布尔值 任何类型 toNumber(x) == y
任何类型 布尔值 x == toNumber(y)
字符串或数字 对象 x == toPrimitive(y)
对象 字符串或数字 toPrimitive(x) == y
  • 假诺x和y是如出1辙类别,JavaScript会相比它们的值或对象值。其余未有列在那一个表格中的情状
    都会回去 false 。
  • toNumber 和 toPrimitive 方法是当中的,并基于以下表格对其进展估值。
  • toNumber 方法对分歧类型重回的结果如下:
值类型 结 果
undefined NaN
null 0
布尔值 如果是 true ,返回 1 ;如果是 false ,返回 0
数字 数字对应的值
字符串 将字符串解析成数字。如果字符串中包含字母,返回 NaN ;如果是由数字字符组成的,转换成数字
对象 Number(toPrimitive(vale))
  • toPrimitive 方法对两样档案的次序再次来到的结果如下:
值类型 结 果
对象 如果对象的 valueOf 方法的结果是原始值,返回原始值。如果对象的 toString方法返回原始值,就返回这个值;其他情况都返回一个错误
  • === 操作符,倘若比较的多个值类型分裂,相比较的结果正是 false 。尽管比较的七个值类型一样,结果会依靠下表决断。

#

类型(x) 结 果
数字 x和y数值相同(但不是 NaN ) true
字符串 x和y是相同的字符 true
布尔值 x和y都是 true 或 false true
对象 x和y引用同一个对象 true

<b><em>代码运维景况:任何能够运作Javascript的条件就可以。</em></b>

新坑占位 ——本种类小说全体文化从《学习Javascript数据结构与算法》1书中学习,有乐趣的前端童鞋能够去买一本书仔细看看。

抓紧时间学习了,一步三个足迹,绝不松懈,这是本种类的率先篇,算法和数据结构是程序猿你的必修课,面试看懂外人复杂的主次那么些都以基础,必要巩固,所以有了下边包车型大巴小说,20拾.二.46.贰伍分

ECMAScript 6

  • 用 let 替代 var 注解变量
  • 常量 const PI = 3.141593;
  • 模板字面量
var name='123';
console.log(`my name is ${name}`);
  • 箭头函数
let circleArea2 = (r) => 3.14 * r * r;
  • 函数的参数暗许值
function sum(x=1,y=2,z=3){
    return x y z;
}
sum(4,6);//13
  • 宣示张开和剩余参数

在ES5中,大家能够用 apply() 函数把数组转化为参数。
ES6有了拓展操作符( ... )。

var params = [3, 4, 5];
console.log(sum(...params));
等价于
var params = [3, 4, 5];
console.log(sum.apply(undefined, params));

在函数中,打开操作符( ... )也得以取代 arguments ,当作剩余参数使用。

function restParamaterFunction (x, y, ...a) {
    return (x   y) * a.length;
}
console.log(restParamaterFunction(1, 2, "hello", true, 7)); //输出9;
等价于
function restParamaterFunction (x, y) {
    var a = Array.prototype.slice.call(arguments, 2);
    return (x   y) * a.length;
};
  • 增进的目的属性

ES6引进了数组解构的定义,能够用来三回开始化多少个变量

var [x,y] = ['a','b'];//初始化
[x,y] = [y,x];//值互换
  • 使用类举行面向对象编制程序
class Book { //{2}
    constructor (title, pages, isbn) {
        this.title = title;
        this.pages = pages;
        this.isbn = isbn;
    }
    printIsbn(){
        console.log(this.isbn);
    }
}
  1. 继承
class ITBook extends Book { 
    constructor (title, pages, isbn, technology) {
        super(title, pages, isbn); 
        this.technology = technology;
    }
    printTechnology(){
        console.log(this.technology);
    }
}
let jsBook = new ITBook('学习JS算法', '200', '1234567890', 'JavaScript');
console.log(jsBook.title);
console.log(jsBook.printTechnology());
  1. 使用性质存取器
class Person {
    constructor (name) {
        this._name = name; 
    }
    get name() { 
        return this._name;
    }
    set name(value) { 
        this._name = value;
    }
}
let lotrChar = new Person('Frodo');
console.log(lotrChar.name); //{4}
lotrChar.name = 'Gandalf'; //{5}
console.log(lotrChar.name);
lotrChar._name = 'Sam'; //{6}
console.log(lotrChar.name);
  1. 此外作用

ES6还有此外一些成效,包含列表迭代器、类型数组、 Set 、 Map 、 WeakSet 、 WeakMap 、模
块、尾调用、 Symbol ,等等

第一章:队列

本种类小说将讲述使用 <b>Javascript</b> 完结:

席卷但不限于:

  1. 栈、
  2. 队列
  3. 链表,双向链表,循环链表
  4. 散列表
  5. 字典
  6. 二叉树
  7. 图(DFS / BFS)
  8. 冒泡排序
  9. 分选排序
  10. 插入排序
  11. 归并排序
  12. 立即排序
  13. 顺序找寻
  14. 二分查找
  15. O 表示法
  16. 动态规划和贪欲算法

数据结交涉算农学习笔记(一)

一. 如何是队列?

<b>天性:先进去的因素,料定先骑行列。( FIFO )
生活中最常见的正是排队购买小车票。</b>

队列是1种新鲜的线性表;
最初始的行列总是空的
它只同目的在于表的前端(front)举行删减操作;
而在表的后端(rear)进行扦插操作;
队列是壹种操作受限制的线性表;
开始展览插队操作的端称为队尾( 入队 );
拓展删减操作的端称为队头 ( 出队 );
首先个插入的因素正是队头;

聊起行列,明确必要提到的是数组,数组在Javascript里是可修改的目的,以下是数组的壹部分骨干措施:

  1. concat(item壹,item二,...,itemN) 合并3个可能三个数组 重返结果
  2. push(item) 往数组最终边增添一个或多个要素,使用:“ , ” 分开参数。
  3. pop() 从数组最前边,移除2个成分,并回到这一个值
  4. shift() 函数删除数组第3个成分,并回到那一个值
  5. unshift(item1,item贰,...,itemN) 向数组的上马增加贰个或更加的多因素,并赶回数组更新后的尺寸。
  6. slice(startIndex,endIndex) 从已某些数组中回到选定的成分。
  7. splice(index,deleteNumber,item1...) 方法向/从数组中增进/删除项目,然后再次来到被剔除的品种。
  8. ...

· 个人职业早已快整整两年了,感受到协调的底蕴相比非常虚亏,加上前端最初始就是自学,假设未来想走的更远,还得在基础上较劲。

率先付诸1个最宗旨的定论:我们做算法和布局其实轻便,就是空间换时间,只怕时间换空间。要看要求了。一般的情事下,大家都喜爱空间换时间。因为内部存款和储蓄器大嘛,总是用啊用不完。

2.实现

<code>
//我们创设贰个类(函数)用来 表示队列
/*
我们将完成以下方法:
enqueue() 入队
dequeue () 出队
front () 重临队头
isEmpty() 队列是不是为空
clear() 清空队列
size() 再次来到这几个行列的尺寸
print() 打字与印刷队列全部因素
*/
function Queue(){
var items =[];
this.enqueue = function(elements){
items.push(elements); //入队,第七个进入的是队头,所未来来入队的要素应该是今后增加。
}
this.dequeue = function(){
return items.shift() //出队,3个入队的相应首先出队,所以理应删除第壹个因素
学习Javascript数据结构与算法,数据结构和算法学习笔记。}
this.front = function(){
return items[0]; //获取队头,重临第二个入队的成分
}
this.isEmpty = function(){
return items.length == 0;
}
this.clear = function(){
items = [];
}
this.size = function(){
return items.length;
}
this.print = function(){
console.log(items);
}
}

var newQueue = new Queue();
newQueue.enqueue(5); // [5]
newQueue.enqueue(8); //[5,8]
newQueue.enqueue(10); //[5,8,10]
newQueue.dequeue() //[8,10];
newQueue.isEmpty() // false
</code>
...

· 本类别作品也是一方面念书1边写,如文中因自个儿知识浅薄导致错误的地方,望各位多多指正。

最宗旨的一部分构作育略过了,从栈开头吧。

叁. 队列的兑现注重借助数组,所以掌握和学会数组的大旨措施是很有不能缺少的。

· 至于为何要写出来,重要照旧写3次加深本人的醒悟,有错的地点也能尽早校勘,其次正是做多个轻易易行的分享,最后正是满意本身小小的的虚荣心,喜欢的同桌点个赞。【 手动可爱状 】

1 堆栈

4. 接下去大家上学习成绩优秀先队列。普通的队列是1种先进先出的数据结构,成分在队列尾追加,而从队列头删除。在优先队列中,成分被给予优先级。当访问成分时,具备最高优先级的要素起始删除。优先队列具备最高等先出 (first in, largest out)的行事特征。

· 预期每一周更新三篇左右,尽量三个月内更完。至于怎么这么慢,更新小说之余还得看看其余的书,专门的学业也会有那么一丝丝忙。好吧 就好像此多了~

库房即为栈,上边是1个数组完毕的栈:该栈固定大小,即存放的要素最大值固定,数组第0位代表栈底。就算急需存入不分明数量的数额,请使用链表来落到实处栈。

—— END ——

class Stack

         {

         public:

                   Stack(int iAmount = 拾);   //设置栈所在数组的最大值

                   ~Stack();

                   int Pop(int&iVal);       //出栈

                   int Push(intiVal);       //入栈

                   int Top(int&iVal);     //栈顶成分

         private:

                   int *m_pData;       //栈所在数据首地址。。轻松起见用int应该改用泛型

                   int m_iCount;            //使用的成分个数

                   int m_iAmount;        //栈最大因素个数

         };

Stack::Stack(int iAmount)

         {

         m_pData= new int[iAmount];//再而三的数组,当中稳定大小来划分栈中元素

         m_iCount= 0;                 //初始化栈内成分为0个

         m_iAmount= iAmount;

         }

Stack::~Stack()

         {

         delete m_pData;

         }

int Stack::Pop(int&iVal)

         {

         if(m_iCount>0)

                   {

                   --m_iCount;                  //栈内成分--

                   iVal= m_pData[m_iCount];    

                   return 1;

                   }

         return 0;

         }

int Stack::Push(int iVal)

         {

         if(m_iCount<m_iAmount)

                   {

                   m_pData[m_iCount]= iVal;

                   m_iCount;

                   return 1;

                   }

         return 0;

         }

int Stack::Top(int&iVal)

         {

         if(m_iCount>0 && m_iCount<=m_iAmount)

                   {

                   iVal= m_pData[m_iCount-1];

                   return 1;

                   }

         return 0;

         }

 

2 队列

上面是三个应用队列来对树举行广度优先检索。

广度优先分化于深度优先,即优先遍历最邻近根节点的各种节点:

大家的算法是:
壹,根节点入队
贰,出队一个节点,算一遍遍历,直到队列为空
三,将刚出队的节点的子节点入队
4,转到2

队列的风貌如下图:

 

 

// The Node

//////////////////////////////////////////////////////////////////////////

struct Node  //树的种种节点

         {

         Node(char cChar, intiSubNodeNum=0);

         ~Node();

         char m_cChar;               //该节点编号举个例子(A.B.C……)

         int m_iSubNodeNum;  //该节点的子节点数目

         Node**m_arrNodePointer; //指向子节点

         };

 

Node::Node(char cChar, intiSubNodeNum)

         {

         m_cChar= cChar;

         m_iSubNodeNum= iSubNodeNum;

         if(iSubNodeNum!=0)

                   m_arrNodePointer= new Node*[iSubNodeNum];

         else

                   m_arrNodePointer= NULL;

         }

 

Node::~Node()

         {

         if(m_arrNodePointer!=NULL)

                   delete[] m_arrNodePointer;

         }

 

// The Queue

//////////////////////////////////////////////////////////////////////////

class Queue

         {

         public:

                   Queue(int iAmount=10);

                   ~Queue();

                   //return 0 means failed, return 1 means succeeded.

                   int Enqueue(Node* node);

                   int Dequeue(Node* & node);

         private:

                   int m_iAmount;

                   int m_iCount;

                   Node**m_ppFixed; //The pointer array to implement thequeue.

                   int m_iHead;

                   int m_iTail;

         };

 

Queue::Queue(int iAmount)

         {

         m_iCount= 0; //队列中已经采纳的因素

         m_iAmount= iAmount; //队列最大因素个数

         m_ppFixed= new Node*[iAmount]; //起初化一个数组保存成分

         m_iHead= 0;   //头地点,即取成分位置,在数组起来

         m_iTail= iAmount-一; //插入成分地点。在数组后面部分

         }

 

Queue::~Queue()

         {

         delete[] m_ppFixed;

         }

 

int Queue::Enqueue(Node* node)

         {

         if(m_iCount<m_iAmount)

                   {

                   m_iTail;

                   if(m_iTail > m_iAmount-1)

                            m_iTail= 0;

                   m_ppFixed[m_iTail]= node;

                   m_iCount;

                   return 1;

                   }

         else

                   return 0;

         }

 

intQueue::Dequeue(Node* & node)

         {

         if(m_iCount>0)

                   {

                   node= m_ppFixed[m_iHead];

                   m_iHead;

                   if(m_iHead > m_iAmount-1)

                            m_iHead= 0;

                   --m_iCount;

                   return 1;

                   }

本文由bwin必赢发布,转载请注明来源

关键词: