JS数据结构与算法

最新推荐文章于 2022-07-11 19:04:09 发布
最新推荐文章于 2022-07-11 19:04:09 发布
阅读量201 收藏 3
点赞数
分类专栏： js
原文链接：https://www.jianshu.com/p/38853c044156
版权

笔记链接

数组结构

在这里插入图片描述

栈结构

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

栈的封装

在这里插入图片描述

栈常见操作

push(element): 添加一个新元素到栈顶位置.
pop()：移除栈顶的元素，同时返回被移除的元素。
peek()：返回栈顶的元素，不对栈做任何修改（这个方法不会移除栈顶的元素，仅仅返回它）。
isEmpty()：如果栈里没有任何元素就返回true，否则返回false。
clear()：移除栈里的所有元素。
size()：返回栈里的元素个数。这个方法和数组的length属性很类似。

注意: 这里我们为了将属性方法放在一起, 没有使用原型来封装方法.

// 栈类
function Stack() {
    // 栈中的属性
    var items = []

    // 栈相关的方法
    // 压栈操作
    this.push = function (element) {
        items.push(element)
    }

    // 出栈操作
    this.pop = function () {
        return items.pop()
    }

    // peek操作
    this.peek = function () {
        return items[items.length - 1]
    }

    // 判断栈中的元素是否为空
    this.isEmpty = function () {
        return items.length == 0
    }

    // 获取栈中元素的个数
    this.size = function () {
        return items.length
    }
}

var stack = new Stack()

// 情况下代码模拟
stack.push(6)
stack.push(5)
stack.pop()     // 5

队列

在这里插入图片描述

队列常见的操作

在这里插入图片描述

优先级队列

在这里插入图片描述
代码实现：

// 封装优先级队列
function PriorityQueue() {
    var items = []

    // 封装一个新的构造函数, 用于保存元素和元素的优先级
    function QueueElement(element, priority) {
        this.element = element
        this.priority = priority
    }

    // 添加元素的方法
    this.enqueue = function (element, priority) {
        // 1.根据传入的元素, 创建新的QueueElement
        var queueElement = new QueueElement(element, priority)

        // 2.获取传入元素应该在正确的位置
        if (this.isEmpty()) {
            items.push(queueElement)
        } else {
            var added = false
            for (var i = 0; i < items.length; i++) {
                // 注意: 我们这里是数字越小, 优先级越高
                if (queueElement.priority < items[i].priority) {
                    items.splice(i, 0, queueElement)
                    added = true
                    break
                }
            }

            // 遍历完所有的元素, 优先级都大于新插入的元素时, 就插入到最后
            if (!added) {
                items.push(queueElement)
            }
        }
    }

    // 删除元素的方法
    this.dequeue = function () {
        return items.shift()
    }

    // 获取前端的元素
    this.front = function () {
        return items[0]
    }

    // 查看元素是否为空
    this.isEmpty = function () {
        return items.length == 0
    }

    // 获取元素的个数
    this.size = function () {
        return items.length
    }
}

// 创建优先级队列对象
var pQueue = new PriorityQueue()

// 添加元素
pQueue.enqueue("abc", 10)
pQueue.enqueue("cba", 5)
pQueue.enqueue("nba", 12)
pQueue.enqueue("mba", 3)

// 遍历所有的元素
var size = pQueue.size()
for (var i = 0; i < size; i++) {
    var item = pQueue.dequeue()
    alert(item.element + "-" + item.priority)
}

链表

链表常见操作

append(element)：向列表尾部添加一个新的项

insert(position, element)：向列表的特定位置插入一个新的项。

remove(element)：从列表中移除一项。

indexOf(element)：返回元素在列表中的索引。如果列表中没有该元素则返回-1。

removeAt(position)：从列表的特定位置移除一项。

isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false。

size()：返回链表包含的元素个数。与数组的length属性类似。

toString()：由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值。

代码

// 封装链表的构造函数
function LinkedList() {
    // 封装一个Node类, 用于保存每个节点信息
    function Node(element) {
        this.element = element
        this.next = null
    }

    // 链表中的属性
    this.length = 0
    this.head = null

    // 链表尾部追加元素方法
    LinkedList.prototype.append = function (element) {
        // 1.根据新元素创建节点
        var newNode = new Node(element)

        // 2.判断原来链表是否为空
        if (this.head === null) { // 链表尾空
            this.head = newNode
        } else { // 链表不为空
            // 2.1.定义变量, 保存当前找到的节点
            var current = this.head
            while (current.next) {
                current = current.next
            }

            // 2.2.找到最后一项, 将其next赋值为node
            current.next = newNode
        }

        // 3.链表长度增加1
        this.length++
    }

    // 链表的toString方法
    LinkedList.prototype.toString = function () {
        // 1.定义两个变量
        var current = this.head
        var listString = ""

        // 2.循环获取链表中所有的元素
        while (current) {
            listString += "," + current.element
            current = current.next
        }

        // 3.返回最终结果
        return listString.slice(1)
    }

    // 根据下标删除元素
    LinkedList.prototype.insert = function (position, element) {
        // 1.检测越界问题: 越界插入失败
        if (position < 0 || position > this.length) return false

        // 2.定义变量, 保存信息
        var newNode = new Node(element)
        var current = this.head
        var previous = null
        index = 0

        // 3.判断是否列表是否在第一个位置插入
        if (position == 0) {
            newNode.next = current
            this.head = newNode
        } else {
            while (index++ < position) {
                previous = current
                current = current.next
            }

            newNode.next = current
            previous.next = newNode
        }

        // 4.length+1
        this.length++

        return true
    }

    // 根据位置移除节点
    LinkedList.prototype.removeAt = function (position) {
        // 1.检测越界问题: 越界移除失败, 返回null
        if (position < 0 || position >= this.length) return null

        // 2.定义变量, 保存信息
        var current = this.head
        var previous = null
        var index = 0

        // 3.判断是否是移除第一项
        if (position === 0) {
            this.head = current.next
        } else {
            while (index++ < position) {
                previous = current
                current = current.next
            }

            previous.next = current.next
        }

        // 4.length-1
        this.length--

        // 5.返回移除的数据
        return current.element
    }

    // 根据元素获取链表中的位置
    LinkedList.prototype.indexOf = function (element) {
        // 1.定义变量, 保存信息
        var current = this.head
        index = 0

        // 2.找到元素所在的位置
        while (current) {
            if (current.element === element) {
                return index
            }
            index++
            current = current.next
        }

        // 3.来到这个位置, 说明没有找到, 则返回-1
        return -1
    }

    // 根据元素删除信息
    LinkedList.prototype.remove = function (element) {
        var index = this.indexOf(element)
        return this.removeAt(index)
    }

    // 判断链表是否为空
    LinkedList.prototype.isEmpty = function () {
        return this.length == 0
    }

    // 获取链表的长度
    LinkedList.prototype.size = function () {
        return this.length
    }

    // 获取第一个节点
    LinkedList.prototype.getFirst = function () {
        return this.head.element
    }
}

双向链表

// 创建双向链表的构造函数
function DoublyLinkedList() {
    // 创建节点构造函数
    function Node(element) {
        this.element = element
        this.next = null
        this.prev = null // 新添加的
    }

    // 定义属性
    this.length = 0
    this.head = null
    this.tail = null // 新添加的

    // 定义相关操作方法
    // 在尾部追加数据
    DoublyLinkedList.prototype.append = function (element) {
        // 1.根据元素创建节点
        var newNode = new Node(element)

        // 2.判断列表是否为空列表
        if (this.head == null) {
            this.head = newNode
            this.tail = newNode
        } else {
            this.tail.next = newNode
            newNode.prev = this.tail
            this.tail = newNode
        }

        // 3.length+1
        this.length++
    }

    // 在任意位置插入数据
    DoublyLinkedList.prototype.insert = function (position, element) {
        // 1.判断越界的问题
        if (position < 0 || position > this.length) return false

        // 2.创建新的节点
        var newNode = new Node(element)

        // 3.判断插入的位置
        if (position === 0) { // 在第一个位置插入数据
            // 判断链表是否为空
            if (this.head == null) {
                this.head = newNode
                this.tail = newNode
            } else {
                this.head.prev = newNode
                newNode.next = this.head
                this.head = newNode
            }
        } else if (position === this.length) { // 插入到最后的情况
            // 思考: 这种情况是否需要判断链表为空的情况呢? 答案是不需要, 为什么?
            this.tail.next = newNode
            newNode.prev = this.tail
            this.tail = newNode
        } else { // 在中间位置插入数据
            // 定义属性
            var index = 0
            var current = this.head
            var previous = null

            // 查找正确的位置
            while (index++ < position) {
                previous = current
                current = current.next
            }

            // 交换节点的指向顺序
            newNode.next = current
            newNode.prev = previous
            current.prev = newNode
            previous.next = newNode
        }

        // 4.length+1
        this.length++

        return true
    }

    // 根据位置删除对应的元素
    DoublyLinkedList.prototype.removeAt = function (position) {
        // 1.判断越界的问题
        if (position < 0 || position >= this.length) return null

        // 2.判断移除的位置
        var current = this.head
        if (position === 0) {
            if (this.length == 1) {
                this.head = null
                this.tail = null
            } else {
                this.head = this.head.next
                this.head.prev = null
            }
        } else if (position === this.length -1) {
            current = this.tail
            this.tail = this.tail.prev
            this.tail.next = null
        } else {
            var index = 0
            var previous = null

            while (index++ < position) {
                previous = current
                current = current.next
            }

            previous.next = current.next
            current.next.prev = previous
        }

        // 3.length-1
        this.length--

        return current.element
    }

    // 根据元素获取在链表中的位置
    DoublyLinkedList.prototype.indexOf = function (element) {
        // 1.定义变量保存信息
        var current = this.head
        var index = 0

        // 2.查找正确的信息
        while (current) {
            if (current.element === element) {
                return index
            }
            index++
            current = current.next
        }

        // 3.来到这个位置, 说明没有找到, 则返回-1
        return -1
    }

    // 根据元素删除
    DoublyLinkedList.prototype.remove = function (element) {
        var index = this.indexOf(element)
        return this.removeAt(index)
    }

    // 判断是否为空
    DoublyLinkedList.prototype.isEmpty = function () {
        return this.length === 0
    }

    // 获取链表长度
    DoublyLinkedList.prototype.size = function () {
        return this.length
    }

    // 获取第一个元素
    DoublyLinkedList.prototype.getHead = function () {
        return this.head.element
    }

    // 获取最后一个元素
    DoublyLinkedList.prototype.getTail = function () {
        return this.tail.element
    }

    // 遍历方法的实现
    // 正向遍历的方法
    DoublyLinkedList.prototype.forwardString = function () {
        var current = this.head
        var forwardStr = ""

        while (current) {
            forwardStr += "," + current.element
            current = current.next
        }

        return forwardStr.slice(1)
    }

    // 反向遍历的方法
    DoublyLinkedList.prototype.reverseString = function () {
        var current = this.tail
        var reverseStr = ""

        while (current) {
            reverseStr += "," + current.element
            current = current.prev
        }

        return reverseStr.slice(1)
    }

    // 实现toString方法
    DoublyLinkedList.prototype.toString = function () {
        return this.forwardString()
    }
}

集合结构

集合的特点

  • 集合通常是由一组无序的, 不能重复的元素构成.
    • 和数学中的集合名词比较相似, 但是数学中的集合范围更大一些, 也允许集合中的元素重复.
    • 在计算机中, 集合通常表示的结构中元素是不允许重复的.
  • 其实集合你可以将它看成一种特殊的数组.
    • 特殊之处在于里面的元素没有顺序, 也不能重复.
    • 没有顺序意味着不能通过下标值进行访问,
    • 不能重复意味着相同的对象在集合中只会存在一份.

操作的方法

add(value)：向集合添加一个新的项。

remove(value)：从集合移除一个值。

has(value)：如果值在集合中，返回true，否则返回false。

clear()：移除集合中的所有项。

size()：返回集合所包含元素的数量。与数组的length属性类似。

values()：返回一个包含集合中所有值的数组。

还有一些集合其他相关的操作, 暂时用不太多, 这里暂不封装.

字典

常见的操作

set(key,value)：向字典中添加新元素。

remove(key)：通过使用键值来从字典中移除键值对应的数据值。
has(key)：如果某个键值存在于这个字典中，则返回true，反之则返回false。

get(key)：通过键值查找特定的数值并返回。

clear()：将这个字典中的所有元素全部删除。

size()：返回字典所包含元素的数量。与数组的length属性类似。

keys()：将字典所包含的所有键名以数组形式返回。

values()：将字典所包含的所有数值以数组形式返回。

操作实现

// 创建字典的构造函数
function Dictionay() {
    // 字典属性
    this.items = {}

    // 字典操作方法
    // 在字典中添加键值对
    Dictionay.prototype.set = function (key, value) {
        this.items[key] = value
    }

    // 判断字典中是否有某个key
    Dictionay.prototype.has = function (key) {
        return this.items.hasOwnProperty(key)
    }

    // 从字典中移除元素
    Dictionay.prototype.remove = function (key) {
        // 1.判断字典中是否有这个key
        if (!this.has(key)) return false

        // 2.从字典中删除key
        delete this.items[key]
        return true
    }

    // 根据key去获取value
    Dictionay.prototype.get = function (key) {
        return this.has(key) ? this.items[key] : undefined
    }

    // 获取所有的keys
    Dictionay.prototype.keys = function () {
        return Object.keys(this.items)
    }

    // 获取所有的value
    Dictionay.prototype.values = function () {
        return Object.values(this.items)
    }

    // size方法
    Dictionay.prototype.size = function () {
        return this.keys().length
    }

    // clear方法
    Dictionay.prototype.clear = function () {
        this.items = {}
    }
}

哈希表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

插入&修改操作

在这里插入图片描述

哈希表扩容

在这里插入图片描述

容量质数

在这里插入图片描述

function isPrime(num) {
    for (var i = 2; i < num; i++) {
        if (num % i == 0) {
            return false
        }
    }
    return true
}

// 测试
alert(isPrime(3)) // true
alert(isPrime(32)) // false
alert(isPrime(37)) // true

但是, 这种做法的效率并不高. 为什么呢?

对于每个数n，其实并不需要从2判断到n-1
一个数若可以进行因数分解，那么分解时得到的两个数一定是一个小于等于sqrt(n)，一个大于等于sqrt(n).
比如16可以被分别. 那么是28, 2小于sqrt(16), 也就是4, 8大于4. 而44都是等于sqrt(n)
所以其实我们遍历到等于sqrt(n)即可

function isPrime(num) {
    // 1.获取平方根
    var temp = parseInt(Math.sqrt(num))

    // 2.循环判断
    for (var i = 2; i <= temp; i++) {
        if (num % i == 0) {
            return false
        }
    }
    return true
}

树结构

树的相关术语

（度、节点、层次、路径、深度…）

二叉树

（特性、满二叉树、完全二叉树、搜索二叉树（添加、查找（前中后序遍历）、删除（三种情况）））

AVL树

红黑树

在这里插入图片描述
在这里插入图片描述

变色

在这里插入图片描述

旋转

在这里插入图片描述

插入

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

删除

在这里插入图片描述

图结构

图的术语

图的表示

邻接矩阵、邻接表

图的遍历

广度优先搜索（BFS）、深度优先搜寻(DFS)

排序算法

冒泡排序

选择排序

插入排序

希尔排序

快速排序

kookoo_babe
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS数据结构与算法.pdf
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
js数据结构与算法.zip
06-16
本资源包“js数据结构与算法.zip”显然是针对想要深入学习JavaScript中的数据结构与算法的学生或开发者设计的。 首先，让我们来讨论数据结构。数据结构是指组织、存储和管理数据的方式。在JavaScript中，常见的数据...
学习JavaScript 数据结构与算法
我是一只蘑菇17的博客
11-10 2378
学习链接：https://github.com/XPoet/js-data-structures-and-algorithms JavaScript 数据结构与算法 1.数据结构(data structure) 数据结构是数据对象，以及存在于该对象的实例和组成实例的数据元素之间的各种联系 ​ 是计算机中存储、组织数据的方式。通常情况下，精心选择的数据结构可以带来最优效率的算法 2.解决问题方法的效率，根据数据的组织方式有关 3.常见的数据结构：数组，栈，链表，图，散列表，队
JavaScript数据结构与算法
LL_bianma的博客
07-11 192
2022.7.11读书心得
js数据结构与算法
runner_123的博客
04-13 2341
一、javascript基础 1.javascript的数据类型有：数字、字符串、函数、对象、undefined、null和数组、日期、正则表达式。 2.变量作用域：本地变量和全局变量。在一个函数里，变量没有使用var 关键字，则是申明或者引用了全局变量。 3.转换为布尔值为假值的有 |undefined| |-null-| | +0，-0，NaN | "" 空字符串 4.创建对象两种方式：构造函...
数据结构与算法（js）
小白目的博客
01-09 1233
数据结构概述：在计算机中存储和组织数据的方式。 算法概述：解决方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。 常用的数据结构： 线性结构（数组、链表、栈、队列和哈希表），非线性结构（树、图），抽象数据结构（集合、字典可看这一篇文章https://blog.csdn.net/qq_37974755/article/details/122115209?spm=1001.2014.3001.5501）。 这些数据结构均有许多变种，本文主要介绍基础..
JavaScript数据结构与算法总结
weixin_44037272的博客
05-20 312
文章目录前言线性结构数组增删改多维数组（矩阵）链表栈队列非线性结构集合字典和散列表字典散列表树二叉树平衡树图排序查找分治算法回溯算法贪心算法其它 JavaScript基础知识 JavaScript数据结构与算法总结一——线性结构（数组、链表、栈、队列） JavaScript数据结构与算法总结 JavaScript可以直接写入 HTML 输出流，也可以直接使用node.js。 <!DOCTYPE html> <html lang="en"> <head> <m
javaScript版数据结构与算法（上）
cloudyless的博客
05-15 983
1.数据结构与算法的关系？ 数据结构：计算机存储，组织数据的方式。就像锅碗瓢盆，不同的食物用不同的容器去剩。 算法：一系列解决问题的清晰指令。就像食谱一样。 程序=数据结构+算法，数据结构为算法提供服务，算法围绕数据结构操 总结：算法指令里面难免有各种数据，所以没有数据结构我们如何存储这些数据呢，所以才有了上面的这句话。锅碗瓢盆用来存放各种食物，然后食谱拿着锅碗瓢盆去做出美味佳肴。 1.1.时间复杂度 一个特殊的函数，以O来表示，如O（1），O（n），O（log n）O（n2） 算法的时间复杂
JavaScript数据结构与算法启蒙
随便写写
05-18 489
JavaScript数据结构与算法启蒙
JavaScript 版数据结构与算法
weixin_49809163的博客
07-07 818
数据结构与算法
javascript数据结构与算法
qiao_qiao_happy的博客
02-01 177
javascript数据结构和算法目录 常见的数据结构: 数据结构(一)之邂逅数据结构&算法 数据结构(二)之数组结构 数据结构(三)之栈结构 数据结构(四)之队列结构 数据结构(五)之链表结构 数据结构(六)之双向链表 数据结构(七)之集合结构 数据结构(八)之字典结构 数据结构(九)之哈希表理论 数据结构(十)之哈希表实现 数据结构(十一)之树结构 数据结构(十二)之二叉搜索树 数据结构(十三)之红黑树 数据结构(十四)之图结构 数据结构(十五)之图算法 数据结构(十六)之简单排序 数据结构
JS数据结构与算法-栈
qq_31207499的博客
04-16 185
JS数据结构与算法-栈
JS数据结构与算法1
08-03
JavaScript 数据结构与算法是编程领域中的基础，它们是构建高效程序和解决复杂问题的关键工具。在JavaScript中，我们经常使用的数据结构包括数组、栈、队列、链表等。 1. **数组**：数组是最基本的数据结构，它可以...
javascript数据结构与算法实现合集.zip
01-04
JavaScript数据结构与算法实现合集是一系列用于深入理解编程基础的资源集合，主要关注于如何在JavaScript中构建和操作各种数据结构以及应用不同算法。这个压缩包中的"DataStructuresAndAlgorithms-main"目录可能包含...
chromedriver-mac-arm64_126.0.6465.0.zip
07-31
chromedriver-mac-arm64_126.0.6465.0.zip
chromedriver-mac-x64_122.0.6235.0.zip
最新发布
07-31
chromedriver-mac-x64_122.0.6235.0.zip
chromedriver-mac-x64_122.0.6188.0.zip
07-31
chromedriver-mac-x64_122.0.6188.0.zip
【JCR2区】基于matlab阿基米德算法优化最小二乘法AOA-LSSVM数据分类【含Matlab源码 6004期】.zip
07-31
CSDN海神之光上传的代码均可运行，亲测可用，换数据就行，适合小白； 1、代码压缩包内容 主函数：main.m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化最小二乘法支持向量机LSSVM分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化LSSVM 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化LSSVM 4.4.3 灰狼算法GWO/狼群算法WPA优化LSSVM 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化LSSVM 4.4.5 萤火虫算法FA/差分算法DE优化LSSVM 4.4.6 其他优化算法优化LSSVM
JavaScript数据结构与算法实践
"JavaScript数据结构与算法相关的电子书资源" 这篇描述和标题提到的"js数据结构与算法"是关于使用JavaScript实现数据结构和算法的专题。JavaScript，通常用于前端开发，近年来由于Node.js和SpiderMonkey等平台的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值