前端算法笔记

已于 2022-12-25 19:46:52 修改
阅读量159 收藏
点赞数 1
分类专栏： 哔哩哔哩视频的笔记前端 文章标签： javascript 前端
于 2022-12-11 18:54:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59820248/article/details/128230884
版权
这篇博客详细介绍了前端开发中常见的数据结构，如数组、链表、栈、队列、双向链表和二维数据结构（树形结构）。博主探讨了各种数据结构的特点、优缺点，以及在JavaScript中的实现。此外，还深入讲解了二叉树的遍历方法和图的两种算法——普利姆算法和克鲁斯卡尔算法，强调了它们在实际问题中的应用。
摘要由CSDN通过智能技术生成

数据结构

1.数组

1.线性数据结构强调存储与顺序
2.有东西先把东西存起来

数组特点

数组定长

数组是定长的，我们以为的其实是js引擎帮我们扩容，内存是操作系统来分配的
尽量给自己的东西设置好数组长度

特性

1.存储在物理空间上（在磁盘上）是连续的。如果存储的到头了，就再去磁盘里找，有没有一个空间能存放的下它。
在这里插入图片描述
2.底层数组的长度不变。（就是你一开始设置了是多长，就是多长）
3.数组变量指向第一个元素的位置（数组下标）

数组优点

1.查询性能好（通过偏移查询）

数组缺点

1.空间必须是连续的，数组比较大，当系统的 空间碎片较多的时候，容易存不下。
2.因为数组的长度是固定的，所以数组的内容难以被添加和删除，添加和删除是很消耗性能的。

在js中创建一个数组

let a = [1,2,3]
let arr = new Array(10) //确定数组长度

2.链表

在这里插入图片描述
数组的存放是连续的，链表的存放是可以碎片的，用引用来把他们连起来。

链表特点

1.空间上不连续
2.每存放一个值都会有一个引用空间

优点

1.只要内存足够大，就能存的下，不用担心空间碎片的问题
2.链表的添加和删除非常容易

缺点

1.链表的查询速度慢
2.链表的每一个查询都需要创建一个next值（就是引用值），直接double了空间。但是可以通过增加数据量的存储来降低引用值大小（引用值大小没变，只是相对于数据量变小了）

延伸（重要）：

1.想传递一个链表，必须传递链表的根节点
2.每一个链表的节点都可以认为自己是根节点

数组和链表

循环遍历方法

数组

// 遍历数组  经典for循环
let a = [1, 2, 3, 4, 5]

function travel(array) {
    if (array == null) return; // 一定要做这个检验
    for (let index = 0; index < array.length; index++) {
        console.log(array[index]);
    }
}
travel(a)

链表

function ode(value) {
    this.value = value;
    this.next = null;
}

let a = new ode(1);
let b = new ode(2);
let c = new ode(3);
let d = new ode(4);

a.next = b;
b.next = c;
c.next = d;

// 循环遍历  传递一个链表 传的是根节点
function travel(root) {
    let temp = root;
    while (true) {
        if (temp == null) {
            break;
        } else {
            console.log(temp.value);
        }
        temp=temp.next;
    }
}
travel(a)

递归遍历方法

数组

let a = [1, 2, 3, 4, 5]
function travel(arr, i) {
    if (arr == null || i >= arr.length) return;
    console.log(arr[i], '递归遍历');
    travel(arr, i + 1)
}
travel(a, 0)

链表

function ode(value) {
    this.value = value;
    this.next = null;
}

let a = new ode(1);
let b = new ode(2);
let c = new ode(3);
let d = new ode(4);

a.next = b;
b.next = c;
c.next = d;

function travel(root) {
    if (root == null) return;
    console.log(root.value, '递归算法');
    travel(root.next) // 找到一直在循环做的事情
}
travel(a)

链表逆置

function ode(value) {
    this.value = value;
    this.next = null;
}

let a = new ode(1);
let b = new ode(2);
let c = new ode(3);
let d = new ode(4);

a.next = b;
b.next = c;
c.next = d;

function reverse(root) {
    //定位到倒数第二个节点,
    if (root.next.next == null) {
        //把最后一个节点指向倒数第二个
        root.next.next = root;
        //退出节点
        return root.next;
    } else {
        //递归
        let result = reverse(root.next);
        //让该节点的下一个节点指向自己
        root.next.next = root;
        //让该节点指向null
        root.next = null;
        return result;
    }
}
//遍历一下
function travel(root) {
    if (root == null) return;
    console.log(root.value);
    travel(root.next)
}
travel(reverse(a))

冒泡排序(比较、交换、排序)

  • 算法步骤
    • 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
    • 针对所有的元素重复以上的步骤，除了最后一个。
    • 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
let arry = [4, 7, 2, 6, 0, 8, 9, 1, 3];
/**
 - 比较
 - 交换
 - 排序
 - */
function compare(a, b) {
    if (a > b) return true;
    else return false;
}
function exchange(arry, i, j) {
    let temp = arry[j]
    arry[j] = arry[i]
    arry[i] = temp
}
function sort(arry) {
    for (let i = 0; i < arry.length; i++) {
        for (let j = 0; j < arry.length - 1 - i; j++) {
            if (compare(arry[j], arry[j + 1])) {
                exchange(arry, j, j + 1)
            }
        }
    }
    return arry;
}
console.log(sort(arry));

选择排序

  • 算法步骤
    • 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
    • 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
    • 重复第二步，直到所有元素均排序完毕。
let arry = [4, 7, 2, 6, 0, 8, 9, 1, 3];

function compare(a, b) {
    if (a > b) return true;
    else return false;
}
function exchange(arry, i, j) {
    let temp = arry[j];
    arry[j] = arry[i];
    arry[i] = temp;
}
function sort(arry) {
    for (let i = 0; i < arry.length; i++) {
        let maxIndex = 0;
        for (let j = 0; j < arry.length - i; j++) {
            if (compare(arry[j], arry[maxIndex])) {
                maxIndex = j;
            }
            exchange(arry, maxIndex, arry.length - 1 - i);
        }
    }
    return arry;
}
console.log(sort(arry));

简单快速排序

  • 算法步骤
    • 从数列中挑出一个元素，称为 “基准”
    • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
    • 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序；
      在这里插入图片描述
let arr = [4, 7, 2, 6, 0, 8, 9, 1, 3];
function quicklySort(arr) {
    if (arr.length == 0 || arr == null) return [];
    let leader = arr[0];
    let left = [];
    let right = [];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < leader) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    // 递归 
    left = quicklySort(left);
    right = quicklySort(right);
    // 把 left leader right 的内容给拼接起来
    left.push(leader)
    let newArry = left.concat(right)
    return newArry

}
console.log(quicklySort(arr));

标准快速排序

let arr = [4, 7, 2, 6, 0, 8, 9, 1, 3];
//交换
function exchange(arr, a, b) {
    let temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
// 值 ，左指针，右指针
function quicklySort(arr, begin, end) {
    //数组的长度小于两个的时候就跳出
    if (begin > end - 1) return;
    let left = begin;
    let right = end;
    do {
        do {
            left++;
        } while (left < right && arr[begin] > arr[left]);
        do {
            right--;
        } while (left < right && arr[begin] < arr[right]);
        if (left < right) exchange(arr, left, right);
    } while (left < right);

    let exchangePoint = left == right ? right - 1 : right;
    exchange(arr, exchangePoint, begin);
    quicklySort(arr, begin, exchangePoint);
    quicklySort(arr, exchangePoint + 1, end)
}
function sort(arr) {
    //左闭右开区间
    quicklySort(arr, 0, arr.length);
}
sort(arr)
console.log(arr);

另一种方法 用到了 slice filter

let arr = [4, 7, 2, 6, 0, 8, 9, 1, 3];
/**
 * 定义arr是一个number值的数组
 * @param {number[]} arr 
 */
function quicklySort(arr) {
    if (arr.length < 2) {
        return arr
    }
    let goal = arr[0]
    //从数组的第一项开始，过滤出小于目标值的项
    let minArr = arr.slice(1).filter(item => item <= goal)
    //从数组的第一项开始，过滤出大于目标值的项
    let maxArr = arr.slice(1).filter(item => item >= goal)
    //递归 拼接
    return quicklySort(minArr).concat([goal]).concat(quicklySort(maxArr))
}
console.log(quicklySort(arr));

3.栈

pop() 方法

用于删除数组的最后一个元素并返回删除的元素。

栈只有一个口
在这里插入图片描述
演示的代码

// 相当于 桶 
let arr = [];
//进桶
function enter(arr, value) {
    arr.push(value);
}
//出桶
function out(arr) {
    arr.pop();
}
enter(arr,1)
console.log(arr);
enter(arr,2)
console.log(arr);
enter(arr,3)
console.log(arr);
out(arr)
console.log(arr);
out(arr)
console.log(arr);

输出：
在这里插入图片描述
简单封装一下代码：

function Stack() {
    this.arr = [];
    this.enter = function (value) {
       return this.arr.push(value);
    };
    this.out = function () {
        return this.arr.pop();
    } ;
}
let stack = new Stack();
stack.enter(1)
console.log(stack.arr);
stack.enter(2)
console.log(stack.arr);
stack.enter(3)
console.log(stack.arr);
stack.out()
console.log(stack.arr);
stack.out()
console.log(stack.arr);
stack.out()
console.log(stack.arr);

在这里插入图片描述

4.队列

shift() 方法

用于把数组的第一个元素从其中删除，并返回第一个元素的值。

队列一个口进一个口出
在这里插入图片描述

function Queue() {
    this.arr = [];
    this.enter = function (value) {
       return this.arr.push(value);
    };
    this.out = function () {
        return this.arr.shift();
    } ;
}
let queue = new Queue();
queue.enter(1)
console.log(queue.arr);
queue.enter(2)
console.log(queue.arr);
queue.enter(3)
console.log(queue.arr);
queue.out()
console.log(queue.arr);
queue.out()
console.log(queue.arr);
queue.out()
console.log(queue.arr);

输出
在这里插入图片描述

5.双向链表

在这里插入图片描述

function Node(value) {
    this.value = value;
    this.next = null;
    this.pre = null;
}
let node1 = new Node(1)
let node2 = new Node(2)
let node3 = new Node(3) 

node1.next = node2;
node2.pre = node1;
node2.next = node3;
node3.pre = node2;

优缺点

优点：能轻松的遍历整条链表
缺点：耗费存储空间

6.二维数据结构

树形结构（有向无环图）

特点

  • 树形结构只有一个根节点
  • 树形结构没有回路
  • 叶子节点
    - 下面没有根节点
  • 节点
    - 普通几点（不是根节点和叶子节点）
  • 树的度
    -各个节点叉最多的，有多少叉
  • 树的深度
    - 树中结点的最大层次数

满二叉树

  • 所有的叶子节点都在最底层
  • 每个非叶子节点都有两个子节点

在这里插入图片描述

完全二叉树

  • 国内定义：
    1.叶子节点都在最后一或倒数第二层
    2.叶子节点向左靠拢
  • 国际定义：

1.叶子节点都在最后一或倒数第二层
2.如果有叶子节点，必然有两个叶子节点
在这里插入图片描述

遍历二叉树

在这里插入图片描述

前序遍历(先根次序遍历) 当前 左边 右边 ABDECFG
// 前序遍历(先根次序遍历) 当前 左边 右边 A BDE CFG

function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}
// 给每个节点赋值 
let a = new Node("a");
let b = new Node("b");
let c = new Node("c");
let d = new Node("d");
let e = new Node("e");
let f = new Node("f");
let g = new Node("g");

//写左边邻居 右边邻居 A的左是B A的右是C
a.left = b;
a.right = c;

b.left = d;
b.right = e;

c.left = f;
c.right = g;

//遍历链表 树 之类的 要传递一个根节点进来 这里的根节点是a
function fl(root) {
    if (root === null) return;
    console.log(root.value);
    // 小递归 
    fl(root.left)
    fl(root.right)
}
fl(a);

打印结果
在这里插入图片描述

中序遍历(中根次序遍历) 左边 当前 右边 DBEAFCG
// 中序遍历(中根次序遍历) 左边 当前 右边 DBE A FCG
function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}

let a = new Node("a")
let b = new Node("b")
let c = new Node("c")
let d = new Node("d")
let e = new Node("e")
let f = new Node("f")
let g = new Node("g")

a.left = b;
a.right = c;
b.left = d;
b.right = e;
c.left = f;
c.right =g;


function fl(root) {
    if(root === null) return ;
    fl(root.left)
    console.log(root.value);
    fl(root.right)
}
fl(a)

运行结果
在这里插入图片描述

后序遍历(后根次序遍历) 左边 右边 当前 DEBFGCA
function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}

let a = new Node("a");
let b = new Node("b");
let c = new Node("c");
let d = new Node("d");
let e = new Node("e");
let f = new Node("f");
let g = new Node("g");

a.left = b;
a.right = c;
b.left = d;
b.right = e;
c.left = f;
c.right = g;

function fl(root) {
    if (root === null) return;
    fl(root.left);
    fl(root.right);
    console.log(root.value);
}
fl(a)

运行结果
在这里插入图片描述

还原二叉树

已知前序遍历和中序遍历还原二叉树 ，进行后序遍历
let forward = ["A", "B", "D", "E", "C", "F", "G",]
let middle = ["D", "B", "E", "A", "F", "C", "G",]

function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}

function f1(forward, middle) {
    //严谨性判断
    if (forward == null || middle == null || forward.length !== middle.length || forward.length == 0 || middle.length == 0) return null;

    //前序遍历的第一个值就是根节点
    let root = new Node(forward[0]);
    //先找到 根节点 在middle里排第几位 3
    let index = middle.indexOf(root.value);
    //slice取的是左闭右开区间 
    //中序遍历的  左边 就是 在index 之前的  从下标第0个开始 到index个（不取index）
    let middleLeft = middle.slice(0, index);
    //中序遍历的  右边 就是 从index之后的 
    let middleRight = middle.slice(index + 1, middle.length)
    //前序遍历的 左边 就是 从 index 之后的index+1个 因为index下标为0，所以从1开始
    let forwardLeft = forward.slice(1, index + 1);
    //前序遍历的 右边 就是 从 index+1个之后 
    let forwardRight = forward.slice(index + 1, forward.length)
    //递归 先前序后中序
    root.left = f1(forwardLeft, middleLeft)
    root.right = f1(forwardRight, middleRight)
    return root;
}
//后续遍历
function f2(root) {
    if (root == null) return;
    f2(root.left)
    f2(root.right)
    console.log(root.value);
}
f2(f1(forward, middle))

结果：
在这里插入图片描述

已知中序遍历和后序遍历还原二叉树 ，进行前序遍历

let middle = ["D", "B", "E", "A", "F", "C", "G",]
let back = ["D", "E", "B", "F", "G", "C", "A",]

function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}

function f1(middle, back) {
    //严谨性判断
    if (middle == null || back == null || back.length !== middle.length || back.length == 0 || middle.length == 0) return null;

    //后续遍历的最后一个就是A
    let root = new Node(back[back.length-1]);
    //先找到 根节点 在middle里排第几位 3
    let index = middle.indexOf(root.value);
    //slice取的是左闭右开区间 

    //中序遍历的  左边 就是 在index 之前的 
    let middleLeft = middle.slice(0, index);
    //中序遍历的  右边 就是 从index之后的
    let middleRight = middle.slice(index + 1, middle.length)

    //后序遍历的 左边 就是 从 1 之后的index+1个
    let backLeft = back.slice(0, index );
    //后序遍历的 右边 就是 从 index+1个之后 
    let backRight = back.slice(index , back.length-1)
    //递归 
    root.left = f1(middleLeft, backLeft)
    root.right = f1(middleRight, backRight)
    return root;
}
function f2(root) {
    if (root == null) return;
    console.log(root.value);
    f2(root.left)
    f2(root.right)
}
f2(f1(middle,back))

运行结果
在这里插入图片描述

二叉树的深度优先搜索

优点：实现比较简单
缺点：容易爆栈，如果很多的话
在这里插入图片描述

function Node(value){
    this.value = value;
    this.left = null;
    this.right = null;
}

let a = new Node("a");
let b = new Node("b");
let c = new Node("c");
let d = new Node("d");
let e = new Node("e");
let f = new Node("f");
let g = new Node("g");

a.left = b;
a.right = c;

b.left = d;
b.right = e;

c.left = f;
c.right = g;

function deepSearch(root,target){
    if(root == null) return false;
    if(root.value == target) return true;
    let left = deepSearch(root.left,target);
    let right = deepSearch(root.right,target);
    return left || right
}
console.log(deepSearch(a,"g"));

假如说我搜索一个g，g在二叉树里面，所以结果是true
在这里插入图片描述

二叉树的广度优先搜索

实现方法：先拿个数组，把A装进去，如果没有，把A移除，装B,C，如果没有，把BC移除，装DEFG，如果找到了，返回true。
在这里插入图片描述

function Node(value){
    this.value = value;
    this.left = null;
    this.right = null;
}

let a = new Node("a");
let b = new Node("b");
let c = new Node("c");
let d = new Node("d");
let e = new Node("e");
let f = new Node("f");
let g = new Node("g");

a.left = b;
a.right = c;

b.left = d;
b.right = e;

c.left = f;
c.right = g;

//广度优先搜索
function wideSearch(rootList,target){
    if(rootList == null && rootList.length == 0) return false;
    let childList = [];
    for(let i = 0;i<rootList.length;i++){
        if(rootList[i] !== null && rootList[i].value == target){
            return true
        }else{
            childList.push(rootList[i].left)
            childList.push(rootList[i].right)
        }
    }
    //如果最后一位为空的话，就返回false
    if(childList[childList.length-1]==null){
        return false
    }else{
        return wideSearch(childList,target)
    } 
}
console.log(wideSearch([a],"h"));

假如说我搜索一个h，h不在二叉树里面，返回false
在这里插入图片描述

二叉树的比较

默认左右子树不分次序

function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}

let a1 = new Node("a");
let b1 = new Node("b");
let c1 = new Node("c");
let d1 = new Node("d");
let e1 = new Node("e");
let f1 = new Node("f");
let g1 = new Node("g");

a1.left = b1;
a1.right = c1;
b1.left = d1;
b1.right = e1;
c1.left = f1;
c1.right = g1;

let a2 = new Node("a");
let b2 = new Node("b");
let c2 = new Node("c");
let d2 = new Node("d");
let e2 = new Node("e");
let f2 = new Node("f");
let g2 = new Node("g");

a2.left = b2;
a2.right = c2;
b2.left = d2;
b2.right = e2;
c2.left = f2;
c2.right = g2;

function compareTree(root1,root2){
    //都为空的话肯定是相同的
    if(root1 == null && root2 == null) return true
    //一个为空 另一个不为空的话,结构都不一样,肯定是不相同的
    if(root1 == null && root2 !== null ||root1 !== null && root2 == null) return false
    //value值不相等,两个二叉树不相同
    if(root1.value!==root2.value) return false
    let leftBool =  compareTree(root1.left,root2.left)
    let rightBool =  compareTree(root2.right,root2.right)
    return leftBool && rightBool
}
console.log(compareTree(a1,a2));

二叉树左右子树互换后的比较

function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}

let a1 = new Node("a");
let b1 = new Node("b");
let c1 = new Node("c");
let d1 = new Node("d");
let e1 = new Node("e");
let f1 = new Node("f");
let g1 = new Node("g");

a1.left = b1;
a1.right = c1;
b1.left = d1;
b1.right = e1;
c1.left = f1;
c1.right = g1;

let a2 = new Node("a");
let b2 = new Node("b");
let c2 = new Node("c");
let d2 = new Node("d");
let e2 = new Node("e");
let f2 = new Node("f");
let g2 = new Node("g");

a2.left = c2; //互换了c2，b2
a2.right = b2; //互换了c2，b2
b2.left = d2;
b2.right = e2;
c2.left = f2;
c2.right = g2;

function compareTree(root1, root2) {
    if (root1 == null && root2 == null) return true
    if (root1 == null && root2 !== null || root1 !== null && root2 == null) return false
    if (root1.value !== root2.value) return false
    return compareTree(root1.left, root2.left) && compareTree(root1.right, root2.right) || compareTree(root1.left, root2.right) && compareTree(root1.right, root2.left)
}
console.log(compareTree(a1, a2));

结果为true

二叉树的diff算法

输出二叉树不一样的地方
增加了什么，改动了什么，删除了什么

function Node(value) {
    this.value = value;
    this.left = null;
    this.right = null;
}

let a1 = new Node("a");
let b1 = new Node("b");
let c1 = new Node("c");
let d1 = new Node("d");
let e1 = new Node("e");
let f1 = new Node("f");
let g1 = new Node("g");

a1.left = b1;
a1.right = c1;
b1.left = d1;
b1.right = e1;
c1.left = f1;
c1.right = g1;

let a2 = new Node("a");
let b2 = new Node("b");
let c2 = new Node("c");
let d2 = new Node("d");
let e2 = new Node("e");
let f2 = new Node("f");
let g2 = new Node("g");

a2.left = b2;
a2.right = c2;
b2.left = d2;
b2.right = e2;
c2.left = f2;
c2.right = g2;


// let diffList=[
//     {
//         type:"增加了||删除了||改动了",
//         origin:c1, //原始
//         now: ff , //现在
//     }
// ];
let diffList = [];
function diffTree(root1,root2,diffList){
    if(root1 == root2) return diffList;
    if(root1 == null && root2 != null){
        diffList.push({
            type:"增加了什么",
            origin:null,
            now:root2,
        });
    }else if( root1 != null && root2 == null){
        diffList.push({
            type:"删除了什么",
            origin:root1,
            now:null,
        });
    }else if(root1.value !=root2.value){
        diffList.push({
            type:"改动了",
            origin:root1.value,
            now:root2.value,
        })
    }else{
        diffTree(root1.left,root2.left,diffList);
        diffTree(root1.right,root2.right,diffList);
    }
}
diffTree(a1,a2,diffList);
console.log(diffList);

7.图

普利姆算法（加点法）

1.挑选出一个节点
2.挑选出一个最短的边区进行联通
3.如果对方没有被联通进系统里则进行联通
4.如果被连进了系统里则去寻找第二短的边
5.重复2-4步

克鲁斯卡尔算法

1.先找最小的边
2.如果说链接的两个点有为两个系统的或者至少有一个没有被链接
3.则加边
4.重复以上三部

杨白鹤
关注
专栏目录
语音算法笔记
shichaog的专栏
10-23 5353
[语音增强和语音识别网页书](https://legacy.gitbook.com/book/shichaog1/hand-book-of-speech-enhancement-and-recognition/details) 语音处理算法一直处于研究和发展的阶段，随着人工智能的兴起，人工智能的两个入口：语音和视觉正变的越来越重要，这也是未来5~10年各个AI公司关注的重点。 语音处理算法主要...
10大前端常用算法，赶紧学起来
qd520_1314的博客
04-20 1860
从事前端开发工作差不多3年了，自己也从一个什么都不懂的小白积累了一定的理论和实践经验，并且自己也对这3年来的学习实践历程有一个梳理，以供后面来细细回忆品味。 1、为什么选择学习前端开发？ 你可能是因为兴趣，完成一个网站、页面、功能的成就感。你也可能是因为现在前端岗位火爆，就业率高。不管是因为什么，只要找准了目标，学就是了！ 字节跳动（校招） 一面： TCP、UDP是什么，区别，应用 什么是字节流，什么是数据报 TCP为啥可靠 超时重传、累计确认的过程 HTTP跟TCP的联系 http通信过程 http.
前端day06笔记
m0_62277259的博客
07-14 375
没有return返回的是underfined。for let i in 数组名。arguments:接实参。
Web前端自学教程笔记导读
Sophie_U的博客
08-01 380
Web前端系列入门教程导读
前端如何搞定算法面试？
2401_84419493的博客
04-27 556
除了简历做到位，面试题也必不可少，整理了些题目，前面有117道汇总的面试到的题目，后面包括了HTML、CSS、JS、ES6、vue、微信小程序、项目类问题、笔试编程类题等专题。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】
2024年Web前端最新从 0 到 1 的前端算法知识已经为你整理好啦，作为程序员一定不要仅仅追求物质
2401_84123077的博客
05-06 842
在这个过程你会发现，有很多 JS 知识点你并不能更好的理解为什么这么设计，以及这样设计的好处是什么，这就逼着让你去学习这单个知识点的来龙去脉，去哪学？更重要的是，技术面试是一个双向了解的过程，要让对方发现你的闪光点，同时也要 试图去找到对方的闪光点，因为他以后可能就是你的同事或者领导，所以，面试官问你有什么问题的时候，不要说没有了，要去试图了解他的工作内容、了解这个团队的氛围。请你解释⼀下，内存中的栈(stack)、堆(heap) 和静态区(static area) 的⽤法。介绍⼀下，排序都有哪⼏种⽅法？
BRISK算法学习笔记
weixin_40196271的博客
11-21 5169
一、部分原文解读 1.尺度空间关键点检测         兴趣点用一个显著性标准在图像和尺度空间进行识别。为了加快计算的效率，关键点可以在金字塔图像的层或者层之间进行检测。每个关键点的位置和尺度通过二次函数拟合的方式在持续的区域获得。 2.关键点描述          一个由依靠合适的尺度中心圆的点组成的采样方式是应用在每个关键点的邻域上来恢复灰度值：计算局部梯度强度的过程中，特征的方向可...
前端学习笔记202310学习笔记第一百零六天-vue3-虚拟dom和diff算法3
qq_41632427的博客
10-19 34
前端
前端学习笔记202310学习笔记第一百零六天-vue3-虚拟dom和diff算法1
qq_41632427的博客
10-19 33
前端
前端学习笔记202310学习笔记第一百零六天-vue3-虚拟dom和diff算法4
qq_41632427的博客
10-19 30
前端
markdown:前端学习笔记
05-04
使用Dijkstra算法实现最短路线规划 Flutter flutter路由详解 flutter安装包App.svelte、加快启动速度 flutter 异步编程 事件循环、Isolate Stream（流） ios数字键盘解决方案 人生不止有技术 理财
前端面试刷题必备，阮一峰ES6教程、JavaScript笔记、html、css、JavaScript、Vue、React、算法、
08-17
前端面试刷题必备，阮一峰ES6教程、JavaScript笔记、html、css、JavaScript、Vue、React、算法、前端日记Blog
typora学习的前端笔记
07-06
8. **js算法.md**：JavaScript算法学习笔记，可能涉及到数据结构、排序算法、查找算法等内容，是提升编程思维和解题能力的重要资料。 9. **写7.6帮盲遇到的问题与解决.md**：可能是作者参与某个7月6日的公益活动中...
P8大佬的算法解题笔记.pdf
01-04
《P8大佬的算法解题笔记》是一份深入探讨算法问题的资料，主要涉及如何解决实际编程中的数据结构和算法挑战。以下将针对其中提到的两个典型问题进行详细阐述。 ### 1. 合并两个有序链表 **问题描述**： 给定两个已...
js中【Worker】相关知识点详细解读
2301_79858914的博客
09-11 864
JavaScript 中的 Worker 是一个可以在后台线程中运行代码的 API，这样可以避免主线程（通常是 UI 线程）被阻塞。使用 Worker 时，JavaScript 可以在多线程环境中工作，解决了单线程的瓶颈问题。通常情况下，JavaScript 是单线程的，也就是所有的代码（包括 DOM 操作和事件处理等）都在同一个线程里执行。如果某段代码需要大量计算，或者运行时间过长，会阻塞整个页面，导致界面卡顿甚至崩溃。Worker提供了一种将复杂或耗时的任务分配到后台线程执行的方法。
【JavaScript】LeetCode：707设计链表
最新发布
weixin_45980065的博客
09-14 508
【代码】【JavaScript】LeetCode：707设计链表。
echarts.js+china.js实现中国地图各省数据案例
qq_58258855的博客
09-11 456
实现中国地图各省数据案例
JS笔记
2201_76100326的博客
09-11 885
javascript中的对象分为3种：自定义对象，内置对象，浏览器对象 JavaScript 中的所有事物都是对象：字符串、数字、数组、日期，等等。在 JavaScript 中，对象是拥有属性和方法的数据。属性是与对象相关的值。方法是能够在对象上执行的动作。.关键词（）
JavaScript基础
zhangh040629的博客
09-10 1317
//** 控制浏览器弹出一个警告框* alert()*/alert;/** 让计算机在页面中输出一个内容*/write;/** 向控制台输出一个内容*/log;</</</</
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值