线性结构
数组
用 JavaScript 声明、创建和初始化数组很简单
let a = new Array();//创建一个数组
a=[1,2];//为数组赋值
let b = new Array(7);//创建一个指定长度的数组
let c = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday');//直接将数组元素作为参数传递给它的构造器
//实际上我们可以直接声明一个数组
let a = [];
数组的循环迭代和C/C++类似，但是JavaScript是动态数组，可以完成一些更方便的操作。
注：在 JavaScript 中，数组是一个可以修改的对象。如果添加元素，它就会动态增长。
增
在数组末尾增加元素
如果只添加一个元素，只需要在数组的最后一个位置添加元素
例如：
let number = [1,2,3];
number[number.length]=4;
numbers.length获取数组长度
push 方法，能把元素添加到数组的末尾。
numbers.push(5);
numbers.push(5,6,7);
在数组开头增加元素
在数组开头增加元素需要移动整个数组
for (let i = number.length; i >= 0; i--) {
number[i] = number[i - 1];
}
number[0] = 0;
unshift方法，可以直接把数值插入数组的开头
numbers.unshift(0);
numbers.unshift(0,-1);//先在数组头部添加0，再在新的数组头部添加-1
删
要删除数组里最靠后的元素，可以用 pop 方法。
numbers.pop()
要删除数组的第一个元素，可以用 shift 方法实现。
numbers.shift()
改
我们可以使用 splice 方法，简单地通过指定位置/索引，就可以删除相应位置上指定数量的元素。
numbers.splice(5,3)删除了从数组索引 5 开始的 3 个元素。
numbers.splice(5, 0, 2, 3, 4)
splice 方法接收的第一个参数，表示想要删除或插入的元素的索引值。第二个参数是删除元素的个数（我们的目的不是删除元素，所以传入 0）。第三个参数往后，就是要添加到数组里的值（元素 2、3、4）。
let number = [1, 2];
document.write(number);
document.write("<br>");
number.push(3,4);
number.unshift(0, -1);
document.write(number);
document.write("<br>");
number.splice(3, 3, 9, 8, 7);
document.write(number);
多维数组（矩阵）
JavaScript 只支持一维数组，并不支持矩阵。但是可以数组套数组，实现矩阵或任一多维数组。
数组方法
| 方法 | 说明 |
|---|---|
| concat | 连接 2 个或更多数组，并返回结果 |
| every | 对数组中的每个元素运行给定函数，如果该函数对每个元素都返回 true，则返回 true |
| filter | 对数组中的每个元素运行给定函数，返回该函数会返回 true 的元素组成的数组 |
| forEach | 对数组中的每个元素运行给定函数。这个方法没有返回值 |
| join | 将所有的数组元素连接成一个字符串 |
| indexOf | 返回第一个与给定参数相等的数组元素的索引，没有找到则返回-1 |
| lastIndexOf | 返回在数组中搜索到的与给定参数相等的元素的索引里最大的值 |
| map | 对数组中的每个元素运行给定函数，返回每次函数调用的结果组成的数组 |
| reverse | 颠倒数组中元素的顺序，原先第一个元素现在变成最后一个，同样原先的最后一个元素变成了现在的第一个 |
| slice | 传入索引值，将数组里对应索引范围内的元素作为新数组返回 |
| some | 对数组中的每个元素运行给定函数，如果任一元素返回 true，则返回 true |
| sort | 按照字母顺序对数组排序，支持传入指定排序方法的函数作为参数 |
| toString | 将数组作为字符串返回 |
| valueOf | 和 toString 类似，将数组作为字符串返回 |
链表
链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。
相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此实现链表时需要额外注意。在数组中，我们可以直接访问任何位置的任何元素，而要想访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。
//节点
function Node(element) {
this.element = element;
this.next = null;
}
//链表
function LList() {
this.head = new Node("head");//头结点
this.find = find;//查找
this.findPrevious = findPrevious;
this.insert = insert;//插入
this.remove = remove;//删除
this.display = display;//输出
}
//查找
function find(item) {
let currNode = this.head;
while (currNode.element != item) {
currNode = currNode.next;
}
return currNode;
}
function findPrevious(item) {
var currNode = this.head;
while (!(currNode.next == null) && (currNode.next.element != item)) {
currNode = currNode.next;
}
return currNode;
}
//增加
function insert(newElement, item) {
var newNode = new Node(newElement);
var current = this.find(item);
newNode.next = current.next;
current.next = newNode;
}
//输出
function display() {
var currNode = this.head;
while (!(currNode.next == null)) {
document.write(currNode.next.element, " ");
currNode = currNode.next;
}
document.write("<br>");
}
//删除
function remove(item) {
var prevNode = this.findPrevious(item);
if (!(prevNode.next == null)) {
prevNode.next = prevNode.next.next;
}
}
var cities = new LList();
cities.insert("Conway", "head");
cities.insert("Russellville", "Conway");
cities.insert("Carlisle", "Russellville");
cities.insert("Alma", "Carlisle");
cities.display()
cities.remove("Carlisle");
cities.display();
栈
栈是一种遵从后进先出（LIFO）原则的有序集合。新添加或待删除的元素都保存在栈的同一端，称作栈顶，另一端就叫栈底。在栈里，新元素都靠近栈顶，旧元素都接近栈底。
栈也被用在编程语言的编译器和内存中保存变量、方法调用等，也被用于浏览器历史记录（浏览器的返回按钮）。
- push(element(s))：添加一个（或几个）新元素到栈顶。
- pop()：移除栈顶的元素，同时返回被移除的元素。
- peek()：返回栈顶的元素，不对栈做任何修改（该方法不会移除栈顶的元素，仅仅返回它）。
- isEmpty()：如果栈里没有任何元素就返回 true，否则返回 false。
- clear()：移除栈里的所有元素。
- size()：返回栈里的元素个数。该方法和数组的 length 属性很类似。
function Stack() {
this.dataStore = [];//数组
this.top = 0;//栈顶
this.push = push;//增
this.pop = pop;//删
this.peek = peek;//返回栈顶元素
this.clear = clear;//清空数据元素
this.length = length;//返回栈的元素个数
}
function push(element) {
this.dataStore[this.top++] = element;
}
function pop() {
return this.dataStore[--this.top];
}
function peek() {
return this.dataStore[this.top - 1];
}
function clear() {
this.top = 0;
}
function length() {
return this.top;
}
var testStack = new Stack();//创建一个栈
testStack.push("This");
testStack.push("is");
testStack.push("a");
testStack.push("stack");
document.write("length:",testStack.length(),"<br>");
document.write(testStack.peek(),"<br>");
let popped = testStack.pop();
document.write("The popped element is:",popped,"<br>");
队列
队列是一种列表，不同的是队列只能在队尾插入元素，在队首删除元素。队列用于存储按 顺序排列的数据，先进先出，这点和栈不一样，在栈中，最后入栈的元素反而被优先处理。
队列的两种主要操作是：向队列中插入新元素和删除队列中的元素。插入操作也叫做入队，删除操作也叫做出队。入队操作在队尾插入新元素，出队操作删除队头的元素。
//队列
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 toString() {
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 testQueue = new Queue();
testQueue.enqueue("Meredith");
testQueue.enqueue("Cynthia");
testQueue.enqueue("Jennifer");
document.write(testQueue.toString(),"<br>");
testQueue.dequeue();
document.write(testQueue.toString(),"<br>");
document.write("Front of queue: ",testQueue.front(),"<br>");
document.write("Back of queue: ",testQueue.back(),"<br>");
182
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
