常用算法第一章

1、栈

class Stack {
    constructor() {
        this.list = []
    }

    // 进栈
    push(e) {
        this.list.push(e)
    }

    // 出栈
    pop() {
        return this.list.pop()
    }

    // 获取栈顶元素
    getTopElement() {
        return this.list[this.list.length - 1]
    }

    // 判断栈是否为空
    isEmpty() {
        return this.list.length ? false : true
    }

    // 返回栈内元素个数
    size() {
        return this.list.length
    }

    // 展示栈内元素
    toString() {
        return this.list.reduce((a, b) => `${a} ${b}`)
    }
}

2、队列

class Queue {
    constructor() {
        this.list = []
    }

    // 入队列
    enqueue(e) {
        this.list.push(e)
    }

    // 出队列
    dequeue() {
        return this.list.shift()
    } 

    // 判断队列是否为空
    isEmpty() {
        return this.list.length ? false : true
    }

    // 返回队列中的元素个数
    size() {
        return this.list.length
    }

    // 返回队列中的第一个元素
    front() {
        return this.size() ? '' : this.list[0]
    }

    // 展示队列中的元素
    toString() {
        return this.list.reduce((a, b) => `${a} ${b}`)
    }
}

3、优先级队列

class PriorityQueue {
    constructor() {
        this.list = []   // 数字小的，权重越大，优先级越高
    }

    // 创建优先级队列的新元素
    element(e, priority) {
        return {e, priority}
    }

    // 入队列
    enqueue(e, priority) {
        let newElement = this.element(e, priority)
        let size = this.size()

        if(!size) this.list.push(newElement);
        else {
            for(let i = 0; i < size; i++) {
                if(newElement.priority < this.list[i].priority) {
                    this.list.splice(i, 0, newElement)
                    return;
                }
            }
            this.list.push(newElement)
        }
    }

    // 出队列
    dequeue() {
        return this.list.shift()
    }

    // 判断队列是否为空
    isEmpty() {
        return this.list.length ? false : true
    }

    // 返回队列中的元素个数
    size() {
        return this.list.length
    }

    // 展示优先级队列中的元素
    toString() {
        return this.list.reduce((a, b) => `${a}\n${b.e}:${b.priority}`, `${this.list[0].e}:${this.list[0].priority}`)
    }
}

4、集合

class Set {
    constructor() {
        this.items = {}
    }

    // 添加元素
    add(value) {
        this.items[value] = value
    }

    // 判断集合中是否有该元素
    has(value) {
        return this.items.hasOwnProperty(value)
    }

    // 删除元素
    delete(value) {
        if(this.has(value)) delete this.items[value];
    }

    // 清空集合
    clear() {
        this.items = {}
    }

    // 判断集合内的元素个数
    size() {
        return Object.keys(this.items).length
    }

    // 返回集合内的所有元素
    values() {
        return Object.keys(this.items)
    }

    // 获取并集
    union(otherSet) {
        let newSet = new Set()
        let currentValues = this.values()
        let otherValues = otherSet.values()

        currentValues.forEach(v => newSet.add(v))
        otherValues.forEach(v => newSet.add(v))

        return newSet
    }

    // 获取交集
    intersect(otherSet) {
        let newSet = new Set()
        let currentValues = this.values()
        
        currentValues.forEach(v => {
            if(otherSet.has(v)) newSet.add(v);
        })

        return newSet
    }

    // 获取差集
    difference(otherSet) {
        let newSet = new Set()
        let currentValues = this.values()

        currentValues.forEach(v => {
            if(!otherSet.has(v)) newSet.add(v);
        })

        return newSet
    }

    // 判断是否为另一个集合的子集
    subset(otherSet) {
        let currentValues = this.values()
        let len = currentValues.length
        for(let i = 0; i < len; i++) {
            if(!otherSet.has(currentValues[i])) return false;
        }

        return true
    }
}

5、洗牌算法，打乱随机数

randomNumber:  function (total,size){/***产生随机数**/
		        var result=[];//最后的结果集
		        var temp=[];//临时变量
		        for(var i=0;i<total;i++){
		            temp.push(i);
		        }
		        //开始打乱数据
		        for(var i=1;i<=total;i++){
		           var start = parseInt(Math.random()*total);
		           var end = parseInt(Math.random()*total);
		           var t=0;
		           //交换数据
		           if(start!=end){
		                t=temp[end];
		                temp[end]=temp[start];
		                temp[start]=t;
		           }
		        }
		        for(var i=0;i<size;i++){
		            result.push(temp[i]);
		        }
		        return result;
		    },

6、