JavaScript数据结构——队列的实现

　　前面楼主简单介绍了JavaScript数据结构栈的实现，http://www.cnblogs.com/qq503665965/p/6537894.html，本次将介绍队列的实现。  

　　队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

　　队列的两种主要操作是：向队列中插入新元素和删除队列中的元素。插入操作也叫做入队，删除操作也叫做出队。入队操作在队尾插入新元素，出队操作删除队头的元素。下图演示了这两个操作。

 

　　队列的另外一项重要操作是读取队头的元素。这个操作叫做 peek() 。该操作返回队头元素，但不把它从队列中删除。除了读取队头元素，我们还想知道队列中存储了多少元素，可以使用 length 属性满足该需求；要想清空队列中的所有元素，可以使用 clear() 方法来实现。下表定义了队列的一些主要方法：

dataStorage	Array	存储数据的底层数据结构
enqueue	int	入队
dequeue	fucntion	出队
front	fucntion	返回队首元素
back	fucntion	返回队尾元素
toString	fucntion	显示队列内的所有元素
empty	function	判断队列是否为空

　　

 

 

 

 

 

 

队列的实现

function Queue(array) {   
    if (array instanceof Array) {
        this.dataStorage = array;
    } else {
        throw "'"+array + "' is not an Array";
    }
}

Queue.prototype = {
    enqueue: function (element) {//向队列中添加元素
        this.dataStorage.push(element);
    },
    dequeue: function () {//删除队首元素
        return this.dataStorage.shift();
    },
    front: function () {//返回队首元素
        return this.dataStorage[0];
    },
    back: function () {//返回队尾元素
        return this.dataStorage[this.dataStorage.length - 1];
    },
    toString: function () {//输出队列中所有元素
        var result = "";
        for (var i = 0; i < this.dataStorage.length; i++) {
            result += this.dataStorage[i] + "\t";
        }
        return result;
    },
    empty: function () {//判定队列是否为空
        if (this.dataStorage.length == 0) {
            return true;
        }
        return false;
    }
}

　　测试：　　

 var queue = new Queue(['a','b']);       
console.log(queue.toString());
//queue.dequeue();//a出队
//console.log(queue.toString());
console.log(queue.front());//队头元素
console.log(queue.back());//队尾元素
queue.dequeue();
queue.dequeue();
console.log(queue.empty());

 

队列的应用——基数排序

　　原理：对于 0~99 的数字，基数排序将数据集扫描两次。第一次按个位上的数字进行排序，第二次按十位上的数字进行排序。每个数字根据对应位上的数值被分在不同的盒子里。

　　假设有这样一个数组：{4, 73, 51, 76, 70, 19, 63, 64, 43, 12}，经过基数排序第一次扫描之后，数字被分配到如下盒子中：　　

Box 0: 70
Box 1: 51
Box 2: 12
Box 3: 73,63,43
Box 4: 4,64
Box 5: 76
Box 6: 
Box 7:
Box 8:
Box 9: 19

　　根据盒子的顺序，对数字进行第一次排序的结果如下：

　　70,51,12,73,63,43,4,64,76,19

　　然后根据十位上的数值再将上次排序的结果分配到不同的盒子中：

Box 0: 4
Box 1: 12,19
Box 2: 
Box 3: 
Box 4: 43
Box 5: 51
Box 6: 63,64
Box 7: 70,73,76
Box 8: 
Box 9: 

　　最后，将盒子中的数字取出，组成一个新的列表，该列表即为排好序的数字：

　　4,12,19,43,51,63,64,70,73,76

　　使用队列代表盒子，可以实现这个算法。我们需要九个队列，每个对应一个数字。将所有队列保存在一个数组中，使用取余和除法操作决定个位和十位。算法的剩余部分将数字加入相应的队列，根据个位数值对其重新排序，然后再根据十位上的数值进行排序，结果即为排好序的数字。

　　下面是根据相应位（个位或十位）上的数值，将数字分配到相应队列的方法：　　

     function allocation(nums,queues,n,digit) {
            for (var i = 0; i < n; ++i) {
                if (digit == 1) {
                    queues[nums[i] % 10].enqueue(nums[i]);
                }
                else {
                    queues[Math.floor(nums[i] / 10)].enqueue(nums[i]);
                }
            }
        }

　　下面是从队列中收集数字的方法：　

    function collection(queues, nums) {
            var i = 0;
            for (var digit = 0; digit < 10; ++digit) {
                while (!queues[digit].empty()) {
                    nums[i++] = queues[digit].dequeue();
                }
            }
        }

　　测试程序：

        var queues = [];
        for (var i = 0; i < 10; ++i) {
            queues[i] = new Queue([]);
        }
        var nums = [];
        for (var i = 0; i < 10; ++i) {//目标排序数组
            nums[i] = Math.floor(Math.floor(Math.random() * 101));
        }
        console.log("排序前:");
        showArray(nums);
        allocation(nums, queues, 10, 1);
        collection(queues, nums);
        allocation(nums,queues,10,10);
        collection(queues, nums);
        console.log("排序后");
        showArray(nums);

        function showArray(array) {
            console.log(array);
        }     

　　结果：

　　下篇楼主将带来，链表的实现。

　　本文的示例代码地址：https://github.com/LJunChina/JavaScript