JS高级-数据结构的封装

最近在看了《数据结构与算法JavaScript描述》这本书，对大学里学的数据结构做了一次复习（其实差不多忘干净了，哈哈）。如果能将这些知识捡起来，融入到实际工作当中，估计编码水平将是一次质的飞跃。带着这个美好的愿望，开始学习吧O(∩_∩)O~~

我们知道在JS中，常常用来组织数据的无非是数组和对象（这些基础就不介绍了）。但在数据结构中，还有一些抽象的数据类型：列表、栈、队列、链表、字典、散列、集合、二叉树、图等，可以用来更好的对实际场景建模。当然这些数据类型，原生JS不支持，那么就需要通过封装来模拟，其底层还是数组和对象（被看穿喽~），接下来我们挨个来解析吧

一、列表

定义：列表是一组有序的数据，每个列表中的数据项称为元素。元素可以是任意数据类型， 也不事先限定元素个数。

生活中经常使用到列表，通讯录、购物车、十佳榜单等。当不需要在一个很长的序列中查找元素或排序可以使用列表。

列表的封装代码：

function List() {//列表的构造函数
    this._dataStore = []; //初始化一个空数组来保存列表元素
    this._pos = 0;//当前的位置
}
List.prototype={
    constructor:List,
    clear:function(){//清空列表
        delete this._dataStore;
        this._dataStore = []; this._pos = 0;
    },
    find:function(element){//在列表中查找某一元素，若有返回位置，否则返回-1
        for (var i = 0; i < this._dataStore.length; ++i) {
            if (this._dataStore[i] === element) {return i;}
        };return -1;
    },
    contains:function(element){//判断给定值是否在列表中
        for (var i = 0; i < this._dataStore.length; ++i) {
            if (this._dataStore[i] === element) {return true; break;}
        };return false;
    },
    insert:function(element, after){//当前位置插入新元素
        var insert_pos = this.find(after);
        if (insert_pos > -1) {this._dataStore.splice(insert_pos+1, 0, element);return true;};
        return false;
    },
    append:function(element){this._dataStore[this._dataStore.length] = element;},//末尾添加新元素
    remove:function(element){//删除元素
        var foundAt = this.find(element);
        if (foundAt > -1) {this._dataStore.splice(foundAt,1);return true;};
        return false;
    },
    front:function(){this._pos = 0;},//将当前位置指针设为表首
    end:function(){this._pos = this._dataStore.length-1;},//将当前位置指针设为表尾
    prev:function(){if (this._pos > 0) {--this._pos;}},//当前位置上移指针
    next:function(){if (this._pos < this._dataStore.length-1) {++this._pos;}},//当前位置下移指针
    moveTo:function(_position){this._pos = _position;},//移动当前位置指针到指定位置
    length:function(){return this._dataStore.length;},//获取列表的中元素的个数
    curr_pos:function(){return this._pos;},//返回当前位置指针
    getElement:function(){return this._dataStore[this._pos];},//返回当前位置的列表项
    toString:function(){return this._dataStore;}//返回列表的字符串形式
}

列表与数组比较类似，只是简单的对数组做了二次封装，用案例来展示一下列表的使用场景，进一步加深理解。

案例：影碟租赁自助查询系统

var moviearr=['肖申克的救赎','教父','教父 2','低俗小说','黄金三镖客','十二怒汉','辛德勒名单','黑暗骑士','指环王：王者归来','搏击俱乐部','星球大战5：帝国反击战','飞越疯人院','指环王：护戒使者','盗梦空间','好家伙','星球大战','七武士','黑客帝国','阿甘正传','上帝之城']//数据

var movieList = new List();//电影列表
for (var i = 0; i < moviearr.length; ++i) {movieList.append(moviearr[i]);}//将数据添加到‘电影列表’
var customerList = new List();//客户列表
function Customer(name, movie) {//客户租赁对象的构造函数
    this.name = name;
    this.movie = movie;
}

function checkOut(name, movie, movieList, customerList) {//某客户需要租赁某电影，同时维护两个列表
        if(movieList.contains(movie)){//若检索电影在列表中，新建客户对象添加到客户列表，同时在电影列表中删除该电影
            var c = new Customer(name, movie);
            customerList.append(c);
            movieList.remove(movie);
        }else{console.log(movie + " is not available.");}//若不在电影列表中，则提示不可租赁
        //打印维护后的两个列表
        console.log('movieList:'+movieList.toString()+'\n customerList:'+JSON.stringify(customerList.toString()))
    }

checkOut('gavin','黑客帝国',movieList,customerList)
checkOut('gavin','星球大战',movieList,customerList)
checkOut('zoe','辛德勒名单',movieList,customerList)
checkOut('gulei','黑客帝国',movieList,customerList)

二、栈

定义：栈是一种特殊的列表， 栈内的元素只能通过列表的一端访问， 这一端称为栈顶。

栈是一种后入先出（ LIFO， last-in-first-out） 的数据结构，任何不在栈顶的元素都无法访问。 为了得到栈底的元素， 必须先拿掉上面的元素。生活中常见的例子如：餐厅的一摞盘子，只能从上面逐个取，洗净的盘子也只能摞在最上面。

栈的封装代码：

function Stack() {//栈的构造函数
    this._dataStore = [];//初始化一个空数组来保存列表元素
    this._top = 0;//记录栈顶的位置
}
Stack.prototype={
    constructor:Stack,
    clear:function(){//清空栈
        delete this._dataStore;
        this._dataStore = []; this._top = 0;
    },
    push:function(element){this._dataStore[this._top++] = element;},//向栈内添加元素
    pop:function(){return this._dataStore[--this._top];},//从栈内取出元素
    peek:function(){return this._dataStore[this._top-1]},//查看栈顶元素
    length:function(){return this._top;}//获取列表的中元素的个数
}

相对列表来说，栈的方法不多显得很简洁，同样来几个案例，帮助理解栈的使用场景

案例一：回文

function isPalindrome(word){
    var s = new Stack();
    for (var i = 0; i < word.length; ++i) {s.push(word[i]);}
    var rword = "";
    while (s.length() > 0) {rword += s.pop();}
    if (word == rword) {return true;}else {return false;}
}
console.log(isPalindrome("hello"));//false
console.log(isPalindrome("racecar"));//true

案例二：递归演示

function factorial(n) {
    if (n === 0) {return 1;}else {return n * factorial(n-1);}
}
function fact(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(factorial(5))//
console.log(fact(5))//

三、队列

定义：列队也是一种特殊的列表， 不同的是队列只能在队尾插入元素， 在队首删除元素。

列队是一种先进先出（ First-In-First-Out， FIFO）的数据结构。排在前面的优先处理，后面的依次排队，直到轮到它。生活中常见的例子如：打印任务池，模拟柜台排队的顾客等。

队列的封装代码：

function Queue() {//队列的构造函数
    this._dataStore = [];//初始化一个空数组来保存元素
}
Queue.prototype={
    constructor:Queue,
    clear:function(){//清空队列
        delete this._dataStore;
        this._dataStore = []; this._top = 0;
    },
    enqueue:function(element){this._dataStore.push(element)},//向队尾添加一个元素
    dequeue:function(){return this._dataStore.shift();},//删除队首元素
    front:function(){return this._dataStore[0];},//读取队首元素
    back:function(){return this._dataStore[this._dataStore.length-1];},//读取队尾元素
    empty:function(){if(this._dataStore.length === 0){return true;}else{return false;}},//判断队列是否为空
    toString:function(){//将队列元素拼接字符串
        var retStr = "";
        for (var i = 0; i < this._dataStore.length; ++i) {retStr += this._dataStore[i] + ",";}
        return retStr;
    }
}

列队比栈稍微复杂一点，总体来说也是比较容易理解的。

案例：舞伴分配

function Dancer(name, sex) {
    this.name = name;
    this.sex = sex;
}

function getDancers(males, females) {
    var names = ['F Allison McMillan','M Frank Opitz','M Mason McMillan','M Clayton Ruff','F Cheryl Ferenback','M Raymond Williams','F Jennifer Ingram','M Bryan Frazer','M David Durr','M Danny Martin','F Aurora Adney'];
    for(var i = 0; i < names.length; ++i) {
        var dancer = names[i].split(" ");
        var sex = dancer[0];
        var name = dancer[1];
        if (sex == "F") {females.enqueue(new Dancer(name, sex));
        } else {males.enqueue(new Dancer(name, sex));}
    }
}
function dance(males, females) {
    console.log("The dance partners are: \n");
    while (!females.empty() && !males.empty()) {
        var person1 = females.dequeue();
        var person2 = males.dequeue();
        console.log("Female dancer is: " + person1.name+" and the male dancer is: " + person2.name);
    }
}
var maleDancers = new Queue();
var femaleDancers = new Queue();
getDancers(maleDancers, femaleDancers);
dance(maleDancers, femaleDancers);
if (!femaleDancers.empty()) {console.log(femaleDancers.front().name + " is waiting to dance.");}
if (!maleDancers.empty()) {console.log(maleDancers.front().name + " is waiting to dance.");}

在一般情况下，从列表中删除元素是优先删除先入队的元素，但有时候也可能需要使用一种优先队列的数据来模拟，比如医院的急诊，主要通过给队列中每个元素添加一个优先级别，并改写dequeue方法实现。

dequeue:function() {
    var priority = this._dataStore[0].code;//code表示优先级别，数值越小优先级越高
    for (var i = 1; i < this._dataStore.length; ++i) {priority =Math.min(priority,i);}
    return this.dataStore.splice(priority,1);
}

四、链表

定义：链表是由一组节点组成的集合，每个节点都使用一个对象的引用指向下一个节点，这个引用叫做链。

除了对数据的随机访问，链表几乎可以代替一维数组。它与数组的主要区别是：数组的元素靠位置进行引用，链表靠相互指向进行引用。

链表的封装代码：

function Node(element) {//链表中节点的构造函数
    this.element = element;
    this.next = null;
}
function LList() {//链表的构造函数
    this.head = new Node("head");
}
LList.prototype={
    constructor:LList,
    find:function(item){//查找链表，如果找到则返回该节点，否者返回头节点
        var currNode = this.head;
        while (currNode.element != item) {currNode = currNode.next;}
        return currNode;
    },
    insert:function(newElement, item){//在找到的节点后，新增一个节点
        var newNode = new Node(newElement);//新增节点
        var current = this.find(item);//查找节点
        newNode.next = current.next;//先将当前节点的next赋值给新节点的next
        current.next = newNode;//再将当前节点的next设置为新节点
    },
    display:function(){
        var currNode = this.head;
        while (currNode.next!==null){console.log(currNode.next.element);currNode = currNode.next; }
    },
    findPrev:function(item){//查找链表，返回当前节点的上一个节点
        var currNode = this.head;
        while (currNode.next!==null && currNode.next.element!==item){ currNode = currNode.next; }
        return currNode;
    },
    remove:function(item){//在链表中删除给定的节点
        var prevNode = this.findPrev(item);
        if (prevNode.next !== null) { prevNode.next = prevNode.next.next;}
    }
}

跟之前的三种数据结构不同，链表没有采用数组作为底层数据存储。而是采用对象节点作为基础，同时每个节点中都含有一个next属性指向另一个对象，与优先队列的中的优先级别code颇为类似。总体来看链表是通过每个节点的next属性，将散列的对象连接到了一起。

如上我们只是实现了单向链表，从头遍历到尾很简单，想要反过来遍历就没那么容易了。我们可以通过给节点增加一个prev属性，指向它的前一个节点，也能实现双向链表。当然，双向链表在新增和删除节点时的操作也要复杂一些，需要同时修改前后节点的next或prev属性。

另外，我们还可以让单向链表的尾节点指向首节点，这样就变成了循环列表。这样需要对链表的一些方法进行改造，防止遍历链表时出现无限循环。

五、字典

定义：字典是一种以键值对形式存储的数据结构。

JS中对象就是以字典的形式设计的，但字典的基础是数组，而不是对象。这样可以进行排序，况且JS中一切皆对象，数组也不例外。

字典的封装代码：

function Dictionary() {//字典的构造函数
    this._datastore = new Array();
}
Dictionary.prototype={
    constructor:Dictionary,
    add:function(key,value){ this._datastore[key]=value; },//增加一条键值对
    find:function(key){ return this._datastore[key] },//查找指定key，返回对应value的值
    remove:function(key){ delete this._datastore[key] },//删除指定key的键值对
    showAll:function(){ //打印字典的所有键值对
        //若需排序可以给Object.keys(this._datastore)数组追加sort方法
        Object.keys(this._datastore).forEach(function(key){console.log(key+" -> "+this._datastore[key]);}.bind(this))
    },
    count:function(){//返回字典所含键值对数量
        var n = 0;
        for(var key in this._datastore) {++n;}
        return n;
    },
    clear:function(){ //清空字典
        Object.keys(this._datastore).forEach(function(key){ delete this._datastore[key];}.bind(this))
    }
}

字典依然采用数组作为底层数据存储，但是与普通按序号索引的数组不同，它只能以key进行查询。

六、散列

定义：散列是一种常用的数据存储技术， 散列后的数据可以快速地插入或取用。 散列使用的数据结构叫做散列表。

是通过一个散列函数（Hash，哈希）将键映射为一个范围是 0 到散列表长度的数字。

散列的封装代码：

function HashTable() {//散列的构造函数
    this._table = new Array(137);//数组的长度应该为质数，即预算散列表的长度
}
HashTable.prototype={
    constructor:HashTable,
    simpleHash:function(data){//简单的散列函数（返回键字符串的ASCII累加除数组长度的余数）
        var total = 0;
        for (var i = 0; i < data.length; ++i) {total += data.charCodeAt(i);}
        return total % this._table.length;
    },
    betterHash:function(data){//更好的散列函数算法，减少碰撞
        const H = 37;
        var total = 0;
        for (var i = 0; i < data.length; ++i) {total += H * total + data.charCodeAt(i);}
        total = total % this._table.length;
        if (total < 0) {total += this._table.length-1;}
        return parseInt(total);
    },
    put:function(data){var pos = this.simpleHash(data);this._table[pos] = data;},//使用简单散列函数
    //put:function(key,data){var pos = this.betterHash(key);this._table[pos] = data;},//使用高级散列函数
    showDistro:function(){//显示散列表中的数据
        var n = 0;
        for (var i = 0; i < this._table.length; ++i) {
            if (this._table[i] !== undefined) {console.log(i + ": " + this._table[i]);}
        }
    },
    get:function(key){return this._table[this.betterHash(key)];},
}

散列其实是通过一种机制（散列函数），将数据存储到散列表对应的位置上去，当机制跟内容相关时仅出现修改才会改变。（MD5类似散列函数的机制）

当散列函数对于多个输入产生同样的输出时称为碰撞。开链法（用数组存储多个相同输出）和探测法（线性探测下个位置，直到有空值存入）

案列：数据存储

var students = ["David", "Jennifer", "Donnie", "Raymond", "Cynthia", "Mike", "Clayton", "Danny", "Jonathan"];
var hTable = new HashTable();
for (var i = 0; i < students.length; ++i) {hTable.put(students[i]);}
hTable.showDistro();//九条数据，被散列成八条，产生于了一个碰撞

七、集合

定义：是一种不含不同元素的数据结构，这些元素是无序且不重复的。

集合的封装代码：

function Set() {//集合的构造函数
    this._dataStore = [];
}
Set.prototype={
    constructor:Set,
    add:function(data){//向集合中添加元素
        if (this._dataStore.indexOf(data) < 0) {this._dataStore.push(data);return true;
        } else {return false;}
    },
    remove:function(data){//从集合中移除元素
        var pos = this._dataStore.indexOf(data);
        if (pos > -1) {this._dataStore.splice(pos,1);return true;
        } else {return false;}
    },
    contains:function(){//检查一个元素是否在集合中
        if (this._dataStore.indexOf(data) > -1) {return true;} else {return false;}
    },
    size:function(){return this._dataStore.length},//返回集合的长度
    union:function(set){//返回与另一个集合的并集
        var tempSet = new Set();
        for (var i = 0; i < this._dataStore.length; ++i) {tempSet.add(this._dataStore[i]);}
        for (var i = 0; i < set.dataStore.length; ++i) {
            if (!tempSet.contains(set.dataStore[i])) {tempSet.dataStore.push(set.dataStore[i]);}
        }
        return tempSet;
    },
    intersect:function(set){//返回与另一个集合的交集
        var tempSet = new Set();
        for (var i = 0; i < this._dataStore.length; ++i) {
            if (set.contains(this._dataStore[i])) {tempSet.add(this._dataStore[i]);}
        }
        return tempSet;
    },
    subset:function(set){//判断集合是否其他集合的子集
        if (this.size() > set.size()) {return false;
        } else {
            this._dataStore.foreach(function(member){if (!set.contains(member)) {return false;}})
        }
        return true;
    },
    difference:function(set){//返回与另一个集合的补集
        var tempSet = new Set();
        for (var i = 0; i < this._dataStore.length; ++i) {
            if (!set.contains(this._dataStore[i])) {tempSet.add(this._dataStore[i]);}
        }
        return tempSet;
    },
    show:function(){return this._dataStore;},//显示集合中的元素
}

集合的数据结构比较简单，主要实现了添加元素时检查唯一性，以及交集、并集、补集的方法和子集的检查。

八、二叉树和二叉查找树

定义：树由一组以边连接的节点组成，二叉树是子节点不超过两个的特殊树。

二叉树的封装代码：

function Node2(data, left, right) {//二叉树中节点的构造函数
    this.data = data;
    this.left = left;
    this.right = right;
    this.show = function(){return this.data;};
}
function BST(){//二叉查找树的构造函数
    this.root = null;
}
BST.prototype={
    constructor:BST,
    insert:function(data){//插入节点
        var n = new Node2(data, null, null);
        if (this.root == null) {
            this.root = n;
        } else {
            var current = this.root;
            var parent;
            while (true) {
                parent = current;
                if (data < current.data) {
                    current = current.left;if (current == null) {parent.left = n;break;}
                } else {
                    current = current.right;if (current == null) {parent.right = n;break;}
                }
            }
        }
    },
    inOrder:function(node){
        if (!(node == null)) {
        this.inOrder(node.left);
        console.log(node.show() + " ");
        this.inOrder(node.right);
        }
    },
    getMin:function(){//获取最小的数，即最左节点
        var current = this.root;
        while (!(current.left == null)) {current = current.left;}
        return current.data;
    },
    getMax:function(){//获取最大的数，即最右节点
        var current = this.root;
        while (!(current.right == null)) {current = current.right;}
        return current.data;
    },
    find:function(data){//查找指定的值
        var current = this.root;
        while (current != null) {
            if (current.data == data) {return current;
            } else if (data < current.data) {current = current.left;
            } else {current = current.right;}
        }
        return null;
    },
    remove:function(data){ root = this.removeNode(this.root, data);},//调用removeNode删除节点
    removeNode:function(node,data){ //删除节点
        if (node == null) {return null;}
        if (data == node.data) {
            if (node.left == null && node.right == null) {return null;} // 没有子节点的节点
            if (node.left == null) {return node.right;} // 没有左子节点的节点
            if (node.right == null) {return node.left;} // 没有右子节点的节点
            // 有两个子节点的节点
            var tempNode = getSmallest(node.right);
            node.data = tempNode.data;
            node.right = removeNode(node.right, tempNode.data);
            return node;
        } else if (data < node.data) {
            node.left = removeNode(node.left, data);
            return node;
        } else {
            node.right = removeNode(node.right, data);
            return node;
        }
    }
}

二叉树有点类似链表的数据结构，采用节点的左右属性来指向两个子节点。

九、图和图算法

定义：图是由边的集合即顶点的集合组成的。常用于地图和航班等信息数据的建模。

图的封装代码：

function Graph(v) {//图的构造函数,v表示顶点的数量
    this.vertices = v;
    this.edges = 0;
    this.adj = [];
    for (var i = 0; i < this.vertices; ++i) {
        this.adj[i] = [];
        this.adj[i].push("");
    }
    this.marked = [];//遍历标志位
    for (var i = 0; i < this.vertices; ++i) {this.marked[i] = false;}
    this.edgeTo = [];//路径查找时，存储两个顶点之间的边
}
Graph.prototype={
    constructor:Graph,
    addEdge:function(v,w){//增加一条从顶点v到顶点w的边
        this.adj[v].push(w);
        this.adj[w].push(v);
        this.edges++;
    },
    showGraph:function(){var p='';//显示当前图的结构
        for (var i = 0; i < this.vertices; ++i) { p+='顶点'+i+' ->';
            for (var j = 0; j < this.vertices; ++j) {
                if (this.adj[i][j] !== undefined){ p+=this.adj[i][j]+' ';}
            };p+='\n';
        }console.log(p)
    },
    dfs:function(v){//深度优先搜索
        this.marked[v] = true;
        if (this.adj[v] !== undefined) {console.log("深度优先: " + v);}
        for(var w in this.adj[v]) {
            if(!this.marked[this.adj[v][w]]){this.dfs(this.adj[v][w]);}
        }
    },
    bfs:function(s){//广度优先搜索
        var queue = [];
        this.marked[s] = true;
        queue.push(s); // 添加到队尾
        while (queue.length > 0) {
            var v = queue.shift(); // 从队首移除
            if (v!==''&&v !== undefined) {console.log("广度优先: " + v);}
            for(var w in this.adj[v]) {
                if (!this.marked[this.adj[v][w]]) {
                    this.marked[this.adj[v][w]] = true;
                    this.edgeTo[this.adj[v][w]] = v;
                    queue.push(this.adj[v][w]);
                }
            }
        }
    },
    pathTo:function(v){//获取最短路径，即顶点v到顶点0的边（必须先广度搜索生成edgeTo）
        var source = 0;
        if (!this.marked[v]) {return undefined;}
        var path = [];
        for (var i = v; i != source; i = this.edgeTo[i]) {path.push(i);}
        path.push(source);
        return path;
    }
}

在对图数据模型进行搜索时，有深度优先和广度优先两种。当进行最短路径查找时，就是广度优先搜索的过程。