js的栈和队列基本算法

栈

栈是一种遵循LIFO（先进后出）原则的有序集合。
方法：push(elements):向栈顶添加元素。pop():从栈顶移除元素（好坑，栈顶是尾部，我被绕晕了。）

使用类实现栈：

function Stack() {
        var items = [];
        //添加一个或几个元素到栈顶
        this.push = function(element) {
            return items.push(element);
        };
        //从栈顶移除一个元素
        this.pop = function(element) {
            return items.pop(element);
        };
        //获取最进添加的一个元素
        this.peek = function(element) {
            return items[items.length -1];
        };
        //栈是否为空
        this.isEmpty = function() {
            return items.length == 0;
        };
        //返回栈里元素的个数
        this.size = function(){
            return items.length;
        };
        //清除栈内的所有元素
        this.clear = function(){
            return items = [];
        };
        this.print = function(){
            console.log(items.toString());
        };
    }

实例化：

var stack = new Stack();
console.log(stack.isEmpty());//true

例子：利用栈实现十进制转二进制
思路：十进制转其他进制是用十进制数除以几进制（转八进制就除以八），除数大于0时，每除一次得到一个余数，直到除数小于进制数，将得到的余数从最后一位向上读，就得到了该进制下的数。比如12转2进制，
12 % 2 余0
6 % 2 余 0
3 % 2 余1
1 % 2 余1
得到的二进制从下往上读：1100

function baseConverter(decNumber,base){
    //decNumber是要转换的数，base代表要转换的进制
    var stack = new Stack();//实例化
    var remainder = 0;//余数
    var baseString = '';//结果
    var digits = '0123456789ABCDEF';//在转换成16进制时，余数多了A,B,C,D,E,F，所以这个变量用于转换数据
    while(decNumber > 0) {
        remainder = decNumber % base;
        decNumber = Math.floor(decNumber / base);
        //这里一定要先取余再取商，因为在商=1的时候，向下取整就变成0，余数也是0，所以应该在对decNumber向下取整之前求余。大家可以测试一下交换着两句代码的位置，将15转换成二进制，得到的是1110
        stack.push(remainder);//将余数推入栈中
    }
    //将结果从栈中取出,调用isEmpty()方法，判断栈中是否还有数
    while(!stack.isEmpty()){
        baseString += digits[stack.pop()];
    }
    return baseString;
}
//测试
console.log(baseConverter(15,2));//1111
console.log(baseConverter(15,8));//17
console.log(baseConverter(15,16));//F

队列

队列是遵循FIFO（先进先出）原则的集合
方法：push(elements):向队列尾部添加元素,shift():移除队列首部的第一个元素。

实例1：优先队列
对于普通队列添加元素的方式：

function Queue(){
    var items = [];
    this.enqueue = function(element){
        return items.push(element);
    }
}

优先队列多了一个参数用于判断优先级。参数越小优先级越高

function PriorityQueue(){
    var items = [];
    this.isEmpty = function(){
        return items.length == 0;
    };
    this.print = function(){
        console.log(items);
    };
    function QueueElement(element,priority){
        this.element = element;
        this.priority = priority;
   };
   this.enqueue = function(element,priority){
        var queueElement = new QueueElement(element,priority);

        //如果队列为空，直接将数据放入队列
        if(this.isEmpty()){
            items.push(queueElement);
        }else{
            var added = false;
            //循环遍历items里面的元素，如果有优先级低于新增的元素，就将新增元素放在该元素之前。
            for(var i=0 ; i<items.length; i++){
                if(queueElement.priority < items[i].priority) {
                    item.splice(i,0,queueElement);//splice()方法：第一个参数是元素索引，第二个参数表示要删除的个数，第三个参数是新增的元素。
                    added = true;
                    break;
                }
            }
            if(!added){
                item.push(queueElement);
            }
        }
   };
}
//测试
var priorityQueue = new PriorityQueue();
priorityQueue.enqueue('Melody',2);
priorityQueue.enqueue('Hello',3);
priorityQueue.enqueue('World',1);
priorityQueue.print();
//结果：优先级高的先入队列
//[ QueueElement { element: 'World', priority: 1 },
 // QueueElement { element: 'Melody', priority: 2 },
  //QueueElement { element: 'Hello', priority: 3 } ]