JavaScript数据结构-栈相关操作方法

栈

/**
 * 数据结构-栈
 * 栈是一种遵循后进先出原则的有序集合，新添加或者待删除的元素保存在栈的同一端，称之为栈顶，另一端叫做栈底
 */

//创建栈

//定义一个数组来保存栈的元素
var items = [];

/**
 * 声明一个类来表示栈
 */
function Stack() {
    //向栈添加元素
    this.push = function(element) {
        items.push(element)
    };
    //移除栈元素
    this.pop = function(element) {
        items.push(element)
    };
    //查看栈顶元素
    this.peek = function() {
        return items[items.length - 1]
    };
    //查看栈是否为空
    this.isEmpty = function() {
        return items.length == 0;
    };
    //或者
    this.size = function() {
        return items.length
    };

    //清空栈元素
    this.clear = function() {
        items = [];
    };
    //打印栈元素
    this.print = function() {
        console.log(items.toString())
    }
}

let stack1 = new Stack();
stack1.push(9);
stack1.push(22);
console.log(stack1.size());
stack1.print();
console.log(stack1)

//ES6的Stack类
//定义私有属性
let _items = Symbol();
/**
 * 这样定义了一个假的私有属性，因为Object.getOwnPropertySymbols方法能够获取到类里面声明的Symbol属性
 */
class Stack6 {
    constructor() {
        this[_items] = [];
    }
    push(element) {
        this[_items].push(element);
    }
    pop(element) {
        tthis[_items].pop(element)
    }
    peek() {
        return this[_items][this[_items].length - 1]
    }
    isEmpty() {
        return this[_items].length == 0
    }

    size() {
        return tthis[_items].length;
    }
    clear() {
        this[_items] = [];
    }

    print() {
        console.log(this[_items].toString())
    }
}

let stack6 = new Stack6();
stack6.push(2);
stack6.push(90);

stack6.print(); //2,90

let a = Object.getOwnPropertySymbols(stack6);
stack6[a[0]].push(1)
console.log(a); //[Symbol()]
stack6.print(); //2,90,1


/**
 * weakMap实现类，该数据类型可以确保属性是私有
 * WeakMap，保存键值对
 */

//声明一个WeakMap类型的变量


let Stack4 = (function() {
    const itemss = new WeakMap();

    class Stack3 {
        constructor() {
            //以this为键
            itemss.set(this, []);
        }

        push(element) {
            //以this为键，从itemss中获取值
            let s = itemss.get(this);
            s.push(element)
        }

        pop() {
            let s = itemss.get(this);
            let r = s.pop();
            return r;
        }
    }
})();

如下图向栈添加元素：

队列

/**
 * 队列，就是遵循先进先出原则的一组有序的项
 * 最新添加的元素必须排在尾部，并且从顶部删除元素
 * 
 */

//声明一个用于存储队列元素的数据结构

let items = [];

//声明一个类
function Queue() {
    //向队列中添加一个或者多个元素
    this.enqueue = function(element) {
        items.push(element)
    }

    //从队列中移除元素，是从队列的顶部开始移除
    this.dequeue = function() {
        return items.shift()
    }

    //查询队列的第一位元素，就是索引为0的元素
    this.front = function() {
        return items[0];
    }

    //检测队列是否为空
    this.isEmpty = function() {
        return items.length == 0;
    }

    //打印队列元素
    this.print = function() {
        console.log(items.toString())
    }

    //队列的长度
    this.size = function() {
        return items.length;
    }
}

let queue = new Queue();
queue.enqueue("duxin");
queue.enqueue("job");
queue.enqueue("nanjing")
queue.print();
console.log(queue.isEmpty());
queue.dequeue();
console.log(queue.size());
queue.print();

/**
 * ES6语法实现Queue类
 */

let Queue2 = (function() {
    const items = new WeakMap();

    class Queue2 {
        constructor() {
            items.set(this, []);
        }

        enqueue(element) {
            let q = items.get(this);
            q.push(element)
        }

        dequeue() {
            let q = items.get(this);
            let r = q.shift();
            return r;
        }
        front() {
            let q = items.get(this);
            return q[0];
        }

        isEmpty() {
            let q = items.get(this);
            return q.length == 0
        }
        print() {
            let q = items.get(this);
            console.log(q.toString());
        }
        size() {
            let q = items.get(this)
            console.log(q)
        }
    }
    return Queue2
})();

let ddd = new Queue2();
ddd.enqueue("ddd");
ddd.print(); //ddd
console.log(ddd.isEmpty()); //false


/**
 * 优先级队列
 */

function PriorityQueue() {
    let items = [];

    function QueueElement(element, priority) {
        this.element = element;
        this.priority = priority;
    }

    //向队列中添加一个或者多个元素
    this.enqueue = function(element, priority) {
        let queueElement = new QueueElement(element, priority);

        let add = false;
        for (let index = 0; index < items.length; index++) {
            if (queueElement.priority < items[index].priority) {
                items.splice(index, 0, queueElement);
                add = true;
                break;
            }
        }
        if (!add) {
            items.push(queueElement);
        }
    }

    //从队列中移除元素，是从队列的顶部开始移除
    this.dequeue = function() {
        return items.shift()
    }

    //查询队列的第一位元素，就是索引为0的元素
    this.front = function() {
        return items[0];
    }

    //检测队列是否为空
    this.isEmpty = function() {
        return items.length == 0;
    }

    //打印队列元素
    this.print = function() {
        for (let index = 0; index < items.length; index++) {
            console.log(`${items[index].element}优先级为： ${items[index].priority}`)
        }
    }

    //队列的长度
    this.size = function() {
        return items.length;
    }
}


let priorityQueue = new PriorityQueue();
priorityQueue.enqueue("beijing", 9);
priorityQueue.enqueue("nanjing", 1);
priorityQueue.enqueue("shanghai", 1);
priorityQueue.enqueue("hangzhou", 2)
priorityQueue.print();
console.log(priorityQueue.size());


/**
 * 循环队列
 */
function hotPotato(nameList, num) {
    let queue = new Queue();

    for (let index = 0; index < nameList.length; index++) {
        // const element = array[index];
        queue.enqueue(nameList[index]);
    }

    let eliminated = ''
    while (queue.size() > 1) {
        for (let index = 0; index < num; index++) {
            queue.enqueue(queue.dequeue());
        }
        eliminated = queue.dequeue();
        console.log(eliminated + '在循环中被淘汰了！')
    }
    return queue.dequeue();
}

let name = ["duxin", "xuelian", "zhanyun", "John", "Jack"];
let winner = hotPotato(name, 5);
console.log("获胜者：" + winner)