前端学习总结（一）——常见数据结构的javascript实现

１.列表类

// 列表类
function List() {
    this.listSize = 0;  // 列表的元素个数
    this.pos = 0;  // 列表的当前位置
    this.dataStore = []; // 初始化一个空数组来保存列表元素
    this.clear = clear;  // 清空列表中所有元素
    this.find = find;  // 查找列表中某一元素
    this.toString = toString;  // 返回列表的字符串形式
    this.insert = insert;  // 在现有元素后插入新元素
    this.append = append;  //在列表的末尾添加新元素
    this.remove = remove;  // 从列表中删除元素
    this.front = front;  // 将列表的当前位置移动到第一个元素
    this.end = end;  // 将列表的当前位置移动到最后一个元素
    this.prev = prev;  // 将当前位置前移一位
    this.next = next;  // 将当前位置后移一位
    this.length = length;  // 返回列表中元素的个数
    this.currPos = currPos;  // 返回列表的当前位置
    this.moveTo = moveTo;  // 将当前位置移动到指定位置
    this.getElement = getElement;  // 返回当前位置的元素
    this.length = length;  // 返回列表中元素的个数
    this.contains = contains;  // 判断给定元素是否在列表中
}

//在列表的末尾添加新元素
function append(element) {
    this.dataStore[this.listSize++] = element;
}
// 查找列表中某一元素
function find(element) {
    for (var i = 0; i < this.dataStore.length; ++i) {
        if (this.dataStore[i] == element) {
            return i;
        }
    }
    return -1;
}
// 从列表中删除元素
function remove(element) {
    var foundAt = this.find(element);
    if (foundAt > -1) {
        this.dataStore.splice(foundAt,1);
        --this.listSize;
        return true;
    }
    return false;
}
// 返回列表中元素的个数
function length() {
    return this.listSize;
}
// 初始化一个空数组来保存列表元素
function toString() {
    return this.dataStore;
}
// 在现有元素后插入新元素
function insert(element, after) {
    var insertPos = this.find(after);
    if (insertPos > -1) {
        this.dataStore.splice(insertPos+1, 0, element);
        ++this.listSize;
        return true;
    }
    return false;
}
// 清空列表中所有元素
function clear() {
    delete this.dataStore;
    this.dataStore = [];
    this.listSize = this.pos = 0;
}

// 判断给定元素是否在列表中
function contains(element) {
    for (var i = 0; i < this.dataStore.length; ++i) {
        if (this.dataStore[i] == element) {
            return true;
        }
    }
    return false;
}

// 将列表的当前位置移动到第一个元素
function front() {
    this.pos = 0;
}
// 将列表的当前位置移动到最后一个元素
function end() {
    this.pos = this.listSize-1;
}
// 移到前一个位置
function prev() {
    if (this.pos > 0) {
        --this.pos;
    }
}
// 移到后一个位置
function next() {
    if (this.pos < this.listSize-1) {
        ++this.pos;
    }
}
// 返回列表的当前位置
function currPos() {
    return this.pos;
}
// 将当前位置移动到指定位置
function moveTo(position) {
    this.pos = position;
}
// 返回当前位置的元素
function getElement() {
    // return this.dataStore[this.pos];
}

2.栈

// 构造函数
function Stack() {
    this.dataStore = []; //数据结构为数组
    this.top = 0; // 指向栈顶元素
    this.push = push;  // 向栈顶添加一个元素
    this.pop = pop;  // 删除栈顶元素
    this.peek = peek;  // 返回栈顶元素
    this.length = length;  // 返回栈的长度
    this.clear = clear;  // 清空栈
}

// 向栈顶添加元素
function push(element) {
    this.dataStore[this.top++] = element;
}

// 删除栈顶元素
function pop() {
    return this.dataStore[--this.top];
}

// 返回栈顶元素
function peek() {
    return this.dataStore[this.top-1];
}

// 返回栈的长度
function length(){
    return this.top;
}

// 清空栈
function clear() {
    this.top = 0;
}

// 测试代码：
var s = new Stack();
s.push("David");
s.push("Raymond");
s.push("Bryan");
print("length: " + s.length());
print(s.peek());
var popped = s.pop();
print("The popped element is: " + popped);
print(s.peek());
s.push("Cynthia");
print(s.peek());
s.clear();
print("length: " + s.length());
print(s.peek());
s.push("Clayton");
print(s.peek());

// 输出为：
length: 3
Bryan
The popped element is: Bryan
Raymond
Cynthia
length: 0
undefined
Clayton

3.队列

function Queue() {
    this.dataStore = []; // 利用数组实现队列
    this.enqueue = enqueue;  // 入队
    this.dequeue = dequeue;  // 出队
    this.front = front;  // 取队首元素
    this.back = back;  // 取队尾元素
    this.toString = toString;  // 显示队列内的所有元素
    this.empty = empty;  // 判断队空
}

// 入队
function enqueue(element) {
    this.dataStore.push(element);
}

// 出队
function dequeue() {
    return this.dataStore.shift();
}

// 取队首元素
function front() {
    return this.dataStore[0];
}

 // 取队尾元素
function back() {
    return this.dataStore[this.dataStore.length-1];
}

// 显示队列内的所有元素
function queueToString() {
    var retStr = "";
    for (var i = 0; i < this.dataStore.length; ++i) {
        retStr += this.dataStore[i] + "\n";
    }
    return retStr;
}

// 判断队空
function empty() {
    if (this.dataStore.length == 0) {
        return true;
    }
    else {
        return false;
    }
}

// 测试代码
var q = new Queue();
q.enqueue("Meredith");
q.enqueue("Cynthia");
q.enqueue("Jennifer");
print(q.queueToString());
q.dequeue();
print(q.queueToString());
print("Front of queue: " + q.front());
print("Back of queue: " + q.back());

输出为：
Meredith
Cynthia
Jenniefer
Cynyhia

Front of queue: Cynthia
Back of queue: Jennifer

4.链表

4.1单链表

function Node(element) {
    this.element = element;
    this.next = null;
}

function LList() {
    this.head = new Node("head");
    this.find = find;  // 查找给定结点
    this.insert = insert;  // 在item后面插入新节点newElement
    this.display = display;  // 显示链表中的所有节点
    this.findPrevious = findPrevious;  // 查找当前节点的前一个结点
    this.remove = remove;  // 删除一个节点
}

// 删除一个节点
function remove(item) {
    var prevNode = this.findPrevious(item);
    if (!(prevNode.next == null)) {
        prevNode.next = prevNode.next.next;
    }
}

// 查找当前节点的前一个结点
function findPrevious(item) {
    var currNode = this.head;
    while (!(currNode.next == null) && (currNode.next.element != item)) {
        currNode = currNode.next;
    }
    return currNode;
}

// 显示链表中的所有节点
function display() {
    var currNode = this.head;
    while (!(currNode.next == null)) {
        print(currNode.next.element);
        currNode = currNode.next;
    }
}

// 查找给定结点
function find(item) {
    var currNode = this.head;
    while (currNode.element != item) {
        currNode = currNode.next;
    }
    return currNode;
}

// 在item后面插入新节点newElement
function insert(newElement, item) {
    var newNode = new Node(newElement);
    var current = this.find(item);
    newNode.next = current.next;
    current.next = newNode;
}

var cities = new LList();
cities.insert("Conway", "head");
cities.insert("Russellville", "Conway");
cities.insert("Carlisle", "Russellville");
cities.insert("Alma", "Carlisle");
cities.display();
console.log();
cities.remove("Carlisle");
cities.display();

4.2 双向 链表

function Node(element) {
    this.element = element;
    this.next = null;
    this.previous = null;
}

function LList() {
    this.head = new Node("head");
    this.find = find;  // 查找指定结点
    this.insert = insert;  // 在item后面插入一个结点
    this.display = display;  // 从头到尾打印链表
    this.remove = remove;  // 移除一个结点
    this.findLast = findLast;  // 找到链表中的最后一个结点
    this.dispReverse = dispReverse;  // 反转双向链表
}

// 反转双向链表
function dispReverse() {
    var currNode = this.head;
    currNode = this.findLast();
    while (!(currNode.previous == null)) {
        print(currNode.element);
        currNode = currNode.previous;
    }
}

// 找到链表中的最后一个结点
function findLast() {
    var currNode = this.head;
    while (!(currNode.next == null)) {
        currNode = currNode.next;
    }
    return currNode;
}

// 移除一个结点
function remove(item) {
    var currNode = this.find(item);
    if (!(currNode.next == null)) {
        currNode.previous.next = currNode.next;
        currNode.next.previous = currNode.previous;
        currNode.next = null;
        currNode.previous = null;
    }
}

//findPrevious 没用了，注释掉
/*function findPrevious(item) {
    var currNode = this.head;
    while (!(currNode.next == null) && (currNode.next.element != item)) {
        currNode = currNode.next;
    }
    return currNode;
}*/

// 从头到尾打印链表
function display() {
    var currNode = this.head;
    while (!(currNode.next == null)) {
        print(currNode.next.element);
        currNode = currNode.next;
    }
}

// 查找指定结点
function find(item) {
    var currNode = this.head;
    while (currNode.element != item) {
        currNode = currNode.next;
    }
    return currNode;
}

// 在item后面插入一个结点
function insert(newElement, item) {
    var newNode = new Node(newElement);
    var current = this.find(item);
    newNode.next = current.next;
    newNode.previous = current;
    current.next = newNode;
}

//
var cities = new LList();
cities.insert("Conway", "head");
cities.insert("Russellville", "Conway");
cities.insert("Carlisle", "Russellville");
cities.insert("Alma", "Carlisle");
cities.display(); //
print();
cities.remove("Carlisle");
cities.display();  //
print();
cities.dispReverse();  //

//打印结果：
Conway
Russellville
Carlisle
Alma

Conway
Russellville
Alma

Alma
Russellville
Conway