【数据结构】我的学习笔记
原创
前言
常言说，打蛇打七寸，学习数据结构，关键要理解数据结构特点以及每种结构的增、删、查方法
一、队列
1.普通队列
特点
先进先出
方法
方法 | 描述 |
|---|---|
push | 队列末尾追加元素 |
shift | 删除队列最后一个元素 |
实现
// 普通队列
class Queue {
constructor(){
this.list = [];
}
push(element){
this.list.push(element);
}
shift(){
return this.list.shift();
}
front(){
return this.list[0];
}
back(){
return this.list[this.list.length-1];
}
display(){
return this.list.toString();
}
isEmpty(){
return this.list.length == 0
}
}对于前端，队列可以说是最简单的数据结构了，因为JavaScript的数组Array是天生支持队列，因为数组自带push、shift、pop、unshift方法
2.优先队列
特点
优先级一样时先进先出，否则优先级最高的先出
方法
方法 | 描述 |
|---|---|
push | 队列末尾追加元素 |
pop | 删除队列级最高的一个元素，否则删除首位 |
实现
// 优先队列
class PriQueue {
constructor(element, priority){
this.element = element;
this.priority = priority; // 记录优先级
}
push(element){
this.list.push(element);
}
shift(){
let priority = this.list[0].priority;
let index = 0;
for (let i = 0; i < this.list.length; i++) {
if ( this.list[i].priority > priority ) {
priority = this.list[i].priority;
index = i;
}
}
return this.list.splice(index, index+1)
}
isEmpty(){
return this.list.length == 0
}
}二、栈
特点
先进后出或者后进先出
方法
方法 | 描述 |
|---|---|
push | 栈末尾追加元素 |
pop | 弹出栈末尾的一个元素 |
实现
class Stack {
constructor(){
this.list = [];
this.depth = 0; // 记录深度
}
push(element){
this.list[this.depth] = element;
this.depth += 1;
}
pop(){
this.depth -= 1;
return this.list[this.depth];
}
peek(){
return this.list[this.depth-1]
}
length(){
return this.depth;
}
clear(){
this.list = [];
}
}三、链表
链式存储的非连续数据结构
1.单向链表
特点
每个元素只能和上一个元素或下一个元素连接
方法
方法 | 描述 |
|---|---|
find | 查找某一个元素 |
findPro | 查找前一个元素 |
insert | 在某个元素后面插入新元素 |
remove | 删除某个元素 |
实现
// 单向链表
class Node {
constructor(element){
this.element = element
this.next = null
}
}
class List {
constructor(){
this.head = new Node("head");
}
find(element){
let currNode = this.head;
while(currNode.element != element){
currNode = currNode.next;
}
return currNode;
}
findPro(element){
let proNode = this.head;
while(proNode.next.element != element){
proNode = proNode.next;
}
console.log(proNode);
return proNode;
}
insert(newElement, element){
let newNode = new Node(newElement);
this.find(element).next = newNode;
console.log(newNode)
}
remove(element){
this.findPro(element).next = this.find(element).next;
}
display(){
let currNode = this.head;
while(!(currNode.next == null)){
console.log(currNode.next.element)
currNode = currNode.next;
}
return
}
}
let list = new List();
list.insert("body","head");
list.insert("foot","body");
list.display();
// list.find("gg");
list.remove("body");
list.display();2.双向链表
特点
每个元素不仅和上一个元素而且和下一个元素连接
方法
方法 | 描述 |
|---|---|
find | 查找某一个元素 |
findLast | 查找最后一个元素 |
insert | 在某个元素后面插入新元素 |
remove | 删除某个元素 |
dispReverse | 翻转链表 |
实现
// 双向链表
class TwoNode {
constructor(element){
this.element = element;
this.next = null;
this.pro = null;
}
}
class TwoList {
constructor(){
this.head = new TwoNode("head");
}
find(element){
let currNode = this.head;
while(currNode.element != element){
if (currNode.next == null) {
}
currNode = currNode.next;
}
return currNode;
}
findLast(){
let currNode = this.head;
while(currNode.next != null){
currNode = currNode.next;
}
return currNode;
}
insert(newElement, element){
let newNode = new TwoNode(newElement);
let currNode = this.find(element)
newNode.next = currNode.next;
newNode.pro = currNode;
currNode.next = newNode;
}
remove(element){
let currNode = this.find(element);
if (!(currNode.next == null)) {
currNode.pro.next = currNode.next;
currNode.next.pro = currNode.pro;
currNode.pro = null;
currNode.next = null;
}
}
display(){
let currNode = this.head;
while(!(currNode.next == null)){
console.log(currNode.next.element)
currNode = currNode.next;
}
return
}
dispReverse(element){
let currNode = this.findLast();
while(!(currNode.element == "head")){
console.log(currNode.element);
currNode = currNode.pro;
}
return
}
}
let list = new TwoList();
list.insert("c","head");
list.insert("b","c");
list.insert("f","b");
list.display();
list.remove("b");
list.display();
list.findLast();
list.dispReverse();3.循环链表
特点
每个元素不仅和上一个元素而且和下一个元素连接，并且首尾相连
方法
方法 | 描述 |
|---|---|
find | 查找某一个元素 |
findLast | 查找最后一个元素 |
insert | 在某个元素后面插入新元素 |
remove | 删除某个元素 |
实现
// 循环链表
class LoopNode {
constructor(element){
this.element = element;
}
}
class LoopList {
constructor(){
this.head = new LoopNode("head");
this.head.next = this.head;
}
find(element){
let currNode = this.head;
while(currNode.element != element){
currNode = currNode.next;
}
return currNode;
}
findPro(element){
let proNode = this.head;
while(proNode.next.element != element){
proNode = proNode.next;
}
console.log(proNode);
return proNode;
}
insert(newElement, element){
let newNode = new Node(newElement);
this.find(element).next = newNode;
console.log(newNode)
}
remove(element){
this.findPro(element).next = this.find(element).next;
}
display(){
let currNode = this.head;
while(!(currNode.next == null) && !(currNode.next.element == "head")){
console.log(currNode.next.element);
currNode = currNode.next;
}
return
}
}原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
评论
登录后参与评论
推荐阅读
目录
腾讯云开发者
