代码随想录——跟着Carl学算法

作者
孙秀洋
丛书名
出版社
电子工业出版社
ISBN
9787121423000
简要
简介
内容简介书籍计算机书籍 本书归纳了程序员面试中的经典算法题,并按照由浅入深、循序渐进的顺序讲解。本书首先讲解程序员面试时需要了解的制作简历的技巧和IT名企的面试流程,以及面试时经常忽略的代码规范性问题。然后详细分析程序的时间复杂度和空间复杂库,包括如何把控程序的实际运行时间,以及编程语言的内存管理。接着讲解数组、链表、哈希表、字符串、栈与队列、二叉树、回溯算法、贪心算法、动态规划的理论基础及其相关题目。本书采用了力扣(LeetCode)的原题,方便读者在学习算法的同时,及时练习相关代码,加深对相关概念的理解。本书适合所有程序员阅读,特别是正在准备面试的程序员。希望本书可以帮助读者循序渐进地学习算法,并搭建起知识框架,提升算法功力。
目录






第1章 准备面试要知己知彼\t1

1.1 面试官为什么要考查算法\t1

1.2 编程语言\t2

1.2.1 学好算法之前更要学好编程语言\t2

1.2.2 代码规范\t2

1.3 如何写简历\t5

1.3.1 简历模板\t5

1.3.2 谨慎使用“精通”\t5

1.3.3 拿不准的内容不要写在简历上\t5

1.3.4 项目经验应该如何写\t6

1.3.5 博客的重要性\t7

1.4 企业技术面试的流程\t7

1.4.1 一面——机试面\t7

1.4.2 二面——基础算法面\t8

1.4.3 三面——综合技术面\t8

1.4.4 四面——技术leader面\t8

1.4.5 五面——HR面\t9

1.5 本章小结\t10

第2章 程序的性能分析\t11

2.1 时间复杂度分析\t11

2.1.1 什么是时间复杂度\t11

2.1.2 如何描述时间复杂度\t12

2.1.3 递归算法的时间复杂度分析\t14

2.2 程序的运行时间\t17

2.2.1 超时是怎么回事\t17

2.2.2 从硬件配置看计算机的性能\t18

2.2.3 测试计算机的运行速度\t18

2.3 编程语言的内存管理\t20

2.3.1 C++的内存管理\t21

2.3.2 如何计算程序占用多少内存\t22

2.3.3 内存对齐\t22

2.4 空间复杂度分析\t24

2.4.1 什么是空间复杂度\t24

2.4.2 递归算法的空间复杂度分析\t25

2.4.3 以空间换时间是常见的优化思路\t32

2.5 本章小结\t33

第3章 数组\t34

3.1 数组理论基础\t34

3.2 二分查找\t36

3.2.1 二分法写法(一)\t37

3.2.2 二分法写法(二)\t38

3.3 移除元素\t39

3.3.1 暴力解法\t40

3.3.2 双指针法\t41

3.4 长度小的子数组\t42

3.4.1 暴力解法\t42

3.4.2 滑动窗口\t43

3.5 这个循环转懵了很多人\t45

3.5.1 循环不变量\t45

3.5.2 代码实现\t46

3.6 本章小结\t48

第4章 链表\t49

4.1 链表理论基础\t49

4.1.1 链表的类型\t49

4.1.2 链表的存储方式\t50

4.1.3 链表的定义\t51

4.1.4 链表的操作\t52

4.1.5 性能分析\t52

4.2 用虚拟头节点会方便得多\t53

4.3 链表常见的六个操作\t57

4.4 反转链表\t60

4.4.1 双指针法\t60

4.4.2 递归法\t61

4.5 删除倒数第n个节点\t62

4.6 环形链表\t64

4.6.1 判断链表是否有环\t65

4.6.2 寻找环的入口\t66

4.7 本章小结\t69

第5章 哈希表\t70

5.1 哈希表理论基础\t70

5.1.1 哈希函数\t71

5.1.2 哈希碰撞\t71

5.1.3 常见的三种哈希结构\t73

5.2 有效的字母异位词\t74

5.3 两个数组的交集\t76

5.4 两数之和\t78

5.5 四数相加\t80

5.6 三数之和\t81

5.6.1 哈希解法\t81

5.6.2 双指针法\t82

5.7 四数之和\t85

5.8 本章小结\t87

第6章 字符串\t88

6.1 字符串与数组的区别\t88

6.2 反转字符串\t89

6.3 反转字符串II\t90

6.4 反转字符串里的单词\t92

6.5 KMP算法理论基础\t96

6.5.1 什么是KMP算法\t96

6.5.2 什么是前缀表\t96

6.5.3 为什么一定要用前缀表\t97

6.5.4 如何计算前缀表\t98

6.5.5 时间复杂度分析\t100

6.6 使用KMP匹配字符串\t101

6.6.1 构造next数组\t101

6.6.2 使用next数组做匹配\t103

6.6.3 前缀表统一减一的代码实现\t104

6.6.4 前缀表(不减一)的代码实现\t105

6.7 找到重复的子字符串\t107

6.8 本章小结\t109

第7章 栈与队列\t110

7.1 栈与队列理论基础\t110

7.2 用栈组成队列\t112

7.3 用队列组成栈\t114

7.3.1 使用两个队列实现栈\t115

7.3.2 使用一个队列实现栈\t117

7.4 匹配括号\t118

7.5 逆波兰表达式\t120

7.6 滑动窗口值\t122

7.7 前k个高频元素\t126

7.8 接雨水\t129

7.8.1 双指针解法\t130

7.8.2 动态规划解法\t132

7.8.3 单调栈解法\t133

7.9 本章小结\t137

第8章 二叉树\t139

8.1 二叉树理论基础\t139

8.1.1 二叉树的种类\t139

8.1.2 二叉树的存储方式\t141

8.1.3 二叉树的遍历方式\t142

8.1.4 二叉树的定义\t143

8.2 前中后序的递归遍历\t144

8.3 前中后序的迭代遍历\t146

8.3.1 前序遍历\t146

8.3.2 中序遍历\t147

8.3.3 后序遍历\t148

8.4 前、中、后序统一迭代法\t149

8.5 二叉树的层序遍历\t152

8.6 反转二叉树\t155

8.6.1 递归法\t156

8.6.2 迭代法\t156

8.7 对称二叉树\t158

8.7.1 递归法\t159

8.7.2 迭代法\t162

8.8 二叉树的深度\t164

8.8.1 递归法\t165

8.8.2 迭代法\t166

8.9 二叉树的小深度\t167

8.9.1 递归法\t168

8.9.2 迭代法\t170

8.10 平衡二叉树\t170

8.10.1 递归法\t173

8.10.2 迭代法\t175

8.11 二叉树的所有路径\t176

8.11.1 递归法\t177

8.11.2 迭代法\t182

8.12 路径总和\t183

8.12.1 递归法\t183

8.12.2 迭代法\t186

8.12.3 路径总和II\t187

8.13 构造一棵二叉树\t189

8.13.1 使用中序与后序遍历序列构造二叉树\t189

8.13.2 使用前序与中序遍历序列构造二叉树\t195

8.13.3 相关思考\t197

8.14 合并两棵二叉树\t197

8.14.1 递归\t198

8.14.2 迭代法\t200

8.15 在二叉搜索树中寻找节点\t201

8.15.1 递归法\t202

8.15.2 迭代法\t203

8.16 验证二叉搜索树\t204

8.16.1 递归法\t205

8.16.2 迭代法\t207

8.17 二叉搜索树的小差\t208

8.17.1 递归法\t208

8.17.2 迭代法\t209

8.18 二叉搜索树中的众数\t210

8.18.1 递归法\t211

8.18.2 迭代法\t215

8.19 二叉树的近公共祖先\t216

8.19.1 普通二叉树\t216

8.19.2 二叉搜索树\t221

8.20 在二叉搜索树中插入一个节点\t224

8.20.1 递归法\t225

8.20.2 迭代法\t227

8.21 在二叉搜索树中删除一个节点\t228

8.21.1 递归法\t228

8.21.2 迭代法\t230

8.22 修剪二叉搜索树\t231

8.22.1 递归法\t232

8.22.2 迭代法\t234

8.23 构造一棵平衡二叉搜索树\t235

8.23.1 递归法\t236

8.23.2 迭代法\t238

8.24 本章小结\t239

第9章 回溯算法\t240

9.1 回溯算法理论基础\t240

9.1.1 什么是回溯算法\t240

9.1.2 回溯法的性能\t240

9.1.3 回溯法可以解决的问题\t240

9.1.4 如何理解回溯法\t241

9.1.5 回溯法模板\t241

9.2 组合问题\t243

9.2.1 回溯算法\t244

9.2.2 剪枝优化\t248

9.3 组合总和(一)\t250

9.3.1 回溯算法\t251

9.3.2 剪枝优化\t254

9.4 电话号码的字母组合\t255

9.5 组合总和(二)\t260

9.5.1 回溯算法\t261

9.5.2 剪枝优化\t263

9.6 组合总和(三)\t265

9.7 分割回文串\t270

9.8 复原IP地址\t274

9.9 子集问题(一)\t279

9.10 子集问题(二)\t281

9.11 递增子序列\t284

9.11.1 回溯算法\t285

9.11.2 哈希优化\t287

9.12 排列问题(一)\t288

9.13 排列问题(二)\t291

9.13.1 回溯算法\t291

9.13.2 拓展\t293

9.14 N皇后问题\t296

9.15 解数独\t301

9.15.1 回溯算法\t302

9.15.2 判断棋盘是否合法\t304

9.16 本章小结\t305

第10章 贪心算法\t306

10.1 贪心算法理论基础\t306

10.1.1 什么是贪心\t306

10.1.2 贪心的套路\t306

10.2 分发饼干\t307

10.3 摆动序列\t309

10.4 子序和\t312

10.5 买卖股票的时机II\t314

10.6 跳跃游戏\t316

10.7 跳跃游戏II\t318

10.7.1 贪心解法(一)\t320

10.7.2 贪心解法(二)\t320

10.8 加油站\t322

10.8.1 暴力解法\t323

10.8.2 贪心解法(一)\t324

10.8.3 贪心解法(二)\t325

10.9 分发糖果\t327

10.10 柠檬水找零\t330

10.11 用少数量的箭射爆气球\t332

10.12 合并区间\t335

10.13 单调递增的数字\t338

10.13.1 暴力解法\t338

10.13.2 贪心解法\t339

10.14 本章小结\t340

第11章 动态规划\t341

11.1 动态规划理论基础\t341

11.1.1 动态规划题目的解题步骤\t341

11.1.2 动态规划应该如何排查问题\t342

11.2 斐波那契数\t343

11.2.1 动态规划解法\t344

11.2.2 递归解法\t345

11.3 爬楼梯\t346

11.4 使用花费爬楼梯\t349

11.5 不同路径(一)\t353

11.5.1 深度优先搜索\t354

11.5.2 动态规划\t355

11.5.3 数论方法\t356

11.6 不同路径(二)\t358

11.7 整数拆分\t361

11.7.1 动态规划\t362

11.7.2 贪心算法\t364

11.8 不同的二叉搜索树\t364

11.9 0-1背包理论基础\t369

11.9.1 二维dp数组\t370

11.9.2 一维dp数组\t375

11.10 分割等和子集\t379

11.11 目标和\t382

11.12 一和零\t385

11.13 完全背包理论基础\t388

11.14 零钱兑换(一)\t392

11.15 拼凑一个正整数\t395

11.16 多步爬楼梯\t398

11.17 零钱兑换(二)\t399

11.18 完全平方数\t402

11.19 单词拆分\t405

11.19.1 回溯算法\t406

11.19.2 背包问题\t407

11.20 买卖股票的时机\t410

11.20.1 暴力枚举\t410

11.20.2 贪心算法\t411

11.20.3 动态规划\t411

11.21 买卖股票的时机II\t414

11.22 买卖股票的时机III\t416

11.23 买卖股票的时机IV\t420

11.24 买卖股票时机(含冷冻期)\t423

11.25 买卖股票的时机(含手续费)\t426

11.26 长递增子序列\t428

11.27 长连续递增序列\t430

11.27.1 动态规划\t430

11.27.2 贪心算法\t432

11.28 长重复子数组\t433

1

推荐

车牌查询
桂ICP备20004708号-3