算法

function Stack() {
	this.items = [];
	// 入栈
	Stack.prototype.push = function(element) {
		return this.items.push(element);
	};
	// 从栈中取出元素
	Stack.prototype.pop = function() {
		return this.items.pop();
	};
	// 查看栈顶元素
	Stack.prototype.peek = function() {
		return this.items[0];
	};
	// 判断栈是否为空
	Stack.prototype.isEmpty = function() {
		return this.items.length == 0;
	};
	// 获取栈中元素个数
	Stack.prototype.size = function() {
		return this.items.length;
	};

	Stack.prototype.toString = function() {
		var resultString = "";
		for (var i = 0; i < this.items.length; i++) {
			resultString += this.items[i] + " ";
		}
		return resultString;
	};
}
var stack = new Stack();

function dec2bin(decNumber) {
	// 定义栈对象
	// 循环操作
	while (decNumber > 0) {
		// 获取余数，并且放入栈中
		stack.push(decNumber % 2);
		// 获取整除后的结果，作为下一次运行的数字
		decNumber = Math.floor(decNumber / 2);
	}
	// 从栈中取出0和1
	var binaryString = "";
	while (!stack.isEmpty()) {
		binaryString += stack.pop();
	}
	return binaryString;
}

function Queue() {
	this.items = [];
}
// 加入队列
Queue.prototype.enqueue = function(element) {
	return this.items.push(element);
};
// 从列表中删除前端元素
Queue.prototype.dequeue = function() {
	return this.items.shift();
};
// 查看前端元素
Queue.prototype.front = function() {
	return this.items[0];
};
Queue.prototype.isEmpty = function() {
	return this.items.length == 0;
};
Queue.prototype.size = function() {
	return this.items.length;
};
Queue.prototype.toString = function() {
	var resultString = "";
	for (var i = 0; i < this.items.length; i++) {
		resultString += this.items[i] + " ";
	}
	return resultString;
};
// 击鼓传花算法
function passGame(nameList, num) {
	// 创建一个队列结构
	var queue = new Queue();
	// 将所有人一次加入到队列中
	for (var i = 0; i < nameList.length; i++) {
		queue.enqueue(nameList[i]);
	}
	// 开始数数字
	while (queue.size() > 1) {
		// 不是num的时候，重新加入到队列的末尾
		// 是num这个数字的时候，将其从队列中删除
		// num数字之前的人重新放入到队列的末尾
		for (var j = 0; j < num - 1; j++) {
			queue.enqueue(queue.dequeue());
		}
		// num对应这个人，直接从队列中删除掉
		queue.dequeue();
	}

	// 获取剩下的那个人
	alert(queue.size());
	var endName = queue.front();
	alert("最终剩下的人：" + endName);
	return nameList.indexOf(endName);
}
names = ["a", "b", "c", "d", "f"];
alert(passGame(names, 3));

function PriorityQueue() {
	// 封装一个新的构造函数，用于保存元素和元素的优先级
	function QueueElement(element, priority) {
		this.element = element;
		this.priority = priority;
	}
	// 封装属性
	this.items = [];

	// 实现插入方法
	PriorityQueue.prototype.enqueue = function(element, priority) {
		// 根基传入的元素，创建新的QueueElement
		var queueElement = new QueueElement(element, priority);
		// 获取传入元素应该在正确的位置
		if (this.items.length == 0) {
			this.items.push(queueElement);
		} else {
			var added = false;
			for (var i = 0; i < this.items.length; i++) {
				// 注意： 我们这里是数字越小，优先级越高
				if (queueElement.priority < this.items[i].priority) {
					this.items.splice(i, 0, queueElement);
					added = true;
					break;
				}
			}
			// 遍历完所有的元素，优先级都大于新插入的元素时，就插入到最后
			if (!added) {
				this.items.push(queueElement);
			}
		}
	};

	// 从列表中删除前端元素
	PriorityQueue.prototype.dequeue = function() {
		return this.items.shift();
	};
	// 查看前端元素
	PriorityQueue.prototype.front = function() {
		return this.items[0];
	};
	PriorityQueue.prototype.isEmpty = function() {
		return this.items.length == 0;
	};
	PriorityQueue.prototype.size = function() {
		return this.items.length;
	};
	PriorityQueue.prototype.toString = function() {
		var resultString = "";
		for (var i = 0; i < this.items.length; i++) {
			resultString +=
				this.items[i].element + "-" + this.items[i].priority + " ";
		}
		return resultString;
	};
}

var pq = new PriorityQueue();
pq.enqueue("a", 1);
pq.enqueue("b", 100);
pq.enqueue("c", 10);
pq.enqueue("d", 50);
alert(pq); // a-1 c-10 d-50 b-100

function LinkedList() {
	function Node(data) {
		this.data = data;
		this.next = null;
	}
	this.head = null;
	this.length = 0;
	LinkedList.prototype.append = function(data) {
		// 创建新节点
		var newNode = new Node(data);
		// 判断是否添加的是第一个节点
		if (this.length == 0) {
			this.head = newNode;
		} else {
			// 找到最后一个节点
			var current = this.head;
			while (current.next) {
				current = current.next;
			}
			// 最后节点的next指向新的节点
			current.next = newNode;
		}
		this.length += 1;
	};

	LinkedList.prototype.insert = function(position, data) {
		// 对position进行越界判断
		if (position < 0 || position > this.length) return false;

		// 根据data创建newNode
		var newNode = new Node(data);

		// 判断插入位置是否是第一个
		if (position == 0) {
			newNode.next = this.head;
			this.head = newNode;
		} else {
			var index = 0;
			var current = this.head;
			var previous = null;
			while (index++ < position) {
				previous = current;
				current = current.next;
			}
			newNode.next = current;
			previous.next = newNode;
		}
		//
		this.length += 1;
	};
	LinkedList.prototype.get = function(position) {};
	LinkedList.prototype.indexOf = function(element) {};
	LinkedList.prototype.update = function(position) {};
	LinkedList.prototype.removeAt = function(position) {};
	LinkedList.prototype.remove = function(element) {};
	LinkedList.prototype.isEmpty = function() {};
	LinkedList.prototype.size = function() {};
	LinkedList.prototype.toString = function() {
		// 定义变量
		var current = this.head;
		var listString = "";
		// 循环获取一个个的节点
		while (current) {
			listString += current.data + " ";
			current = current.next;
		}
		return listString;
	};
}
var list = new LinkedList();
list.append("a");
list.append("b");
list.append("c");
alert(list); // "a b c"