算法入门-常见的算法

常见算法(排序、查找、递归...) 1)二分查找、插值查找、斐波那契查找各自的特点相同点:都是通过不断的缩小范围来查找对应的数据的不同点:计算mid的方式不一样二分查找:mid每次都是指向范围的中间位置插值查找:mid尽可能的靠近要查找的数据,但是要求数据尽可能的分布均匀斐波那契查找:根据黄金分割点来计算mid指向的位置。 阅读详情

一 算法入门

1 常见位运算

  1. 位与(&):二元运算符,两个为1时结果为1,否则为0
  2. 位或(|):二元运算符,两个其中有一个为1时结果就为1,否则为0
  3. 位异或(^):二元运算符,两个数同时为1或0时结果为1,否则为0 (可以理解为无进位相加)
  4. 位取非(~):一元运算符,取反操作
  5. 左移(<<):一元运算符,按位左移一定的位置。高位溢出,低位补符号位,符号位不变。
  6. 右移(>>):一元运算符,按位右移一定的位置。高位补符号位,符号位不变,低位溢出。
  7. 无符号右移(>>>):一元运算符,符号位(即最高位)保留,其它位置向右移动,高位补零,低位溢出。

认识异或运算:

  1. 满足结合律 (a ^ b)^ c = a ^ (b ^ c)
  2. 满足交换律 a ^ b = b ^ a
  3. 满足自反性 a ^ a = 0 a ^ b ^ b = a ^ 0=a

2 位运算技巧

  1. 取mid
// 常见写法
int mid = (l + r)/2;
// l+r容易导致溢出
int mid = r + (r - l)/2;
// 位运算优化
int mid = l + ((r - l) >> 1);
  1. N*2+1
// 常见写法 例如 11 = 5 * 2 + 1
int sum = N * 2 + 1;
// 位运算写法 0101 << 1 
// 0 1010舍弃最高位为1010  值为10  
// 1010 | 1 为 1011 为11
int sum = (N << 1 | 1);

3 位运算题目

1 如何不用额外变量交换两个数

int a = 3;
int b = 5;
// 通常swap方法 这种方法需要多申请一个变量  增加了常数项的空间复杂度
int temp = a;
a = b;
b = temp;
// 通过位运算 不用开辟额外空间,并且计算速度更快 
a = a^b;
b = a^b;
a = a^b;

2 一个数组中有一组数出现了奇数次,其他出现偶数次,找到并打印这种数

// 方法一 最暴力的使用map 比较简单  不进行演示
// 缺点:需要开辟额外空间map
// 方法二 使用位运算
	    int eor = 0;
        for (int i = 0; i < ints.length; i++) {
            eor ^= ints[i];
        }
        System.out.println(eor);

3 把一个int值的最右侧1提取出来

// 0111
int a = 7; 
/**
 ~a 取反 0111 取反 1000 
 ~a +1  1001
 a & (~a + 1)  0001
*/
int b = a & (~a + 1)

4一个数组中有两个数出现了奇数次,其他出现偶数次,找到并打印这两个数

// 第一种方法: 使用map计数 比较简单 不进行演示
// 缺点: 需要额外开辟空间map
// 第二种方法:通过位运算
        int a = 0;
        for (int i = 0; i < ints.length; i++) {
            // 结果为 a ^ b   因为a,b不为0 所以a^b != 0
            a ^= ints[i];
        }
        int var2 = a & (~a + 1);
        int b = 0;
        for (int i = 0; i < ints.length; i++) {
            if ((var2 & ints[i]) == 0) {
                b ^= ints[i];
            }
        }
        System.out.println(b + "-" + (b ^ a));

二 队列和栈

1 题目

1 实现一个特殊的栈,在基础的功能上实现,实现返回栈中最小数据的功能。

  1. 要求push,pop,getMin的时间复杂度为O(1)

第一种方案:
在这里插入图片描述

两个栈,一个栈为正常存储数据的栈,另一个栈为存储最小数据的栈,每次入栈的时候都要和minData最顶的数据(即栈中最小的数据)进行对比,若新的数据小于栈顶的数据,则压入新的数据进入minData的栈;否则再次压入minData中最小的数据。

优点:栈顶一直记录的是最小的元素,且获取最小的元素的时间复杂度为O(1)

缺点:浪费空间,要创建和data栈一样的栈。

第二种方案:

还是第一种方案的模型,只不过minData栈只会压入新元素小于等于minData栈顶元素的元素。
在这里插入图片描述

2 如何用栈结构实现队列结构

使用两个栈,一个push栈,一个pop栈,push的时候讲数据压入push栈,poll的时候将pop栈中的数据弹出,pop栈的数据从push栈获取。注意事项:

  1. pop栈空时才能从push栈里获取数据
  2. pop从push栈中获取数据时,需要将push栈中的数据全部压入pop栈中。

3 如何用队列结构实现栈结构

使用两个队列,一个push队列,一个pop队列,push的时候把数据往push队列里插入数据,pop的时候将push的队列后面n-1个数据出站并且进入pop队列,然后push和pop队列互换身份,在将pop队列的数据pop出。用两个队列实现了栈的基本操作push和pop操作。
在这里插入图片描述

三 链表相关算法

1 模型

public class Node {
    public int value;

    public Node next;
}

2 题目

链表奇数长度返回中点,偶数长度返回上中点

利用快慢指针,慢指针一次前进一个节点,快指针一次前进两个节点。

    /**
     * 链表奇数长度返回中点,偶数长度返回上中点
     *
     * @param node1
     * @return
     */
    private static Node getMidUp(Node node1) {
        Node fast = node1;
        Node slow = node1;
        while (fast != null && fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

链表奇数长度返回中点,偶数长度返回下中点

    /**
     * 链表奇数长度返回中点,偶数长度返回下中点
     *
     * @param node1
     * @return
     */
    private static Node getMidDown(Node node1) {
        Node fast = node1;
        Node slow = node1;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

判断一个链表是否有环

    /**
     * 判断一个链表是否有环,有环则返回一个入环节点
     * 简单实现,利用set
     *
     * 注意事项:
     * 不建议Node类重写Equels和HashCode,因为有环的情况下会导致栈溢出
     * @param head
     * @return
     */
    public static Node isRing(Node head) {
        HashSet<Node> nodesSet = new HashSet<>();
        Node cur = head;
        while (cur != null) {
            boolean contains = nodesSet.contains(cur);
            if (contains) {
                return cur;
            }
            nodesSet.add(cur);
            cur = cur.next;
        }
        return null;
    }

    /**
     * 判断一个链表是否有环,有环则返回一个入环节点
     * 用快指针和慢指针
     *
     * @param head
     * @return
     */
    public static Node isRingP(Node head) {
        if (head == null || head.next == null) {
            return null;
        }
        Node fast = head;
        Node slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                fast = head;
                break;
            }
        }
        if (fast == head) {
            while (fast != slow) {
                fast = fast.next;
                slow = slow.next;
            }
            return slow;
        }
        return null;
    }

给定两个可能有环也可能无环的单链表,头结点为head1和head2。实现一个函数若两个链表相交则返回相交的第一个节点,若不相交则返回null;两链表长度为n,要求时间复杂度为O(n),额外空间复杂度为O(1)。

解题思路:

① 两个都没有环的情况下,可能会存在交叉也可能没有

② 一个有环一个无环的情况下,不可能相交

③ 两个都有环的情况下,可能相交,也可能不相交

​ ① 两个都有环,但不相交

​ ② 在入环节点之前相交

​ ③ 在入环节点之后相交

    /**
     * 两个无环链表判断是否相交,相交则返回相交点,不相交则返回null
     *
     * @param head1
     * @param head2
     * @return
     */
    private static Node bothNoRing(Node head1, Node head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        Node cur1 = head1;
        Node cur2 = head2;
        int n = 0;
        while (cur1.next != null) {
            cur1 = cur1.next;
            n++;
        }
        while (cur2.next != null) {
            cur2 = cur2.next;
            n--;
        }
        // 最后一个节点不是公共节点,则不是相交
        if (cur1 != cur2) {
            return null;
        }
        // 长的位cur1
        cur1 = n > 0 ? head1 : head2;
        // 段的是cur2
        cur2 = cur1 == head1 ? head2 : head1;
        n = Math.abs(n);
        while (n != 0) {
            n--;
            cur1 = cur1.next;
        }
        while (cur1 != cur2) {
            cur1 = cur1.next;
            cur2 = cur2.next;
        }
        return cur1;
    }
/**
     * 判断两个链表是否是有相交
     * ① 两个都没有环的情况下,可能会存在交叉也可能没有
     * ② 一个有环一个无环的情况下,不可能相交
     * ③ 两个都有环的情况下,可能相交,也可能不相交
     *    ① 两个都有环,但不相交
     *    ② 在入环节点之前相交
     *    ③ 在入环节点之后相交
     *
     * @param head1
     * @param head2
     * @return
     */
    public static Node isIntersect(Node head1, Node head2) {
        // 先看是否都有环
        Node ringP1 = isRingP(head1);
        Node ringP2 = isRingP(head2);
        /**一个有环一个没环,那就不可能相交*/
        if (ringP1 == null && ringP2 != null || ringP1 != null && ringP2 == null) {
            return null;
        }
        /**先看两个都无环的情况*/
        if (ringP1 == null && ringP2 == null) {
            return bothNoRing(head1, head2);
        }
        /**两个都有环*/
        return bothRing(head1, ringP1, head2, ringP2);
    }

    /**
     * 两个链表都有环的情况下,有交点则返回交点,无相交则返回null
     *
     * @param head1
     * @param ringP1
     * @param head2
     * @param ringP2
     * @return
     */
    private static Node bothRing(Node head1, Node ringP1, Node head2, Node ringP2) {
        // 在入环节点之前是否相交
        if (ringP1 == ringP2) {
            // 说明在入环节点之前相交了 退化成无环链表的交点问题
            return bothNoRing(head1, head2, ringP1);
        } else {
            // 在入环节点之后相交
            return intersectAfterRing(ringP1, ringP2);
        }
    }

    /**
     * 在入环节点之后相交
     *
     * @param ringP1
     * @param ringP2
     * @return
     */
    private static Node intersectAfterRing(Node ringP1, Node ringP2) {
        Node cur1 = ringP1.next;
        while (cur1 != ringP1) {
            if (cur1 == ringP2) {
                return cur1;
            }
        }
        return null;
    }

    /**
     * 两个无环链表判断是否相交,相交则返回相交点,不相交则返回null
     *
     * @param head1
     * @param head2
     * @return
     */
    private static Node bothNoRing(Node head1, Node head2, Node tail) {
        if (head1 == null || head2 == null) {
            return null;
        }
        Node cur1 = head1;
        Node cur2 = head2;
        int n = 0;
        while (cur1 != tail) {
            cur1 = cur1.next;
            n++;
        }
        while (cur2 != tail) {
            cur2 = cur2.next;
            n--;
        }
        // 最后一个节点不是公共节点,则不是相交
        if (cur1 != cur2) {
            return null;
        }
        // 长的位cur1
        cur1 = n > 0 ? head1 : head2;
        // 段的是cur2
        cur2 = cur1 == head1 ? head2 : head1;
        n = Math.abs(n);
        while (n != 0) {
            n--;
            cur1 = cur1.next;
        }
        while (cur1 != cur2) {
            cur1 = cur1.next;
            cur2 = cur2.next;
        }
        return cur1;
    }
38、Python入门 爬虫的常见算法 路线为“首页→Python→Node.js→Golang→爬虫→Django→机器学习→基础知识→Express→基础知识→并行计算→课时1→课时2→……这样导致的问题就是,餐馆A的订单量可能是早上8点爬到的,而餐馆B是晚上8点爬到的。每个大分类的信息,然后从第1个大分类中爬取所有的课程信息,爬完了第1个大分类,再爬第2个大分类,直到所有大分类下面的课程信息都搞定了,再爬第一个课程的。的所有课时都爬取完成,再爬取Django的所有课程,接着爬取机器学习的所有课程,之后再去爬取Node.js的所有信息。 阅读详情

相关推荐

Python入门教程:几种常见的Python算法实现

今天跟大家总结的Python学习教程关于Python算法的实现,上次催我更算法的伙伴可以粗来了! 1、选择排序 选择排序是一种简单直观的排序算法。它的原理是这样:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的后面,以此类推,直到所有元素均排序完毕。算法实现如下: #找到最小的元素def FindSmall(l...

chen801090的博客 2488

算法入门详解

算法可以被视为一种计算过程通过一系列有序的步骤来执行特定的任务。它是一种数学概念,通常由一组输入、输出和执行步骤组成。一个好的算法应该是正确的、高效的,并且适用于特定问题。递归是一种通过在算法的执行过程中自我调用的方式来解决问题的方法。在递归算法中,问题被分解为更小的子问题,并通过递归调用相同的算法来解决这些子问题。递归算法通常通过定义一个或多个基本情况(边界条件)来终止递归过程。这样描述可能有点抽象,下面通过几道例题进行加深你的理解。将难以直接解决的大问题分解成一些规模较小的相同。

weixin_44907888的博客 1万+

c++常见入门级算法题五十道

c++常见入门级算法题五十道

m0_66127918的博客 1324

基础夯实:基础数据结构与算法(二)

基础夯实:基础数据结构与算法(二)常见的10种算法1、递归算法例题1:计算n!例题2:斐波那契数列例题3:递归将整形数字转换为字符串例题4:汉诺塔例题5:猴子吃桃例题6:N皇后问题2、排序算法冒泡排序:快速排序:3、二分查找算法4、搜索算法5、哈希算法6、贪心算法7、分治算法求x的n次幂归并排序8、回溯算法9、动态规划(DP)算法10、字符串匹配算法参考文献 上一章我们说了常见的10种数据结构,接下来我们说常见的10种算法。 上一章地址:基础夯实:基础数据结构与算法(一),不怎么清楚的可以去瞅瞅。 常见的1

熊泽-学习中的苦与乐 4368

ConnectionResetError 10054 根因分析与全链路防御指南

ConnectionResetError(错误码10054)是TCP协议中服务端主动发送RST包导致的强制断连,本质并非网络连接失败,而是服务端基于空闲超时、连接满载、TLS协商失败等策略做出的确定性终止决策。理解其底层原理有助于跳出‘重试’误区,转向连接生命周期管理。该错误高频出现在HTTP长连接、WebSocket、第三方API对接等场景,尤其在Nginx反向代理、负载均衡器(如AWS ALB)、WAF设备及内核conntrack机制下极易触发。本文结合Wireshark抓包分析、客户端心跳保鲜、协议指

weixin_30225755的博客 642

稳健自适应波束形成学习(2):自适应计算对角加载量方法——基于广义线性组合的鲁棒Capon波束形成

对于快拍数相对阵元数较小时,样本协方差矩阵不能很好对协方差矩阵进行估计。常规的对角加载量需要根据经验值或不断手动调整进行测试,没有一个明确的准则和推导。该篇介绍一种自适应计算对角加载量的方法,且能适应快拍数相对阵元数较小时的情况。均匀线阵阵元数:18;载波频率30MHz;通信信号来波方向0°、来波估计偏差0.5°;干扰来波方向30°;通信信号信噪比10dB;干扰信号信噪比60dB。也即在干扰角度生成66dB的零陷,通信信号受到16dB的衰减。

a1uajug的博客 825

算法入门篇-详解

步骤的集合: 算法首先是一个步骤的集合,这些步骤用于解决某个特定的问题或执行特定的计算。这些步骤被明确地定义,并且按照特定的顺序执行。明确性: 算法中的每一个步骤都必须是明确无误的,不能存在歧义。这意味着对于任何执行算法的人或系统来说,算法中的每一个步骤都应该有一个清晰、唯一的解释。有穷性: 算法必须在有限的时间内完成,也就是说,它不能无限地执行下去。这要求算法中的步骤数量是有限的,并且每一步骤的执行时间也是有限的。输入与输出: 算法通常具有输入和输出。

战族狼魂的博客 4518

手把手教你用VSCode+SDL在Ubuntu上跑LVGL8.2模拟器(附插件清单)

本文详细介绍了在Ubuntu系统上使用VSCode和SDL库搭建LVGL8.2模拟器环境的完整流程,特别适合嵌入式开发者(如全志F1C100s平台)进行UI设计验证。从环境配置、项目编译到VSCode深度集成,提供了实用技巧和常见问题解决方案,帮助开发者实现'先模拟后真机'的高效开发模式。

weixin_33737134的博客 358

【基础算法Ⅰ】算法入门篇

什么是枚举■枚举是基于已有知识来猜测答案的一种问题求解策略。■枚举的思想是不断地猜测,从可能的集合中一一尝试,然后再判断题目的条件是否成立。枚举的要点■建立简洁的数学模型。枚举的时候要想清楚:可能的情况是什么?要枚举哪些要素?■枚举的范围是什么?是所有的内容都需要枚举吗?在用枚举法解决问题的时候,一定要想清楚这两件事,否则会带来不必要的时间开销。■根据题目判断。比如例题中要求的是最大的符合条件的素数,那自然是从大到小枚举比较合适。

weixin_72686492的博客 3931

国科大学习资料--计算机视觉(胡占义、董秋雷)--2018-2019第二学期期末试卷

国科大学习资料–计算机视觉(胡占义、董秋雷)–2018-2019第二学期期末试卷 国科大学习资料–计算机视觉(胡占义、董秋雷)–2018-2019第二学期期末试卷 国科大学习资料–计算机视觉(胡占义、董秋雷)–2018-2019第二学期期末试卷 ...

无名何许人的博客 2169

CATIA二次开发核心技术:多实体零件自动化拆解与装配生成深度解析(零件转产品)

CATIA二次开发核心技术:多实体零件自动化拆解与装配生成深度解析

KE17RS的博客 2146

常见的限流算法入门

实际项目中,还需要确定限流对象,也就是针对什么来进行限流。常见的限流对象如下: IP :针对 IP 进行限流,适用面较广,简单粗暴。 业务 ID:挑选唯一的业务 ID 以实现更针对性地限流。例如,基于用户 ID 进行限流。 个性化:根据用户的属性或行为,进行不同的限流策略。例如, VIP 用户不限流,而普通用户限流。 根据系统的运行指标(如 QPS、并发调用数、系统负载等),动态调整限流策略。例如,当系统负载较高的时候,控制每秒通过的请求减少

LUCIAZZZ的博客 1077

视觉Transformer实战 | Token-to-Token Vision Transformer(T2T-ViT)详解与实现

Vision Transformer (ViT) 在计算机视觉领域取得了巨大成功,但标准的 ViT 存在一些局限性,如需要大规模预训练数据、对局部结构建模不足等。Token-to-Token ViT (T2T-ViT) 通过引入渐进式分词过程改进了原始 ViT,使其能够在中小型数据集上取得更好的性能。本节将详细介绍 T2T-ViT 的技术原理,并使用 PyTorch 从零开始实现 T2T-ViT。

盼小辉丶的博客 4万+

python入门算法_Python入门教程:几种常见的Python算法实现

今天跟大家总结的Python学习教程关于Python算法的实现,上次催我更算法的伙伴可以粗来了!在这里插入图片描述1、选择排序选择排序是一种简单直观的排序算法。它的原理是这样:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的后面,以此类推,直到所有元素均排序完毕。算法实现如下:#找到最小的元素def FindSm...

weixin_39928102的博客 207

将Windbg附加到软件进程上排查异常闪退的问题

使用Windbg和Process Explorer排查因为内存泄漏导致的软件异常闪退问题。

dvlinker的技术专栏 1万+

L型探测器几何畸变矫正

定位像素空间位置 -> 计算水平面投影点 -> 统一物理分辨率 -> 重采样生成新图。

如果想成为中心,那么就到中心去吧。 244

ACM算法竞赛入门——算法竞赛赛制、题目形式、常见评测状态

最全的acm算法竞赛赛制介绍、比赛、题目形式、常见测评状态

大四蒟蒻的学习笔记 1万+

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Java算法入门以及常见时间复杂度的推导

详细介绍了算法的入门知识,比如算法的定义,以及算法的时间复杂度推导和常见算法的时间复杂度。

终生学习践行者 3144

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

机器学习入门:常见算法

阿里云大学课程:机器学习入门:常见算法 课程介绍 机器学习(Machine Learning, ML)是人工智能的核心,专门研究计算机怎样模拟或实现人类的学习行为,以获取新的知识或技能,重新组织已有的知识结构使之不断改善自身的性能,它是使计算机具有智能的根本途径,其应用遍及人工智能的各个领域。 本课程将带你入门机器学习,掌握机器学习的概念和常用的算法。 课时列表: 第1 章 : 机器学习...

weixin_40050195的博客 211

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

双指针算法入门 —— 常见例题

当fast指针指向的数与slow指针不相同时,slow指针便向右移动一位,此时slow指针指向的值被更新为fast指针所指向的值。每次循环时,我们比较左指针与右指针所指向的数字的平方,将较大的那个数放在res(答案数组)的最左端(这一点比较好实现,因为答案数组与nums是等长的)。那么索引等于2的元素需要被退格。考虑 nums 的唯一元素的数量为 k ,你需要做以下事情确保你的题解可以被通过: 更改数组 nums ,使 nums 的前 k 个元素包含唯一元素,并按照它们最初在 nums 中出现的顺序排列。

m0_73456105的博客 1614

C++ STL算法从入门及常见运用方法详解

算法主要是由头文件组成。是所有STL头文件中最大的一个,范围涉及到比较、 交换、查找、遍历操作、复制、修改等等。体积很小,只包括几个在序列上面进行简单数学运算的模板函数定义了一些模板类,用以声明函数对象。

Dola的博客 1559

【Java入门】常见算法-笔记

本文总结了常见的查找和排序算法。查找算法包括基本查找、二分查找、插值查找、斐波那契查找、分块查找和哈希查找,重点分析了它们的原理、适用条件及实现方法。排序算法部分介绍了冒泡排序、选择排序、插入排序、递归算法和快速排序,详细说明了每种算法的执行过程。此外还介绍了Arrays工具类的常用方法,包括数组转字符串、二分查找、数组拷贝和排序等。最后简要说明了Lambda表达式的作用,即简化函数式接口的实现。全文系统性地整理了数据查找和排序的核心算法,为编程实践提供了清晰的指导。

Keyser_的博客 282

C语言算法入门常见错误

scanf没加& 弄错变量定义域 弄错数组循环遍历范围 变量未初始化就去做相加操作 字符数组未尾没加“\0”导致输出乱码 语法错误 代码逻辑出错 没看清要求 未添加对应的头文件如bool,memset 数组容量过小,溢出 用字符变量存储汉字 给printf中加了&导致输出乱码 未用strcmp而用"=="去比较字符数组 没重新初始化循环后的变量 ...

SeptDays的博客 464

《算法图解》是一本面向初学者的算法入门书籍,以通俗易懂的方式讲解了常见算法和数据结构的核心概念,并通过丰富的图示和实际例子帮助读者理解

算法图解》(原名 *Grokking Algorithms*,作者 Aditya Bhargava)是一本面向初学者的算法入门书籍,以通俗易懂的方式讲解了常见算法和数据结构的核心概念,并通过丰富的图示和实际例子帮助读者理解。就像你在超市排队,O(n) 是队伍越长你等得越久,O(log n) 是无论队伍多长,你很快就能结账。好的算法能让你用最少的时间和资源解决问题。你随便挑一张牌(比如 5),把比 5 小的放左边,比 5 大的放右边,然后对左右两堆再重复这个过程,直到每堆都只有一张牌,排序就完成了。

专注于前沿技术的探索与实践,热衷于从代码逻辑、架构设计到行业应用等多维度深挖技术本质。期待在技术之路上与你共同成长~ 562

大厂算法实习常见八股文,这些你都会吗?(已拿offer)大模型入门到精通,收藏这篇就足够了!

大厂算法实习常见八股文,这些你都会吗?(已拿offer)大模型入门到精通,收藏这篇就足够了!

huang9604的博客 1525
上一篇: linux常用命令
下一篇: hystrix原理及使用
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值