五. 链表
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
链表的特点
1.插入、删除数据效率高O(1)级别（只需更改指针指向即可），随机访问效率低O(n)级别（需要从链头至链尾进行遍历）。 2.和数组相比，内存空间消耗更大，因为每个存储数据的节点都需要额外的空间存储后继指针。
1. 单链表
每个节点只包含一个指针，即后继指针。
class Node {
constructor(element){
this.element = element // 链表节点中存放的内容
this.next = null // 用于指向下一个节点的指针
}
}
class LinkedList {
constructor(){
this.head = null // 链表的表头
this.count = 0 // 链表的节点数量
}
push(element){ // 用于向链表(末尾)添加元素
const node = new Node(element) // 创建一个新的节点
let current ;
if(this.head===null){
this.head = node
}else{
current = this.head
while(current.next!==null){ //通过循环遍历，找到最后链表的最后一个节点
current = current.next
}
current.next = node // 在链表的最后一个节点出添加新的节点
}
this.count++ // 完成添加操作后，令count++
}
removeAt(index){ // 用于删除第index个元素
if(index>=0&&index<this.count){
let current = this.head
if(index===0){
this.head = current.next // 如果只有一个元素，则直接将表头指向下一个(空)节点
}else{
let previous
for(let i =0;i<index;i++){ // 找出要删除的节点current 和 该节点的上一个节点previous
previous = current
current = current.next
}
previous.next = current.next // 令上一个节点的指针指向该节点的下一个节点
}
this.count-- // 完成删除操作后，令count--
return current.element // 返回被删除节点的内容
}
return // 如果index越界，则直接返回
}
getNodeAt(index){ // 获得第index个节点
if(index>=0&&index<this.count){
let node = this.head
for(let i=0;i<index;i++){
node= node.next
}
return node
}
return // 如果index越界，则直接返回
}
removeAt2(index){ // 利用getNodeAt()优化后的删除节点方法
if(index>=0&&index<this.count){
let current = this.head
if(index===0){
this.head = current.next
}else{
const previous = this.getNodeAt(index-1)
current = previous.next
previous.next = current.next
}
this.count--
return current.element
}
return
}
equalFn(a,b){ // 比较两个数据是否相同
return JSON.stringify(a)===JSON.stringify(b) // 仍然存在隐患，无法解决复杂数据类型，对于对象类型而言，如果对象初始化时赋值的顺序不同（例如{a:1,b:2} 和 {b:2,a:1} 这两个对象，本质上他们相同，可是根据JSON的处理生成的字符串不同），结果依然是false
}
indexOf(element){ // 根据值(内容)来获取索引(index表示第几个)
let current = this.head
for(let i=0;i<this.count;i++){
if(this.equalFn(element,current.element)){
return i
}
current = current.next
}
return -1
}
remove(element){ // 根据值删除节点
const index = this.indexOf(element) // 根据值来获取'索引'
return this.removeAt(index) // 调用根据'索引'删除节点的方法
}
insert(element,index){ // 在指定位置处插入节点的方法
if(index>=0&& index<=this.count){
const node = new Node(element) // 创建将要插入的节点
if(index===0){ //在首位插入节点
const current = this.head
node.next = current // 让该节点指向head节点
this.head = node // 改变head指向(指向第一个节点也就是该节点)
}else{ // 不在首位插入节点
const previous = this.getNodeAt(index-1)
const current = previous.next
node.next = current
previous.next = node
}
this.count++ // 完成添加操作后令count++
return true
}
return false
}
isEmpty(){
return this.size()===0
}
size(){
return this.count
}
getHead(){
return this.head
}
}
2.利用链表解决十进制转二进制 击鼓传花 回文判断
<1>十进制转二进制：
function docToBinl(num) {
let transList = new linkedList()
while (num > 0) {
let remainder = num % 2
num = Math.floor(num / 2)
transList.push(remainder)
}
return transList.toString().split('').reverse().join('')
}
<2> 击鼓传花
function gamel(list, num) {
let q = new linkedList()
for (let i = 0; i < list.length;i++) {
q.push(list[i])
}
console.log(list);
while (q.size() > 1) {
for (let k = 1; k <= num; k++){
q.push(q.removeAt(0))
}
console.log(`${q.getHead().element}出局`)
q.removeAt(0)
}
console.log(`winner: ${q.getHead().element}！！！`);
}
// gamel(['apple','rice','green','pencil','dollar','mirror'],5)
<3>判断回文:
function isPalindromel(str) {
// 处理字符串
let list = str.split(' ').join('').toLowerCase()
// console.log(list);
let deq1 = new linkedList()
// 初始化队列
for (let i = 0; i < list.length; i++) {
// console.log(`list[i]:${list[i]}`)
deq1.push(list[i])
}
let deq2 = new linkedList()
// 初始化队列
for (let i = 0; i < list.length; i++) {
// console.log(`list[${i}]:${list[i]}`);
deq2.insert(list[i],0)
}
// console.log(deq1.toString());
// console.log(deq2.toString());
return deq1.toString() === deq2.toString()
}
// let strl = '我D bab d 我 '
// console.log(isPalindromel(strl));
3. 双向链表
节点除了存储数据外，还有两个指针分别指向前一个节点地址（前驱指针prev）和下一个节点地址（后继指针next）。
class DoublyNode extends Node {
constructor(element) {
super(element);
this.prev = null; // 新增前驱指针
}
}
class DoublyLinkedList extends LinkedList {
constructor() {
super();
this.tail = null; // 新增后继指针
}
push(element) {
const node = new DoublyNode(element);
if (this.head == null) { // 若链表为空，则让链表的头和尾都指向新增节点
this.head = node;
this.tail = node;
} else {
this.tail.next = node;
node.prev = this.tail;
this.tail = node;
}
this.count++;
}
insert(element, index) {
if (index >= 0 && index <= this.count) {
const node = new DoublyNode(element);
let current = this.head;
if (index === 0) {
if (this.head == null) {
this.head = node;
this.tail = node;
} else {
node.next = this.head;
this.head.prev = node;
this.head = node;
}
} else if (index === this.count) {
current = this.tail;
current.next = node;
node.prev = current;
this.tail = node;
} else {
const previous = this.getNodeAt(index - 1);
current = previous.next;
node.next = current;
previous.next = node;
current.prev = node;
node.prev = previous;
}
this.count++;
return true;
}
return false;
}
removeAt(index) {
if (index >= 0 && index < this.count) {
let current = this.head;
if (index === 0) {
this.head = this.head.next;
if (this.count === 1) {
// {2}
this.tail = undefined;
} else {
this.head.prev = undefined;
}
} else if (index === this.count - 1) {
current = this.tail;
this.tail = current.prev;
this.tail.next = undefined;
} else {
current = this.getNodeAt(index);
const previous = current.prev;
previous.next = current.next;
current.next.prev = previous; // NEW
}
this.count--;
return current.element;
}
return undefined;
}
getHead() {
return this.head;
}
getTail() {
return this.tail;
}
}
4. 循环链表
循环链表和链表之间唯一的区别在于，最后一个元素指向下一个元素的指针（tail.next）不是引用 undefined，而是指向第一个元素（head）
class CircularLinkedList extends LinkedList {
constructor() {
super();
}
push(element) {
const node = new Node(element);
let current;
if (this.head == null) {
this.head = node;
} else {
current = this.getNodeAt(this.size() - 1);
current.next = node;
}
node.next = this.head;
this.count++;
}
insert(element, index) {
if (index >= 0 && index <= this.count) {
const node = new Node(element);
let current = this.head;
if (index === 0) {
if (this.head == null) {
// if no node in list
this.head = node;
node.next = this.head;
} else {
node.next = current;
current = this.getNodeAt(this.size() - 1);
// update last element
this.head = node;
current.next = this.head;
}
} else {
const previous = this.getNodeAt(index - 1);
node.next = previous.next;
previous.next = node;
}
this.count++;
return true;
}
return false;
}
removeAt(index) {
if (index >= 0 && index < this.count) {
let current = this.head;
if (index === 0) {
if (this.size() === 1) {
this.head = undefined;
} else {
let last = this.getNodeAt(this.size() - 1);
this.head = this.head.next;
last.next = this.head;
}
} else {
const previous = this.getNodeAt(index - 1);
current = previous.next;
previous.next = current.next;// 如果删的是最后一个也不怕，current.next 是head
}
this.count--;
return current.element;
}
return undefined;
}
}
