北京大学 17门计算机课 160G 一次性分享给你

北京大学 17门计算机课 160G

├─c#程序设计 - 北京大学
│ ├─1 课前准备
│ │ ├─1.1 《C#程序设计》学习日历
│ │ ├─1.2 准备教材及热身活动
│ │ └─1.3 温馨提示：本课程不合适零基础的学员
│ ├─10 文本处理及正则表达式
│ │ ├─10.1 基于文本的应用
│ │ ├─10.2 正则表达式
│ │ └─10.3 第9讲小结
│ ├─11 网络信息获取及Xml处理
│ │ ├─11.1 网络信息获取的基本方法
│ │ ├─11.2 XML基本操作
│ │ ├─11.3 XPath及Xlst编辑教学内容
│ │ ├─11.4 大仕老师编写的一组示例
│ │ └─11.5 第10讲小结
│ ├─12 多线程与异步编程
│ │ ├─12.1 线程及其控制
│ │ ├─12.2 并行编程
│ │ ├─12.3 异步编程
│ │ └─12.4 第11讲小结
│ ├─13 访问数据库
│ │ ├─13.1 数据库基础知识
│ │ ├─13.2 ADO.NET
│ │ ├─13.3 访问数据库的方法
│ │ ├─13.4 数据库应用程序
│ │ └─13.5 第12讲小结
│ ├─14 深入理解C#语言
│ │ ├─14.1 类型与转换
│ │ ├─14.2 变量及其传递
│ │ ├─14.3 多态与虚方法调用
│ │ ├─14.4 动态类型确定
│ │ ├─14.5 对象构造与析构
│ │ ├─14.6 C#语言新特性
│ │ └─14.7 第13讲小结
│ ├─2 C#程序设计简介
│ │ ├─2.1 C#与.NET概述
│ │ ├─2.2 C#快速入门
│ │ ├─2.3 基本的应用类型
│ │ ├─2.4 基本输入与输出
│ │ └─2.5 第1讲小结
│ ├─3 C#语言基础
│ │ ├─3.1 数据类型、变量与常量 —— 语言中的单词
│ │ ├─3.2 运算符与表达式 —— 语言中的标点符号
│ │ ├─3.3 流程控制语句 —— 语言中的语句
│ │ ├─3.4 数组 —— 与C语言的数组大不同
│ │ ├─3.5 补充材料
│ │ └─3.6 第2讲小结
│ ├─4 面向对象的C#语言
│ │ ├─4.1 类、字段、方法 —— 面向对象那点事儿
│ │ ├─4.2 属性、索引 —— 访问字段能更优优雅吗
│ │ ├─4.3 类的继承 —— 富二代值得羡慕吗
│ │ ├─4.4 修饰符 —— 形容词有大作用
│ │ ├─4.5 接口 —— 我和她有个约定
│ │ ├─4.6 结构及枚举 —— 原来这就是值类型
│ │ └─4.7 第3讲小结
│ ├─5 C#语言高级特性
│ │ ├─5.1 委托 —— 函数也能当变量
│ │ ├─5.10 第4讲小结
│ │ ├─5.2 事件 —— 悄悄的告诉你
│ │ ├─5.3 Lambda表达式 —— 简洁到了极致
│ │ ├─5.4 运算符重载 —— 原来函数可以写成一个符号
│ │ ├─5.5 异常处理 —— 麻烦总有人帮着解决
│ │ ├─5.6 Attribute —— 微软都不会翻译的一个词
│ │ ├─5.7 C#语言中的其他成分 —— 学到这里C#语法就差不多了
│ │ ├─5.8 程序的组织 —— 不再只是单个类的程序
│ │ └─5.9 语法总结 —— C#主要就是类型及其成员
│ ├─6 基础类及常用算法
│ │ ├─6.1 DotNet基本类库 —— 要编程需要知道这些
│ │ ├─6.2 类型转换 —— 一切皆是类型
│ │ ├─6.3 数学、文字、日期 —— 最常用的类型
│ │ ├─6.4 数组、集合、泛型 —— 在这里真的见到索引器了
│ │ ├─6.5 第5讲小结
│ │ └─6.6 常用算法—— 遍试、迭代、递归
│ ├─7 流、文件
│ │ ├─7.1 IO及文件管理
│ │ ├─7.2 文件内容的读写
│ │ ├─7.3 补充：注册表操作
│ │ ├─7.4 第6讲小结
│ │ └─7.5 号外：程序的调试 —— 编程必不可少的手段
│ ├─8 Windows窗体与控件
│ │ ├─8.1 布局与事件 —— 界面的基本问题
│ │ ├─8.2 常用控件
│ │ ├─8.3 窗体
│ │ ├─8.4 菜单、工具栏、对话框
│ │ ├─8.5 用户控件
│ │ └─8.6 第7讲小结
│ └─9 绘图及图像
│ ├─9.1 绘图基础GDI+
│ ├─9.2 绘图对象及绘图方法
│ ├─9.3 一组漂亮的绘图示例
│ ├─9.4 控件的重绘及双缓冲
│ ├─9.5 图像处理
│ └─9.6 第8讲小结
├─Java程序设计 - 北京大学
│ ├─1 课前准备
│ │ ├─1.1 《Java程序设计》学习日历
│ │ ├─1.2 准备教材及热身活动
│ │ └─1.3 温馨提示：本课程不适合零基础的学员
│ ├─10 流、文件及基于文本的应用
│ │ ├─10.1 输入输出流
│ │ ├─10.2 文件及目录
│ │ ├─10.3 正则表达式
│ │ └─10.4 week9 小结
│ ├─11 图形用户界面
│ │ ├─11.1 组件
│ │ ├─11.2 实现界面的三步曲
│ │ ├─11.3 布局管理
│ │ ├─11.4 事件处理
│ │ ├─11.5 常用组件的使用
│ │ ├─11.6 Applet
│ │ └─11.7 week10 小结
│ ├─12 网络、多媒体和数据库编程
│ │ ├─12.1 网络编程
│ │ ├─12.2 多媒体编程
│ │ ├─12.3 数据库编程
│ │ └─12.4 week11 小结
│ ├─13 怎样写好程序
│ │ ├─13.1 写好程序的一些经验
│ │ ├─13.2 重构
│ │ ├─13.3 设计模式
│ │ ├─13.4 反射
│ │ └─13.5 week12 小结
│ ├─2 Java语言与面向对象的程序设计
│ │ ├─2.1 Java语言的历史与特点
│ │ ├─2.2 面向对象程序设计
│ │ └─2.3 week1 小结
│ ├─3 简单的Java程序
│ │ ├─3.1 Java程序的类型与基本构成
│ │ ├─3.2 开发Java程序的基本步骤
│ │ ├─3.3 程序中进行输入与输出
│ │ ├─3.4 Java开发工具
│ │ └─3.5 week2 小结
│ ├─4 数据运算、流控制和数组
│ │ ├─4.1 数据类型、变量与常量
│ │ ├─4.2 运算符与表达式
│ │ ├─4.3 流程控制语句
│ │ ├─4.4 数组
│ │ └─4.5 week3 小结
│ ├─5 类、包和接口
│ │ ├─5.1 类、字段、方法
│ │ ├─5.2 类的继承
│ │ ├─5.3 包
│ │ ├─5.4 访问控制符
│ │ ├─5.5 其他修饰符
│ │ ├─5.6 接口
│ │ ├─5.7 语法小结
│ │ └─5.8 week4 小结
│ ├─6 深入理解Java语言
│ │ ├─6.1 变量及其传递
│ │ ├─6.2 多态及虚方法调用
│ │ ├─6.3 对象构造与初始化
│ │ ├─6.4 对象清除与垃圾回收
│ │ ├─6.5 内部类与匿名类
│ │ ├─6.6 Lambda表达式（＊）
│ │ ├─6.7 其他几个高级语法(＊)
│ │ ├─6.8 没有指针的Java语言
│ │ └─6.9 week5 小结
│ ├─7 异常处理
│ │ ├─7.1 异常处理
│ │ ├─7.2 自定义异常
│ │ ├─7.3 断言及程序的测试
│ │ ├─7.4 程序的调试
│ │ └─7.5 week6 小结
│ ├─8 工具类及常用算法
│ │ ├─8.1 Java语言基础类
│ │ ├─8.2 字符串及日期
│ │ ├─8.3 集合
│ │ ├─8.4 排序与查找
│ │ ├─8.5 泛型(＊)
│ │ ├─8.6 常用算法
│ │ └─8.7 week7 小结
│ └─9 多线程
│ ├─9.1 线程的创建
│ ├─9.2 线程的控制
│ ├─9.3 线程的同步（＊）
│ ├─9.4 并发API
│ ├─9.5 流式操作及并行流（＊）
│ └─9.6 week8 小结
├─Python语言基础与应用 - 北京大学
│ ├─1 引子(51min)
│ │ ├─1.1 课程1 我们为什么要学习编程？(20min)
│ │ ├─1.2 课程2 程序是什么？如何用计算思维解决问题？(17min)
│ │ └─1.3 课程3 Python语言的历史和现状(14min)
│ ├─2 Python语言介绍与概览(94min)
│ │ ├─2.1 课程4 Python语言运行环境（Windows／macOS／Linux）(9min)
│ │ ├─2.2 课程5 第一个Python程序(9min)
│ │ ├─2.3 课程6 集成开发工具PyCharm(13min)
│ │ ├─2.4 课程7 上机练习：体验Python程序(9min)
│ │ ├─2.5 课程8 Python程序设计风格(17min)
│ │ ├─2.6 课程9 数据对象及其组织(17min)
│ │ ├─2.7 课程10 计算和控制流(17min)
│ │ ├─2.8 视频教程：面向初学者的Python编程工具：Thonny
│ │ └─2.9 视频教程：怎么做慕课Python在线评测OJ作业
│ ├─3 数据类型（一）(84min)
│ │ ├─3.1 课程11 基本类型：数值（int／float／complex）(25min)
│ │ ├─3.2 课程12 基本类型：逻辑值（bool）(13min)
│ │ ├─3.3 课程13 基本类型：字符串（str）(25min)
│ │ ├─3.4 课程14 变量和引用(11min)
│ │ └─3.5 课程15 上机练习：基本数据类型(9min)
│ ├─4 数据类型（二）（105min）
│ │ ├─4.1 课程16 容器类型：列表和元组（list／tuple）(21min)
│ │ ├─4.2 课程17 容器类型：字典（dict）(22min)
│ │ ├─4.3 课程18 容器类型：集合（set）(17min)
│ │ ├─4.4 课程19 可变类型和不可变类型(13min)
│ │ ├─4.5 课程20 建立复杂的数据结构(8min)
│ │ ├─4.6 课程21 输入和输出（input／print）(17min)
│ │ └─4.7 课程22 上机练习：容器类型操作（5min）
│ ├─5 计算和控制流（一）（70min）
│ │ ├─5.1 课程23 自动计算过程（10min）
│ │ ├─5.2 课程24 控制流程（10min）
│ │ ├─5.3 课程25 控制流：条件分支语句（if）（11min）
│ │ ├─5.4 课程26 控制流：条件循环（while）（17min）
│ │ ├─5.5 课程27 控制流：迭代循环（for）（16min）
│ │ └─5.6 课程28 上机练习：基本的计算程序（4min）
│ ├─6 计算和控制流（二）（63min）
│ │ ├─6.1 课程29 代码组织：函数（def）（21min）
│ │ ├─6.2 课程30 代码组织：函数的参数（12min）
│ │ ├─6.3 课程31 上机练习：创建并调用函数（4min）
│ │ └─6.4 课程32 引用扩展模块（25min）
│ ├─7 基本扩展模块（118min）
│ │ ├─7.1 课程33 datetime模块
│ │ ├─7.10 课程42 上机练习：简单绘图
│ │ ├─7.2 课程34 calendar模块
│ │ ├─7.3 课程35 time模块
│ │ ├─7.4 课程36 几个算术模块
│ │ ├─7.5 课程37 持久化模块
│ │ ├─7.6 课程38 文件文本读写模块
│ │ ├─7.7 课程39 上机练习：计时和文件处理
│ │ ├─7.8 课程40 简单的图形界面模块
│ │ └─7.9 课程41 海龟作图
│ ├─8 高级特性（一）：面向对象（78min）
│ │ ├─8.1 课程43 面向对象：什么是对象？
│ │ ├─8.2 课程44 面向对象：类的定义与调用
│ │ ├─8.3 课程45 面向对象：类定义中的特殊方法
│ │ ├─8.4 课程46 自定义对象的排序
│ │ ├─8.5 课程47 面向对象：类的继承
│ │ └─8.6 课程48 上机练习：类和对象
│ └─9 高级特性（二）与高级扩展模块（112min）
│ ├─9.1 课程49 例外处理
│ ├─9.2 课程50 推导式
│ ├─9.3 课程51 生成器函数
│ ├─9.4 课程52 上机练习：生成器
│ ├─9.5 课程53 图像处理库（PIL)
│ ├─9.6 课程54 Web服务框架（Flask）
│ ├─9.7 课程55 网络爬虫（requests, Beautiful Soup）
│ ├─9.8 课程56 数据可视化（matplotlib）
│ └─9.9 课程57 上机练习：高级扩展模块应用
├─人工智能与信息社会 - 北京大学
│ ├─1 1新闻热点与身边的人工智能(68min)
│ │ ├─1.1 101家庭助手(8min)
│ │ ├─1.2 102机器翻译(9min)
│ │ ├─1.3 103图像识别(9min)
│ │ ├─1.4 104下棋高手(13min)
│ │ ├─1.5 105自动驾驶(7min)
│ │ ├─1.6 106医疗健康(8min)
│ │ ├─1.7 107金融与商业(12min)
│ │ ├─1.8 108微软亚洲研究院院长洪小文博士寄语计算机教育(2min)
│ │ └─1.9 109人工智能改变世界：微软新视界Center One（3min）
│ ├─2 2人工智能发展简史(73min)
│ │ ├─2.1 201什么是人工智能(10min)
│ │ ├─2.2 202人工智能经典问题(10min)
│ │ ├─2.3 203第一次热潮(12min)
│ │ ├─2.4 204第二次热潮(11min)
│ │ ├─2.5 205第三次热潮(15min)
│ │ ├─2.6 206人工智能发展状况(14min)
│ │ └─2.7 微软亚研院刘铁岩副院长访谈：人工智能发展简史(52min)
│ ├─3 3基于决策树和搜索的智能系统（上）(65min)
│ │ ├─3.1 301实例1读心术(9min)
│ │ ├─3.2 302和人类一样的判断方式(13min)
│ │ ├─3.3 303专家系统应用与发展(12min)
│ │ ├─3.4 304实例2井字棋(11min)
│ │ ├─3.5 305博弈树(20min)
│ │ └─3.6 实例1读心术代码运行及说明
│ ├─4 3基于决策树和搜索的智能系统（下）(72min)
│ │ ├─4.1 306估值决策(18min)
│ │ ├─4.2 307最大最小值法(15min)
│ │ ├─4.3 308AlphaBeta剪枝(13min)
│ │ ├─4.4 309启发式算法(11min)
│ │ ├─4.5 310从国际象棋到围棋(15min)
│ │ └─4.6 实例2井字棋代码运行及说明
│ ├─5 4基于仿生算法的智能系统(63min)
│ │ ├─5.1 401仿生算法简介(14min)
│ │ ├─5.2 402基因遗传算法(16min)
│ │ ├─5.3 403实例3拼图游戏(6min)
│ │ ├─5.4 404拼图的基因(7min)
│ │ ├─5.5 405遗传和变异(10min)
│ │ ├─5.6 406自然选择(10min)
│ │ └─5.7 实例3基因遗传算法代码运行及说明
│ ├─6 5基于神经网络的智能系统I (62min)
│ │ ├─6.1 501神经元与神经网络(12min)
│ │ ├─6.2 502实例4手写数字识别(9min)
│ │ ├─6.3 503网络构建(13min)
│ │ ├─6.4 504计算损失函数(8min)
│ │ ├─6.5 505优化器优化函数(10min)
│ │ ├─6.6 506反向传播(10min)
│ │ └─6.7 实例4手写数字识别代码运行及说明
│ ├─7 6基于神经网络的智能系统II (79min)
│ │ ├─7.1 601监督学习和非监督学习(16min)
│ │ ├─7.2 602让人工智能学会玩游戏(12min)
│ │ ├─7.3 603试错式学习(7min)
│ │ ├─7.4 604状态动作回报(9min)
│ │ ├─7.5 605价值判断Q函数(12min)
│ │ ├─7.6 606尝遍百草(9min)
│ │ ├─7.7 607熟能生巧(11min)
│ │ └─7.8 实例5FlappyBird代码运行及说明
│ ├─8 7人工智能应用 (123min)
│ │ ├─8.1 701图像识别与分类(10min)
│ │ ├─8.2 702医学影像分析(12min)
│ │ ├─8.3 微软亚研院张益肇副院长访谈：人工智能应用 医疗+AI(26min)
│ │ ├─8.4 706语音识别(12min)
│ │ ├─8.5 707人脸识别和情感计算(13min)
│ │ ├─8.6 微软亚研院周明副院长访谈：人工智能应用 自然语言处理(37min)
│ │ └─8.7 711自动驾驶(12min)
│ └─9 8人工智能与人类社会未来
│ ├─9.1 801挑战-技术视角(9min)
│ ├─9.2 802挑战-人文视角(12min)
│ ├─9.3 803伦理规范-社会层面(14min)
│ ├─9.4 804伦理规范-公共政策(10min)
│ ├─9.5 微软亚研院潘天佑副院长访谈：人工智能与人类关系(50min)
│ ├─9.6 808科幻作品中的人工智能(23min)
│ └─9.7 809奇点理论-畅想未来(16min)
├─人工智能原理 - 北京大学
│ ├─1 Part I. Basics：Chapter 1. Introduction
│ │ ├─1.1 Overview of Artificial Intelligence
│ │ ├─1.2 Foundations of Artificial Intelligence
│ │ ├─1.3 History of Artificial Intelligence
│ │ ├─1.4 The State of The Art
│ │ └─1.5 Summary
│ ├─10 Part V. Learning：Chapter 10. Tasks in Machine Learning
│ │ ├─10.1 Classification
│ │ ├─10.2 Regression
│ │ ├─10.3 Clustering
│ │ ├─10.4 Ranking
│ │ ├─10.5 Dimensionality Reduction
│ │ └─10.6 Summary
│ ├─11 Part V. Learning：Chapter 11. Paradigms in Machine Learning
│ │ ├─11.1 Supervised Learning Paradigm
│ │ ├─11.2 Unsupervised Learning Paradigm
│ │ ├─11.3 Reinforcement Learning Paradigm
│ │ ├─11.4 Other Learning Paradigms
│ │ └─11.5 Summary
│ ├─12 Part V. Learning：Chapter 12. Models in Machine Learning
│ │ ├─12.1 Probabilistic Models
│ │ ├─12.2 Geometric Models
│ │ ├─12.3 Logical Models
│ │ ├─12.4 Networked Models
│ │ └─12.5 Summary
│ ├─2 Part I. Basics：Chapter 2. Intelligent Agent
│ │ ├─2.1 Approaches for Artificial Intelligence
│ │ ├─2.2 Rational Agents
│ │ ├─2.3 Task Environments
│ │ ├─2.4 Intelligent Agent Structure
│ │ ├─2.5 Category of Intelligent Agents
│ │ └─2.6 Summary
│ ├─3 Part II. Searching：Chapter 3. Solving Problems by Search
│ │ ├─3.1 Problem Solving Agents
│ │ ├─3.2 Example Problems
│ │ ├─3.3 Searching for Solutions
│ │ ├─3.4 Uninformed Search Strategies
│ │ ├─3.5 Informed Search Strategies
│ │ ├─3.6 Heuristic Functions
│ │ └─3.7 Summary
│ ├─4 Part II. Searching：Chapter 4. Local Search and Swarm Intelligence
│ │ ├─4.1 Overview
│ │ ├─4.2 Local Search Algorithms
│ │ ├─4.3 Optimization and Evolutionary Algorithms
│ │ ├─4.4 Swarm Intelligence and Optimization
│ │ └─4.5 Summary
│ ├─5 Part II. Searching：Chapter 5. Adversarial Search
│ │ ├─5.1 Games
│ │ ├─5.2 Optimal Decisions in Games
│ │ ├─5.3 Alpha-Beta Pruning
│ │ ├─5.4 Imperfect Real-time Decisions
│ │ ├─5.5 Stochastic Games
│ │ ├─5.6 Monte-Carlo Methods
│ │ └─5.7 Summary
│ ├─6 Part II. Searching：Chapter 6. Constraint Satisfaction Problem
│ │ ├─6.1 Constraint Satisfaction Problems (CSPs)
│ │ ├─6.2 Constraint Propagation：Inference in CSPs
│ │ ├─6.3 Backtracking Search for CSPs
│ │ ├─6.4 Local Search for CSPs
│ │ ├─6.5 The Structure of Problems
│ │ └─6.6 Summary
│ ├─7 Part III. Reasoning：Chapter 7. Reasoning by Knowledge
│ │ ├─7.1 Overview
│ │ ├─7.2 Knowledge Representation
│ │ ├─7.3 Representation using Logic
│ │ ├─7.4 Ontological Engineering
│ │ ├─7.5 Bayesian Networks
│ │ └─7.6 Summary
│ ├─8 Part IV. Planning：Chapter 8. Classic and Real-world Planning
│ │ ├─8.1 Planning Problems
│ │ ├─8.2 Classic Planning
│ │ ├─8.3 Planning and Scheduling
│ │ ├─8.4 Real-World Planning
│ │ ├─8.5 Decision-theoretic Planning
│ │ └─8.6 Summary
│ └─9 Part V. Learning：Chapter 9. Perspectives about Machine Leaning
│ ├─9.1 What is Machine Learning
│ ├─9.2 History of Machine Learning
│ ├─9.3 Why Different Perspectives
│ ├─9.4 Three Perspectives on Machine Learning
│ ├─9.5 Applications and Terminologies
│ └─9.6 Summary
├─人工智能实践：Tensorflow笔记 - 北京大学
│ ├─1 神经网络计算
│ │ ├─1.1 人工智能三学派
│ │ ├─1.10 PPT：第一讲神经网络计算
│ │ ├─1.2 神经网络设计过程
│ │ ├─1.3 张量生成
│ │ ├─1.4 TF2常用函数1
│ │ ├─1.5 TF2常用函数2
│ │ ├─1.6 鸢尾花数据集读入
│ │ ├─1.7 神经网络实现鸢尾花分类
│ │ ├─1.8 Tensorflow2安装
│ │ └─1.9 TensorFlow笔记：第一讲神经网络计算
│ ├─5 神经网络优化
│ │ ├─5.1 预备知识
│ │ ├─5.2 复杂度学习率
│ │ ├─5.3 激活函数
│ │ ├─5.4 损失函数
│ │ ├─5.5 缓解过拟合
│ │ ├─5.6 优化器
│ │ ├─5.7 TensorFlow笔记：第二讲神经网络优化
│ │ └─5.8 PPT：第二讲神经网络优化
│ ├─6 神经网络八股
│ │ ├─6.1 搭建网络八股sequential
│ │ ├─6.2 搭建网络八股class
│ │ ├─6.3 MNIST数据集
│ │ ├─6.4 FASHION数据集
│ │ ├─6.5 TensorFlow笔记：第三讲神经网络八股
│ │ └─6.6 PPT：第三讲神经网络八股
│ ├─7 网络八股扩展
│ │ ├─7.1 搭建网络八股总览
│ │ ├─7.2 自制数据集
│ │ ├─7.3 数据增强
│ │ ├─7.4 断点续训
│ │ ├─7.5 参数提取
│ │ ├─7.6 acc&loss可视化
│ │ ├─7.7 给图识物
│ │ ├─7.8 TensorFlow笔记：第四讲网络八股扩展
│ │ └─7.9 PPT：第四讲网络八股扩展
│ ├─8 卷积神经网络
│ │ ├─8.1 卷积计算过程
│ │ ├─8.10 卷积神经网络搭建示例
│ │ ├─8.11 LeNet
│ │ ├─8.12 AlexNet
│ │ ├─8.13 VGGNet
│ │ ├─8.14 InceptionNet
│ │ ├─8.15 ResNet
│ │ ├─8.16 经典卷及网络小结
│ │ ├─8.17 TensorFlow笔记：第五讲卷积神经网络
│ │ ├─8.18 PPT：第五讲卷积神经网络
│ │ ├─8.2 感受野
│ │ ├─8.3 全零填充
│ │ ├─8.4 TF描述卷积计算层
│ │ ├─8.5 批标准化
│ │ ├─8.6 池化
│ │ ├─8.7 舍弃
│ │ ├─8.8 卷积神经网络
│ │ └─8.9 CIFAR0数据集
│ └─9 循环神经网络
│ ├─9.1 循环核
│ ├─9.10 字母预测Embedding_1pre1
│ ├─9.11 字母预测Embedding_4pre1
│ ├─9.12 RNN实现股票预测
│ ├─9.13 LSTM实现股票预测(LSTM计算过程TF描述LSTM层)
│ ├─9.14 GRU实现股票预测(GRU计算过程TF描述GRU层)
│ ├─9.15 TensorFlow笔记：第六讲循环神经网络
│ ├─9.16 PPT：第六讲循环神经网络
│ ├─9.2 循环核时间步展开
│ ├─9.3 循环计算层
│ ├─9.4 TF描述循环计算层
│ ├─9.5 循环计算过程I
│ ├─9.6 字母预测onehot_1pre1
│ ├─9.7 循环计算过程II
│ ├─9.8 字母预测onehot_4pre1
│ └─9.9 Embedding编码
├─实用Python程序设计 - 北京大学
│ ├─1 Python初探(视频总长约1小时27分)
│ │ ├─1.1 Python语言来历
│ │ ├─1.10 第一周讲义
│ │ ├─1.11 第一周测验提示
│ │ ├─1.2 Python的开发环境搭建
│ │ ├─1.3 Python语言的基本要素
│ │ ├─1.4 初步认识字符串
│ │ ├─1.5 字符串和数的转换
│ │ ├─1.6 最简单的输入输出
│ │ ├─1.7 初步认识列表
│ │ ├─1.8 在OpenJudge完成作业和考试必读
│ │ └─1.9 习题边写边说
│ ├─10 玩转Python生态（视频总长1小时34分)
│ │ ├─10.1 Python库的安装和使用
│ │ ├─10.10 ★★ 图像的素描化
│ │ ├─10.11 ★★★ 为图像添加水印
│ │ ├─10.12 第十周讲义
│ │ ├─10.13 ★★ 自觉训练：图像翻转和加文字
│ │ ├─10.14 ★ 自觉训练：excel文档处理
│ │ ├─10.2 用datetime库处理日期、时间
│ │ ├─10.3 用random库处理随机数相关事务
│ │ ├─10.4 用jieba库进行分词和中文词频统计
│ │ ├─10.5 ★ 用openpyxl库读取excel文档
│ │ ├─10.6 ★ 用openpyxl库创建excel文档
│ │ ├─10.7 ★★ 用openpyxl库设定excel文档单元格样式
│ │ ├─10.8 ★★ 图像基本常识和用Pillow库缩放图像
│ │ └─10.9 ★★ 图像的旋转、滤镜和裁剪
│ ├─11 数据分析和展示(视频总长约1小时26分)
│ │ ├─11.1 numpy库的使用
│ │ ├─11.10 用matplotlib绘制雷达图
│ │ ├─11.11 ★★ matplotlib多子图绘图
│ │ ├─11.12 第十一周讲义：numpy库和pandas库
│ │ ├─11.13 第十一周讲义：matplotlib绘图
│ │ ├─11.14 ★ 自觉训练：绘制词云
│ │ ├─11.2 数据分析库pandas基础
│ │ ├─11.3 ★ 数据分析库pandas提高
│ │ ├─11.4 ★ 用pandas读写excel文档
│ │ ├─11.5 用matplotlib绘制基础直方图
│ │ ├─11.6 ★ 用matplotlib绘制堆叠直方图
│ │ ├─11.7 ★ 用matplotlib绘制多组对比直方图
│ │ ├─11.8 用matplotlib绘制散点图和折线图
│ │ └─11.9 用matplotlib绘制饼图和热力图
│ ├─12 ★ 第十二章 网络爬虫设计(视频总长约2小时2分)
│ │ ├─12.1 ★ 爬虫的基本原理：爬取百度图片搜索结果
│ │ ├─12.10 ★★ 自觉训练：爬取Openjudge所有提交过的程序
│ │ ├─12.11 ★★ 自觉训练：爬取京东购物订单
│ │ ├─12.12 ★★★ 自觉训练：爬虫和数据库作业
│ │ ├─12.2 ★ 用requests、pyppeteer或selenium获取网页
│ │ ├─12.3 ★ 用beautifulsoup分析网页
│ │ ├─12.4 ★ 实例：用pyppeteer爬取每日股票交易信息
│ │ ├─12.5 ★★ 用pyppeteer编写需要登录的爬虫：原理
│ │ ├─12.6 ★★ 用pyppeteer编写需要登录的爬虫：实现
│ │ ├─12.7 ★★★ pyppeteer+requests编写高速爬虫
│ │ ├─12.8 ★ 爬虫编写注意事项
│ │ └─12.9 第十二章讲义
│ ├─13 面向对象程序设计(视频总长约1小时5分)
│ │ ├─13.1 类和对象的概念
│ │ ├─13.2 ★★ 2. 对象的比较
│ │ ├─13.3 ★★ 3. 继承和派生
│ │ ├─13.4 ★★ 4. 静态属性和静态方法
│ │ ├─13.5 ★★ 5. 对象作为集合元素和字典的键
│ │ └─13.6 第十三章讲义
│ ├─14 ★ 第十四章 tkinter图形界面程序设计(视频总长1小时45分)
│ │ ├─14.1 ★ 控件概述
│ │ ├─14.10 第十四周程序源码
│ │ ├─14.2 ★ 布局基础
│ │ ├─14.3 ★★ 使用Frame进行复杂布局
│ │ ├─14.4 ★ 控件属性和事件响应
│ │ ├─14.5 ★★ 实例：Python火锅店点菜系统
│ │ ├─14.6 ★ 实例：通过简单文本编辑器掌握菜单和多行编辑框
│ │ ├─14.7 ★ 对话框
│ │ ├─14.8 ★★★ 实例：在图形界面上显示图像、用matplotlib绘图
│ │ └─14.9 第十四周讲义
│ ├─2 基本运算、条件分支和输出格式控制(视频总长约1小时28分)
│ │ ├─2.1 算术运算
│ │ ├─2.2 比较运算和逻辑运算
│ │ ├─2.3 条件分支语句
│ │ ├─2.4 条件分支例题
│ │ ├─2.5 输出格式控制
│ │ ├─2.6 习题边写边说
│ │ ├─2.7 第二周讲义
│ │ └─2.8 第二周测验提示
│ ├─3 循环语句(视频总长约1小时28分)
│ │ ├─3.1 for 循环语句
│ │ ├─3.2 for 循环简单例题
│ │ ├─3.3 while循环语句
│ │ ├─3.4 异常处理
│ │ ├─3.5 循环综合例题
│ │ ├─3.6 习题边写边说
│ │ ├─3.7 第三周讲义
│ │ └─3.8 第三周测验提示
│ ├─4 函数和递归(视频总长约1小时28分)
│ │ ├─4.1 函数的概念和用法
│ │ ├─4.2 什么是递归
│ │ ├─4.3 递归例题：上台阶
│ │ ├─4.4 ★ 递归例题：汉诺塔
│ │ ├─4.5 ★ 递归例题：雪花曲线
│ │ ├─4.6 习题边写边说
│ │ ├─4.7 第四周讲义
│ │ └─4.8 自觉训练：奇异三角形
│ ├─5 字符串和元组(视频总长约1小时34分)
│ │ ├─5.1 Python变量的指针本质
│ │ ├─5.10 习题边写边说：石头剪刀布
│ │ ├─5.11 第五周讲义
│ │ ├─5.12 第五周测验提示
│ │ ├─5.2 字符串的转义字符
│ │ ├─5.3 字符串的切片（子串）
│ │ ├─5.4 ★ 字符串的分割
│ │ ├─5.5 字符串的函数
│ │ ├─5.6 字符串的格式化
│ │ ├─5.7 元组
│ │ ├─5.8 实例：万年历
│ │ └─5.9 习题边写边说：字符串例题
│ ├─6 列表(视频总长约1小时34分)
│ │ ├─6.1 列表的操作
│ │ ├─6.10 习题边写边说：成绩排序
│ │ ├─6.11 ★ 习题边写边说：图像模糊处理
│ │ ├─6.12 第六周讲义
│ │ ├─6.13 第六周测验提示
│ │ ├─6.2 列表应用例题：校门外的树
│ │ ├─6.3 列表的朴素排序
│ │ ├─6.4 用排序函数对简单列表排序
│ │ ├─6.5 复杂列表的自定义排序
│ │ ├─6.6 列表相关函数
│ │ ├─6.7 ★ 列表生成式
│ │ ├─6.8 ★ 二维列表
│ │ └─6.9 ★ 列表的拷贝和转换
│ ├─7 字典和集合(视频总长约56分钟)
│ │ ├─7.1 字典的基本概念
│ │ ├─7.2 字典相关函数
│ │ ├─7.3 字典例题：词频统计
│ │ ├─7.4 集合
│ │ ├─7.5 ★ 程序或算法的时间复杂度
│ │ ├─7.6 习题边写边说
│ │ ├─7.7 第七周讲义
│ │ └─7.8 第七周测验提示
│ ├─8 文件读写和文件夹操作和数据库(视频总长约1小时44分)
│ │ ├─8.1 文本文件的读写
│ │ ├─8.10 ★★ 创建sqlite3数据库
│ │ ├─8.11 ★★ 数据库的查询和修改
│ │ ├─8.12 ★★★ 数据库二进制字段处理
│ │ ├─8.13 第八周讲义：文件读写和文件夹操作
│ │ ├─8.14 第八周讲义：数据库编程
│ │ ├─8.2 文本文件的编码
│ │ ├─8.3 文件的路径
│ │ ├─8.4 ★ 文件夹操作
│ │ ├─8.5 ★ 命令行参数
│ │ ├─8.6 ★ 文件处理实例：词频统计
│ │ ├─8.7 ★ 文件处理实例：改进的词频统计
│ │ ├─8.8 ★ 词频统计实例源代码和数据
│ │ └─8.9 ★★ 数据库和SQL语言简介
│ └─9 ★ 第九章 正则表达式（视频总长约1小时46分)
│ ├─9.1 ★ 正则表达式的概念和组成
│ ├─9.10 第九周讲义
│ ├─9.2 ★ 字符范围和量词
│ ├─9.3 ★ 正则表达式的函数
│ ├─9.4 ★ 边界符号
│ ├─9.5 ★ 分组
│ ├─9.6 ★ ｜ 的用法
│ ├─9.7 ★ 贪婪匹配模式和懒惰匹配模式
│ ├─9.8 ★ 匹配对象的函数
│ └─9.9 ★ 应用实例：诸葛亮口中的曹操
├─数据结构与算法 - 北京大学
│ ├─1 概论
│ │ ├─1.1 课程介绍
│ │ ├─1.10 教材勘误和源代码
│ │ ├─1.2 问题求解
│ │ ├─1.3 数据结构与抽象数据类型
│ │ ├─1.4 算法特性及分类
│ │ ├─1.5 算法效率与度量
│ │ ├─1.6 补充 面向对象简介（选修）
│ │ ├─1.7 补充 类的特殊成员（选修）
│ │ ├─1.8 补充 模版函数与模版类（选修）
│ │ └─1.9 补充 输入输出流（选修）
│ ├─10 检索
│ │ ├─10.1 检索的概念
│ │ ├─10.2 基于线性表的检索
│ │ ├─10.3 集合的检索
│ │ ├─10.4 散列表的概念和散列函数
│ │ ├─10.5 散列冲突处理
│ │ └─10.6 散列的实现及性能分析
│ ├─11 索引
│ │ ├─11.1 静态索引
│ │ ├─11.2 倒排索引
│ │ ├─11.3 B 树
│ │ ├─11.4 B+ 树
│ │ ├─11.5 位索引技术
│ │ └─11.6 红黑树
│ ├─12 高级数据结构（上）
│ │ ├─12.1 多维数组
│ │ ├─12.2 广义表
│ │ └─12.3 存储管理
│ ├─13 高级数据结构（下）
│ │ ├─13.1 Trie 树
│ │ ├─13.2 AVL 树
│ │ └─13.3 Splay 树
│ ├─2 线性表
│ │ ├─2.1 线性结构
│ │ ├─2.2 顺序表
│ │ ├─2.3 链表
│ │ └─2.4 顺序表和链表的比较
│ ├─3 栈与队列
│ │ ├─3.1 栈
│ │ ├─3.2 栈与递归
│ │ ├─3.3 递归转非递归
│ │ ├─3.4 队列
│ │ └─3.5 队列的应用
│ ├─4 字符串
│ │ ├─4.1 字符串基本概念
│ │ ├─4.2 字符串的存储结构
│ │ ├─4.3 字符串运算的算法实现
│ │ └─4.4 字符串的快速模式匹配
│ ├─5 二叉树
│ │ ├─5.1 二叉树的概念
│ │ ├─5.2 二叉树的抽象数据结构
│ │ ├─5.3 二叉树的搜索
│ │ ├─5.4 二叉树的存储结构
│ │ ├─5.5 二叉搜索树
│ │ ├─5.6 堆与优先队列
│ │ └─5.7 Huffman树及其应用
│ ├─6 树
│ │ ├─6.1 树的定义、树与二叉树的等价转换
│ │ ├─6.2 树的抽象数据结构及树的遍历
│ │ ├─6.3 树的链式存储结构
│ │ ├─6.4 树的父指针表示法
│ │ └─6.5 树的顺序存储和K叉树
│ ├─7 图
│ │ ├─7.1 图的概念和抽象数据类型
│ │ ├─7.2 图的存储结构
│ │ ├─7.3 图的遍历
│ │ ├─7.4 最短路径
│ │ └─7.5 最小生成树
│ ├─8 内排序
│ │ ├─8.1 排序问题的基本概念
│ │ ├─8.10 排序算法的时间代价
│ │ ├─8.2 插入排序（Shell 排序）
│ │ ├─8.3 选择排序（堆排序）
│ │ ├─8.4 交换排序（冒泡排序、快速排序）
│ │ ├─8.5 归并排序
│ │ ├─8.6 桶排序
│ │ ├─8.7 基于静态链的基数排序
│ │ ├─8.8 链式基数排序
│ │ └─8.9 索引排序
│ └─9 外排序
│ ├─9.1 主存储器和外存储器
│ ├─9.2 文件的组织和管理
│ └─9.3 外排序
├─数据结构与算法Python版 - 北京大学
│ ├─1 概述
│ │ ├─1.1 引子：数据时代 9m53s
│ │ ├─1.2 问题求解的计算之道 12m20s
│ │ ├─1.3 图灵机计算模型 14m49s
│ │ ├─1.4 算法和计算复杂性 14m28s
│ │ ├─1.5 突破计算极限 9m08s
│ │ ├─1.6 什么是抽象和实现 9m00s
│ │ ├─1.7 为什么研究数据结构与算法 10m02s
│ │ └─1.8 从C转换到Python
│ ├─10 树及算法（下）
│ │ ├─10.1 二叉查找树及操作 8m59s
│ │ ├─10.2 二叉查找树实现及算法分析（上） 11m55s
│ │ ├─10.3 二叉查找树实现及算法分析（下） 14m39s
│ │ ├─10.4 AVL树的定义和性能 7m08s
│ │ ├─10.5 AVL树的Python实现 20m04s
│ │ └─10.6 树结构小结 7m39s
│ ├─11 图及算法（上）
│ │ ├─11.1 图的基本概念及相关术语 11m51s
│ │ ├─11.2 图抽象数据类型 5m57s
│ │ ├─11.3 图抽象数据类型的Python实现 5m26s
│ │ ├─11.4 图的应用：词梯问题 8m20s
│ │ ├─11.5 实现广度优先搜索 15m07s
│ │ ├─11.6 图的应用：骑士周游问题 6m37s
│ │ ├─11.7 骑士周游问题算法实现 7m56s
│ │ └─11.8 骑士周游问题算法分析与改进 8m45s
│ ├─12 图及算法（下）
│ │ ├─12.1 通用的深度优先搜索 10m27s
│ │ ├─12.2 图的应用：拓扑排序 9m30s
│ │ ├─12.3 图的应用：强连通分支 11m16s
│ │ ├─12.4 图的应用：最短路径 16m54s
│ │ ├─12.5 图的应用：最小生成树 12m08s
│ │ └─12.6 图结构小结 6m33s
│ ├─2 算法分析
│ │ ├─2.1 什么是算法分析 16m49s
│ │ ├─2.2 大O表示法 13m06s
│ │ ├─2.3 “变位词”判断问题（上） 10m27s
│ │ ├─2.4 “变位词”判断问题（下） 9m54s
│ │ ├─2.5 Python数据类型的性能（上） 12m37s
│ │ ├─2.6 Python数据类型的性能（下） 10m18s
│ │ └─2.7 怎么做慕课Python在线评测OJ作业
│ ├─3 基本结构（上）
│ │ ├─3.1 什么是线性结构 6m59s
│ │ ├─3.2 栈抽象数据类型及Python实现 10m14s
│ │ ├─3.3 栈的应用：简单括号匹配 11m19s
│ │ ├─3.4 栈的应用：十进制转换为二进制 9m34s
│ │ ├─3.5 表达式转换（上） 11m24s
│ │ ├─3.6 表达式转换（下） 12m36s
│ │ └─3.7 后缀表达式求值 8m18s
│ ├─4 基本结构（下）
│ │ ├─4.1 队列抽象数据类型及Python实现 10m01s
│ │ ├─4.2 队列的应用：热土豆 7m52s
│ │ ├─4.3 队列的应用：打印任务（上） 7m37s
│ │ ├─4.4 队列的应用：打印任务（下） 17m23s
│ │ ├─4.5 双端队列抽象数据类型及Python实现+回文词判定 7m25s
│ │ ├─4.6 无序表抽象数据类型及Python实现 11m03s
│ │ ├─4.7 无序表的链表实现 12m54s
│ │ ├─4.8 有序表抽象数据类型及Python实现 13m14s
│ │ └─4.9 线性结构小结 6m08s
│ ├─5 递归（上）
│ │ ├─5.1 什么是递归 13m20s
│ │ ├─5.2 递归的应用：任意进制转换 6m32s
│ │ ├─5.3 递归调用的实现 8m32s
│ │ ├─5.4 递归可视化：分形树 10m54s
│ │ ├─5.5 递归可视化：谢尔宾斯基三角 10m31s
│ │ ├─5.6 递归的应用：汉诺塔 10m37s
│ │ └─5.7 递归的应用：探索迷宫 16m35s
│ ├─6 递归（下）
│ │ ├─6.1 分治策略 5m34s
│ │ ├─6.2 优化问题和贪心策略 7m49s
│ │ ├─6.3 找零兑换问题的递归解法 12m32s
│ │ ├─6.4 找零兑换问题的动态规划解法 13m26s
│ │ ├─6.5 动态规划案例分析 17m53s
│ │ └─6.6 递归小结 6m51s
│ ├─7 排序与查找（上）
│ │ ├─7.1 顺序查找算法及分析 9m41s
│ │ ├─7.2 二分查找算法及分析 12m20s
│ │ ├─7.3 冒泡和选择排序算法及分析 12m14s
│ │ ├─7.4 插入排序算法及分析 7m06s
│ │ ├─7.5 谢尔排序算法及分析 6m15s
│ │ ├─7.6 归并排序算法及分析 9m13s
│ │ └─7.7 快速排序算法及分析 12m30s
│ ├─8 排序与查找（下）
│ │ ├─8.1 什么是散列 7m21s
│ │ ├─8.2 完美散列函数 15m02s
│ │ ├─8.3 区块链技术 17m20s
│ │ ├─8.4 散列函数设计 8m47s
│ │ ├─8.5 冲突解决方案 11m59s
│ │ ├─8.6 映射抽象数据类型及Python实现 14m58s
│ │ └─8.7 排序与查找小结 9m45s
│ └─9 树及算法（上）
│ ├─9.1 什么是树 8m37s
│ ├─9.2 树结构相关术语 8m23s
│ ├─9.3 树的嵌套列表实现 11m00s
│ ├─9.4 树的链表实现 6m57s
│ ├─9.5 树的应用：表达式解析（上） 13m03s
│ ├─9.6 树的应用：表达式解析（下） 15m15s
│ ├─9.7 树的遍历 10m11s
│ ├─9.8 优先队列和二叉堆 11m45s
│ └─9.9 二叉堆的Python实现 13m14s
├─离散数学概论 - 北京大学
│ ├─1 数理逻辑-基本概念
│ │ ├─1.1 命题与联结词
│ │ └─1.2 命题公式
│ ├─10 抽象代数
│ │ ├─10.1 代数结构
│ │ ├─10.2 特殊元素
│ │ └─10.3 代数结构间的关系
│ ├─11 形式语言与自动机：基本概念
│ │ ├─11.1 形式语言
│ │ └─11.2 形式语法分类
│ ├─12 形式语言与自动机-有限状态机
│ │ ├─12.1 状态图
│ │ ├─12.2 商机器
│ │ └─12.3 带输出的机器
│ ├─13 形式语言与自动机-图灵机与计算理论
│ │ ├─13.1 图灵机
│ │ ├─13.2 通用图灵机
│ │ └─13.3 停机问题
│ ├─2 课程介绍
│ │ ├─2.1 课程简介
│ │ └─2.2 正式内容之前
│ ├─3 数理逻辑-命题逻辑及形式系统
│ │ ├─3.1 重言式
│ │ ├─3.2 范式
│ │ └─3.3 命题演算形式系统
│ ├─4 数理逻辑-谓词逻辑及形式系统
│ │ ├─4.1 谓词公式
│ │ ├─4.2 谓词演算形式系统
│ │ └─4.3 自然推理系统
│ ├─5 集合论
│ │ ├─5.1 集合基本概念
│ │ └─5.2 归纳定义
│ ├─6 集合论-集合代数
│ │ ├─6.1 关系定义
│ │ ├─6.2 关系运算
│ │ └─6.3 关系特性
│ ├─7 集合论-特殊关系及函数
│ │ ├─7.1 特殊关系
│ │ └─7.2 函数
│ ├─8 图论：图的基本概念
│ │ ├─8.1 图的定义
│ │ └─8.2 连通性
│ └─9 图论-特殊图
│ ├─9.1 二分图
│ └─9.2 树
├─程序设计与算法（一）C语言程序设计 - 北京大学
│ ├─1 第一周
│ │ ├─1.1 信息在计算机中的表示
│ │ ├─1.2 C语言快速入门
│ │ ├─1.3 变量和数据类型初探
│ │ ├─1.4 变量和数据类型进阶
│ │ ├─1.5 常量
│ │ ├─1.6 Dev C++编译环境介绍
│ │ ├─1.7 第一周讲义
│ │ ├─1.8 Openjudge在线做题必读
│ │ └─1.9 习题边写边说(视频)
│ ├─10 第十周
│ │ ├─10.1 结构（struct）
│ │ ├─10.2 全局变量、局部变量、静态变量
│ │ ├─10.3 变量的作用域和生存期
│ │ ├─10.4 选择排序和插入排序
│ │ ├─10.5 冒泡排序
│ │ ├─10.6 程序或算法的时间复杂度
│ │ └─10.7 第十周讲义
│ ├─11 第十一周
│ │ ├─11.1 STL排序算法sort
│ │ ├─11.2 STL二分查找算法
│ │ ├─11.3 multiset
│ │ ├─11.4 自定义排序规则的multiset
│ │ ├─11.5 set
│ │ └─11.6 第十一周讲义
│ ├─12 第十二周
│ │ ├─12.1 multimap
│ │ ├─12.2 map
│ │ └─12.3 第十二周讲义
│ ├─13 课本习题解答
│ │ └─13.1 《新标准C++程序设计教程》习题解答
│ ├─14 第十三周
│ │ ├─14.1 文件读写概述
│ │ ├─14.2 文本文件读写
│ │ ├─14.3 二进制文件读写概述
│ │ ├─14.4 创建和读取二进制文件
│ │ ├─14.5 修改二进制文件
│ │ ├─14.6 文件拷贝程序
│ │ └─14.7 第十三周讲义
│ ├─2 第二周
│ │ ├─2.1 输入输出进阶
│ │ ├─2.2 算术运算符和算术表达式
│ │ ├─2.3 关系运算符和逻辑表达式
│ │ ├─2.4 其他运算符及运算符优先级
│ │ ├─2.5 第二周讲义
│ │ └─2.6 习题边写边说（视频）
│ ├─3 第三周
│ │ ├─3.1 if语句
│ │ ├─3.2 switch语句
│ │ ├─3.3 for 循环之一
│ │ ├─3.4 for 循环之二
│ │ ├─3.5 while循环和do while循环之一
│ │ ├─3.6 while循环和do while循环之二
│ │ ├─3.7 第三周讲义
│ │ └─3.8 习题边写边说(视频)
│ ├─4 第四周
│ │ ├─4.1 break语句和continue语句
│ │ ├─4.2 OJ输入数据的处理
│ │ ├─4.3 用freopen重定向输入
│ │ ├─4.4 循环例题选讲 1
│ │ ├─4.5 循环例题选讲 2
│ │ ├─4.6 循环例题选讲 3
│ │ └─4.7 第四周讲义
│ ├─5 第五周
│ │ ├─5.1 数组
│ │ ├─5.2 筛法求素数
│ │ ├─5.3 数组初始化
│ │ ├─5.4 数组越界
│ │ ├─5.5 二维数组
│ │ └─5.6 第五周讲义
│ ├─6 第六周
│ │ ├─6.1 函数(1)
│ │ ├─6.2 函数(2)
│ │ ├─6.3 递归初步
│ │ ├─6.4 库函数和头文件
│ │ ├─6.5 位运算
│ │ ├─6.6 位运算思考题
│ │ └─6.7 第六周讲义
│ ├─7 第七周
│ │ ├─7.1 字符串的形式和存储
│ │ ├─7.2 输入字符串
│ │ ├─7.3 字符串库函数
│ │ ├─7.4 例题：编写判断子串的函数
│ │ └─7.5 第七周讲义
│ ├─8 第八周
│ │ ├─8.1 指针的基本概念和用法
│ │ ├─8.2 指针的意义和互相赋值
│ │ ├─8.3 指针的运算
│ │ ├─8.4 指针作为函数参数
│ │ ├─8.5 指针和数组
│ │ └─8.6 第八周讲义
│ └─9 第九周
│ ├─9.1 指针和二维数组、指向指针的指针
│ ├─9.2 指针和字符串
│ ├─9.3 字符串库函数
│ ├─9.4 void指针和内存操作函数
│ ├─9.5 函数指针
│ └─9.6 第九周讲义
├─程序设计与算法（三）C++面向对象程序设计 - 北京大学
│ ├─1 第一周 从 C 到C++
│ │ ├─1.1 引用
│ │ ├─1.2 const关键字
│ │ ├─1.3 动态内存分配
│ │ ├─1.4 内联函数和重载函数函数参数缺省值
│ │ ├─1.5 类和对象的基本概念(1)
│ │ ├─1.6 第一周讲义
│ │ └─1.7 Openjudge 在线做题必读
│ ├─10 第十周 C++ 11新特性和C++高级主题
│ │ ├─10.1 C++11 新特性(1)
│ │ ├─10.2 C++11 新特性(2)
│ │ ├─10.3 强制类型转换
│ │ ├─10.4 异常处理
│ │ └─10.5 第十周讲义
│ ├─11 魔兽世界大作业及魔兽系列作业测试数据
│ │ └─11.1 魔兽世界系列作业测试数据
│ ├─12 课本习题解答
│ │ └─12.1 《新标准C++程序设计》习题解答
│ ├─2 第二周 类和对象基础
│ │ ├─2.1 类和对象的基本概念(2)
│ │ ├─2.2 构造函数
│ │ ├─2.3 复制构造函数
│ │ ├─2.4 类型转换构造函数和析构函数
│ │ ├─2.5 构造函数析构函数调用时机
│ │ └─2.6 第二周讲义
│ ├─3 第三周 类和对象提高
│ │ ├─3.1 this指针
│ │ ├─3.2 静态成员变量
│ │ ├─3.3 成员对象和封闭类
│ │ ├─3.4 常量对象、常量成员函数
│ │ ├─3.5 友元
│ │ └─3.6 第三周讲义
│ ├─4 第四周 运算符重载
│ │ ├─4.1 运算符重载的基本概念
│ │ ├─4.2 赋值运算符的重载
│ │ ├─4.3 运算符重载为友元
│ │ ├─4.4 可变长数组类的实现
│ │ ├─4.5 流插入运算符和流提取运算符的重载
│ │ ├─4.6 类型转换运算符的重载
│ │ ├─4.7 自增自减运算符的重载
│ │ └─4.8 第四周讲义
│ ├─5 第五周 继承
│ │ ├─5.1 继承和派生的基本概念
│ │ ├─5.2 继承关系和复合关系
│ │ ├─5.3 覆盖和保护成员
│ │ ├─5.4 派生类的构造函数
│ │ ├─5.5 公有继承的赋值兼容规则
│ │ ├─5.6 第五周讲义
│ │ └─5.7 魔兽世界2测试数据
│ ├─6 第六周 多态
│ │ ├─6.1 虚函数和多态的基本概念
│ │ ├─6.2 多态实例：魔法门之英雄无敌
│ │ ├─6.3 多态实例：几何形体程序
│ │ ├─6.4 多态的实现原理
│ │ ├─6.5 虚析构函数、纯虚函数和抽象类
│ │ └─6.6 第六周讲义
│ ├─7 第七周 输入输出和模板
│ │ ├─7.1 输入输出流相关的类
│ │ ├─7.2 用流操纵算子控制输出格式
│ │ ├─7.3 文件读写（一）
│ │ ├─7.4 文件读写（二）
│ │ ├─7.5 函数模板
│ │ ├─7.6 类模板
│ │ ├─7.7 类模板与派生、友元和静态成员变量
│ │ ├─7.8 第七周讲义-模板
│ │ └─7.9 第七周讲义-输入输出和文件操作
│ ├─8 第八周 标准模板库STL(一)
│ │ ├─8.1 string 类
│ │ ├─8.2 标准模板库STL概述(一)
│ │ ├─8.3 标准模板库STL概述(二)
│ │ ├─8.4 vector,deque和list
│ │ ├─8.5 函数对象
│ │ ├─8.6 第八周string类讲义
│ │ └─8.7 第八周标准模板库(一)讲义
│ └─9 第九周 标准模板库STL(二)
│ ├─9.1 set和multiset
│ ├─9.2 map和multimap
│ ├─9.3 容器适配器
│ ├─9.4 算法(一)
│ ├─9.5 算法(二)
│ └─9.6 第九周讲义
├─程序设计与算法（二）算法基础 - 北京大学
│ ├─1 第一周 枚举
│ │ ├─1.1 枚举的基本思想
│ │ ├─1.2 例题：生理周期
│ │ ├─1.3 例题：称硬币
│ │ ├─1.4 例题：熄灯问题(1)
│ │ ├─1.5 例题：熄灯问题(2)
│ │ ├─1.6 第一周讲义
│ │ └─1.7 Openjudge在线做题必读
│ ├─10 第十周 广度优先搜索
│ │ ├─10.1 广度优先搜索的基本思想
│ │ ├─10.2 例题. 迷宫问题
│ │ ├─10.3 例题. 八数码问题
│ │ └─10.4 第十周讲义
│ ├─11 第十一周 贪心算法
│ │ ├─11.1 贪心算法的基本思想
│ │ ├─11.2 例题：电影节
│ │ ├─11.3 例题：分配畜栏
│ │ ├─11.4 例题：放置雷达
│ │ ├─11.5 例题：钓鱼
│ │ └─11.6 第十一周讲义
│ ├─2 第二周 递归（一）
│ │ ├─2.1 递归的基本思想
│ │ ├─2.2 例题2：汉诺塔
│ │ ├─2.3 例题3：N皇后
│ │ ├─2.4 例题4：逆波兰表达式求值
│ │ └─2.5 第二周讲义
│ ├─3 第三周 递归（二）
│ │ ├─3.1 例题1：表达式求值
│ │ ├─3.2 例题2：上台阶
│ │ ├─3.3 例题3：放苹果
│ │ ├─3.4 例题4：算24
│ │ └─3.5 第三周讲义
│ ├─4 第四周 二分算法
│ │ ├─4.1 程序或算法的时间复杂度
│ │ ├─4.2 二分查找的原理和实现
│ │ ├─4.3 二分法求方程的根
│ │ ├─4.4 例题1 找 一对数
│ │ ├─4.5 例题2 农夫和奶牛
│ │ └─4.6 第四周讲义
│ ├─5 第五周 分治
│ │ ├─5.1 分治的基本思想
│ │ ├─5.2 快速排序
│ │ ├─5.3 输出前m大的数
│ │ ├─5.4 求排列的逆序数
│ │ └─5.5 第五周讲义
│ ├─6 第六周 动态规划（一）
│ │ ├─6.1 动态规划的基本思想
│ │ ├─6.2 例题 数字三角形（2）
│ │ ├─6.3 动态规划解题一般思路
│ │ ├─6.4 例题 最长上升子序列
│ │ ├─6.5 例题 最长公共子序列
│ │ ├─6.6 例题 最佳加法表达式
│ │ └─6.7 第六周讲义
│ ├─7 第七周 动态规划(二)
│ │ ├─7.1 例题1. Help Jimmy
│ │ ├─7.2 例题2. 滑雪
│ │ ├─7.3 例题3. 神奇的口袋
│ │ ├─7.4 例题4. 0-1背包问题
│ │ ├─7.5 例题5. 分蛋糕
│ │ └─7.6 第七周讲义
│ ├─8 第八周 深度优先搜索（一）
│ │ ├─8.1 在图上寻找路径和遍历（一）
│ │ ├─8.2 在图上寻找路径和遍历（二）
│ │ ├─8.3 图的表示方法：邻接矩阵和邻接表
│ │ ├─8.4 例题1. 城堡问题
│ │ ├─8.5 例题2. 踩方格
│ │ └─8.6 第八周讲义
│ └─9 第九周 深度优先搜索（二）
│ ├─9.1 剪枝的思想和例题1 寻路问题（一）
│ ├─9.2 例题1 寻路问题（二）
│ ├─9.3 例题2. 生日蛋糕
│ └─9.4 第九周讲义
├─算法设计与分析 - 北京大学
│ ├─1 第一周 基础知识（1）：算法的基本概念及伪码描述，函数的渐近的界
│ │ ├─1.1 本周教学内容简介
│ │ ├─1.2 算法设计的两个例子
│ │ ├─1.3 问题的计算复杂度：排序问题
│ │ ├─1.4 货郎问题与计算复杂性
│ │ ├─1.5 算法及其时间复杂度
│ │ ├─1.6 算法的伪码表示
│ │ ├─1.7 函数的渐近的界
│ │ ├─1.8 有关函数渐近的界的定理
│ │ └─1.9 几类重要函数
│ ├─10 第十周 回溯与分支限界
│ │ ├─10.1 本周教学内容简介
│ │ ├─10.2 分支限界
│ │ ├─10.3 最大团问题
│ │ ├─10.4 货郎问题
│ │ ├─10.5 圆排列问题
│ │ ├─10.6 连续邮资问题
│ │ └─10.7 课程总结
│ ├─2 第二周 基础知识（2）：序列求和方法，递推方程求解
│ │ ├─2.1 本周教学内容简介
│ │ ├─2.2 序列求和的方法
│ │ ├─2.3 递推方程与算法分析
│ │ ├─2.4 迭代法求解递推方程
│ │ ├─2.5 差消法化简递推方程
│ │ ├─2.6 递归树
│ │ ├─2.7 主定理及其证明
│ │ └─2.8 主定理的应用
│ ├─3 第三周 分治策略（1）
│ │ ├─3.1 本周教学内容简介
│ │ ├─3.2 分治策略的设计思想
│ │ ├─3.3 分治策略的一般描述和分析方法
│ │ ├─3.4 芯片测试
│ │ ├─3.5 快速排序
│ │ ├─3.6 幂乘算法及应用
│ │ ├─3.7 改进分治算法的途径1：减少子问题数
│ │ └─3.8 改进分治算法的途径2：增加预处理
│ ├─4 第四周 分治策略（2）
│ │ ├─4.1 本周内容简介
│ │ ├─4.2 选最大与最小
│ │ ├─4.3 选第二大
│ │ ├─4.4 一般选择问题的算法设计
│ │ ├─4.5 选择问题的算法分析
│ │ ├─4.6 卷积及应用
│ │ ├─4.7 卷积计算
│ │ ├─4.8 快速傅立叶变换FFT算法
│ │ └─4.9 平面点集的凸包
│ ├─5 第五周 动态规划（1）
│ │ ├─5.1 本周教学内容简介
│ │ ├─5.2 动态规划算法的例子
│ │ ├─5.3 动态规划算法设计
│ │ ├─5.4 动态规划算法的递归实现
│ │ ├─5.5 动态规划算法的迭代实现
│ │ ├─5.6 投资问题
│ │ ├─5.7 背包问题
│ │ └─5.8 最长公共子序列
│ ├─6 第六周 动态规划（2）
│ │ ├─6.1 本周教学内容简介
│ │ ├─6.2 图像压缩
│ │ ├─6.3 最大子段和
│ │ ├─6.4 最优二叉检索树的概念
│ │ ├─6.5 最优二叉检索树的算法
│ │ ├─6.6 RNA二级结构预测
│ │ └─6.7 序列比对
│ ├─7 第七周 贪心法（1）
│ │ ├─7.1 本周教学内容简介
│ │ ├─7.2 贪心法的例子
│ │ ├─7.3 贪心法的正确性证明
│ │ ├─7.4 最优装载问题
│ │ ├─7.5 最小延迟调度
│ │ └─7.6 得不到最优解的处理方法
│ ├─8 第八周 贪心法（2）
│ │ ├─8.1 本周教学内容简介
│ │ ├─8.2 最优前缀码及哈夫曼算法
│ │ ├─8.3 哈夫曼算法的正确性证明
│ │ ├─8.4 最小生成树
│ │ ├─8.5 Prim算法
│ │ ├─8.6 Kruskal算法
│ │ ├─8.7 单源最短路径问题及算法
│ │ └─8.8 Dijkstra算法的证明
│ └─9 第九周 回溯与分支限界（1）
│ ├─9.1 本周教学内容简介
│ ├─9.2 几个回溯算法的例子
│ ├─9.3 回溯算法的设计思想和适用条件
│ ├─9.4 回溯算法实现及实例
│ ├─9.5 图的着色
│ └─9.6 搜索树结点数的估计
├─计算机组成 - 北京大学
│ ├─1 计算机基本结构（Basic Components of a Computer）
│ │ ├─1.1 电子计算机的兴起
│ │ ├─1.2 冯诺依曼结构的要点
│ │ ├─1.3 冯诺依曼结构的小故事
│ │ ├─1.4 计算机结构的简化模型
│ │ ├─1.5 计算机执行指令的过程
│ │ ├─1.6 计算机输入和输出
│ │ └─1.7 冯诺依曼结构和具体实现
│ ├─2 指令系统体系结构（Instruction Set Architecture）
│ │ ├─2.1 设计自己的计算机
│ │ ├─2.2 x86体系结构
│ │ ├─2.3 x86指令简介
│ │ ├─2.4 复杂的x86指令举例
│ │ ├─2.5 MIPS体系结构
│ │ └─2.6 MIPS指令简介
│ ├─3 算术逻辑单元（Arithmetic Logic Unit）
│ │ ├─3.1 算术运算和逻辑运算
│ │ ├─3.2 门电路的基本原理
│ │ ├─3.3 寄存器的基本原理
│ │ ├─3.4 逻辑运算的实现
│ │ ├─3.5 加法和减法的实现
│ │ └─3.6 加法器的优化
│ ├─4 乘法器和除法器（Multiplier and Divider）
│ │ ├─4.1 乘法的运算过程
│ │ ├─4.2 乘法器的实现
│ │ ├─4.3 乘法器的优化1
│ │ ├─4.4 乘法器的优化2
│ │ ├─4.5 除法的运算过程
│ │ ├─4.6 除法器的实现
│ │ └─4.7 除法器的优化
│ ├─5 单周期处理器（Single Cycle Processor）
│ │ ├─5.1 设计处理器的准备
│ │ ├─5.2 数据通路的建立
│ │ ├─5.3 运算指令的控制信号
│ │ ├─5.4 访存指令的控制信号
│ │ ├─5.5 分支指令的控制信号
│ │ └─5.6 控制信号的集成
│ ├─6 流水线处理器（Pipelined Processor）
│ │ ├─6.1 流水线的基本原理
│ │ ├─6.2 流水线的优化
│ │ ├─6.3 超标量流水线
│ │ ├─6.4 流水线的冒险
│ │ ├─6.5 数据冒险的处理
│ │ └─6.6 控制冒险的处理
│ ├─7 存储层次结构（Memory Hierarchy）
│ │ ├─7.1 存储层次结构概况
│ │ ├─7.2 DRAM和SRAM
│ │ ├─7.3 主存的工作原理
│ │ ├─7.4 主存技术的发展
│ │ ├─7.5 高速缓存的工作
│ │ ├─7.6 高速缓存的设计要点
│ │ └─7.7 存储容量的计算
│ ├─8 中断与异常（Interruption and Exception）
│ │ ├─8.1 中断和异常的来源
│ │ ├─8.2 中断向量表的结构
│ │ ├─8.3 中断向量表的发展
│ │ ├─8.4 中断的处理过程
│ │ ├─8.5 内部中断分类说明
│ │ └─8.6 基于中断的功能调用
│ └─9 输入输出接口（Input／Output System）
│ ├─9.1 输入输出接口的基本功能
│ ├─9.2 输入输出接口的编址方式
│ ├─9.3 输入输出的控制方式
│ ├─9.4 中断控制方式
│ ├─9.5 外部中断的处理过程
│ └─9.6 直接存储器访问方式
├─计算概论与程序设计基础 - 北京大学
│ ├─1 计算机的基本原理
│ │ ├─1.1 从数学危机到图灵机
│ │ ├─1.2 图灵机的基本构成
│ │ ├─1.3 图灵机的运行机理
│ │ ├─1.4 数的二进制表示
│ │ └─1.5 二进制数的布尔运算
│ ├─10 C程序中的字符串
│ │ ├─10.1 字符数组与字符串
│ │ ├─10.2 输入缓冲区
│ │ ├─10.3 一个字符的输入
│ │ ├─10.4 一串字符的输入
│ │ ├─10.5 字符串应用例题
│ │ └─10.6 编程作业：字符串应用练习
│ ├─11 C程序中的函数
│ │ ├─11.1 函数的定义与声明
│ │ ├─11.2 函数的调用过程
│ │ ├─11.3 函数调用示例
│ │ ├─11.4 变量的作用域
│ │ ├─11.5 数组做函数参数
│ │ ├─11.6 函数应用示例
│ │ └─11.7 编程练习：函数与字符串练习
│ ├─12 C语言中的运算成分
│ │ ├─12.1 说在前面的话
│ │ ├─12.10 编程作业：运算成分基础练习
│ │ ├─12.2 赋值运算
│ │ ├─12.3 赋值运算的说明
│ │ ├─12.4 算术运算
│ │ ├─12.5 自增自减运算
│ │ ├─12.6 关系运算
│ │ ├─12.7 逻辑运算与混合运算
│ │ ├─12.8 逗号，条件，强制类型转换
│ │ └─12.9 位运算
│ ├─13 函数的递归
│ │ ├─13.1 如何理解递归
│ │ ├─13.2 递归调用的过程
│ │ ├─13.3 递归应用示例（切饼，斐波那契数列）
│ │ ├─13.4 递归应用示例（进制转换，汉诺塔）
│ │ ├─13.5 递归应用示例（放苹果）【较难 选听】
│ │ ├─13.6 递归应用示例（逆波兰表达式）【较难 选听】
│ │ ├─13.7 习题课一 枚举 模拟与递归
│ │ └─13.8 编程练习：递归编程练习（1／2）
│ ├─14 指针 —
│ │ ├─14.1 什么是指针
│ │ ├─14.2 什么是指针变量
│ │ ├─14.3 指针变量示例
│ │ ├─14.4 指针变量的++---
│ │ ├─14.5 数组与指针
│ │ ├─14.6 用指针访问数组
│ │ ├─14.7 习题课二 较难 选听
│ │ └─14.8 编程练习：递归编程练习（2／2）
│ ├─15 指针二
│ │ ├─15.1 字符串与指针
│ │ ├─15.2 再谈指向一维数组的指针
│ │ ├─15.3 指向二维数组的指针
│ │ ├─15.4 二维数组名引用示例
│ │ ├─15.5 利用指针遍历二维数组
│ │ └─15.6 编程作业：指针使用练习
│ ├─16 指针三
│ │ ├─16.1 指针做函数参数
│ │ ├─16.2 限制指针函数实参的功能
│ │ ├─16.3 指针做函数返回值
│ │ ├─16.4 静态局部变量
│ │ └─16.5 编程练习：综合练习题
│ ├─17 结构体与链表
│ │ ├─17.1 结构体与结构体变量
│ │ ├─17.2 结构体变量与函数
│ │ ├─17.3 结构体变量与指针
│ │ ├─17.4 链表的定义
│ │ ├─17.5 链表的操作
│ │ └─17.6 编程练习：结构体与链表的使用
│ ├─19 最后一次课
│ │ ├─19.1 结语;轻叩面向对象之门
│ │ ├─19.2 编程工具的安装和使用：下载、安装和使用IDE
│ │ └─19.3 说明 编程工具的安装和使用：使用IDE进行调试
│ ├─2 计算机的历史与未来
│ │ ├─2.1 历史上的计算设备
│ │ ├─2.2 从电子管到云计算
│ │ ├─2.3 摩尔定律下的计算危机
│ │ ├─2.4 量子计算机的基本原理
│ │ └─2.5 量子计算机的发展状态
│ ├─3 程序运行的基本原理
│ │ ├─3.1 问题的提出
│ │ ├─3.2 冯诺依曼式计算机
│ │ ├─3.3 存储器的种类与特点
│ │ ├─3.4 存储器的原理与类型
│ │ ├─3.5 CPU指令的执行
│ │ └─3.6 程序的执行
│ ├─4 感性认识计算机程序
│ │ ├─4.1 说在前面的话
│ │ ├─4.10 配置编程环境（补充资料）使用IDE进行调试
│ │ ├─4.11 编程作业：编程基础练习（1／2）
│ │ ├─4.2 程序是你告诉计算机的话
│ │ ├─4.3 如果你的大脑是台计算机
│ │ ├─4.4 如果你来设计一门编程语言
│ │ ├─4.5 快步走近C程序之一
│ │ ├─4.6 快步走近C程序之二
│ │ ├─4.7 快步走近C程序之三
│ │ ├─4.8 什么样的程序是好程序
│ │ └─4.9 配置编程环境（补充资料）下载安装和使用IDE
│ ├─5 从现实问题到计算机程序的
│ │ ├─5.1 没有解决方案就没有程序
│ │ ├─5.2 先有构想再写程序
│ │ ├─5.3 先有构想再写程序--示例
│ │ ├─5.4 体验结构化的程序--示例
│ │ └─5.5 编程作业：编程基础练习（2／2）
│ ├─6 理性认识C程序 导论
│ │ ├─6.1 明确学习进度
│ │ ├─6.2 C语言的由来
│ │ ├─6.3 C语言的标准
│ │ └─6.4 C语言的构成
│ ├─7 C 语言中的数据成分
│ │ ├─7.1 再谈学习进度与安排
│ │ ├─7.10 常数
│ │ ├─7.11 变量命名
│ │ ├─7.12 编程作业：数据成分基础练习
│ │ ├─7.2 变量定义的含义
│ │ ├─7.3 整数型的类别
│ │ ├─7.4 整数型的存储
│ │ ├─7.5 整数的输入输出
│ │ ├─7.6 最大与最小整数
│ │ ├─7.7 浮点型
│ │ ├─7.8 字符型
│ │ └─7.9 布尔型
│ ├─8 C语言中的控制成分
│ │ ├─8.1 再谈分支语句
│ │ ├─8.2 再谈循环语句
│ │ ├─8.3 Goto之争
│ │ └─8.4 编程练习：控制成分基础练习
│ └─9 C程序中的数组
│ ├─9.1 再谈一维数组
│ ├─9.2 二维数组
│ ├─9.3 三维数组
│ ├─9.4 数组的作用之一
│ ├─9.5 数组的作用之二
│ └─9.6 编程作业：数组应用练习
└─软件工程 - 北京大学
├─1 第一周：软件工程概论
│ ├─1.1 软件的定义及特点
│ ├─1.2 软件工程的起源和概念
│ ├─1.3 软件开发的本质和基本手段
│ ├─1.4 软件工程框架
│ └─1.5 补充材料－软件工程新视野
├─10 第五周：UML-2
│ ├─10.1 表达客观事物的术语——接口及其他
│ ├─10.2 控制复杂性的术语——包
│ ├─10.3 表达关系的术语——关联
│ └─10.4 表达关系的术语——泛化、细化、依赖及如何使用
├─11 第六周：UML-3
│ ├─11.1 UML的模型表达工具概述
│ ├─11.2 UML的模型表达工具静态建模——类图
│ └─11.3 UML模型表达工具_动态建模——用况图
├─12 第六周：UML-4
│ ├─12.1 顺序图
│ ├─12.2 状态图
│ └─12.3 UML总结
├─13 第七周：面向对象分析
│ ├─13.1 面向对象分析概述
│ ├─13.2 识别类
│ ├─13.3 识别属性和操作
│ ├─13.4 识别对象之间的关系
│ └─13.5 【补充】面向对象分析案例
├─14 第七周：面向对象设计-1
│ ├─14.1 面向对象设计概述
│ ├─14.2 问题域部分的概念
│ └─14.3 如何进行问题域部分的设计
├─15 第八周：面向对象设计-2
│ ├─15.1 人机交互部分的设计
│ ├─15.2 控制驱动和数据管理部分的设计
│ └─15.3 【补充】面向对象设计案例
├─16 第八周：编码实现
│ ├─16.1 程序设计范型和面向对象编程语言的特点发展
│ ├─16.2 如何选择编程语言
│ └─16.3 【补充】代码风格与编程规范
├─17 第八周：敏捷开发方法
│ ├─17.1 敏捷开发概述
│ ├─17.2 极限编程
│ ├─17.3 敏捷设计
│ └─17.4 Scrum模型
├─18 第九周：软件测试-1
│ ├─18.1 软件测试的概念
│ ├─18.2 软件测试过程模型和原则
│ └─18.3 白盒测试技术
├─19 第九周：软件测试-2
│ ├─19.1 黑盒测试技术
│ └─19.2 软件测试的步骤
├─2 第一周：软件过程
│ ├─2.1 软件生存周期过程的概念
│ ├─2.2 软件生存周期过程的分类
│ ├─2.3 软件生存周期模型的概念
│ └─2.4 常见的软件生存周期模型
├─20 第十周：项目管理
│ ├─20.1 项目管理的概念
│ ├─20.2 项目管理框架和要素
│ ├─20.3 软件项目管理的概念
│ └─20.4 【补充】软件质量
├─21 第十周：CMM
│ ├─21.1 CMM概念及发展
│ ├─21.2 CMM的基本内容
│ ├─21.3 CMM五级标准
│ └─21.4 ISO9000标准
├─22 第十一周：软件开发工具与环境
│ ├─22.1 软件开发工具及环境的定义
│ ├─22.2 工具集成模型
│ ├─22.3 常用的软件开发工具和环境
│ └─22.4 补充材料-移动web软件分析与优化
├─23 第十二周（补充内容）：软件维护与再工程
│ ├─23.1 软件维护的概念
│ ├─23.2 软件维护活动
│ ├─23.3 程序修改
│ ├─23.4 软件再工程模型
│ └─23.5 逆向工程
├─3 第一周：课程介绍
│ ├─3.1 课程宣传片
│ └─3.2 课程简介
├─4 第二周：软件需求
│ ├─4.1 需求的作用
│ ├─4.2 需求的定义
│ ├─4.3 需求的分类
│ ├─4.4 需求发现
│ ├─4.5 需求规约的概念和格式
│ ├─4.6 需求规约的作用
│ └─4.7 项目的需求及需求规约
├─5 第三周：结构化分析方法
│ ├─5.1 结构化分析方法的概念
│ ├─5.2 结构化分析模型
│ ├─5.3 结构化分析过程
│ ├─5.4 需求规格说明书
│ ├─5.5 【补充】结构化分析案例
│ └─5.6 【补充】需求验证
├─6 第三周：结构化设计方法-1
│ ├─6.1 结构化设计概念
│ ├─6.2 初始模块结构图的设计
│ ├─6.3 初始模块结构图精化的原则
│ └─6.4 【补充】总体设计案例
├─7 第四周：结构化设计方法-2
│ ├─7.1 初始模块结构图精化的启发式规则
│ ├─7.2 接口设计
│ └─7.3 数据设计
├─8 第四周：结构化设计方法-3
│ ├─8.1 详细设计工具
│ ├─8.2 软件设计规约
│ ├─8.3 结构化方法总结
│ └─8.4 【补充】软件设计评审
└─9 第五周：UML-1
├─9.1 面向对象的概念
├─9.2 UML的概念
└─9.3 表达客观事物的术语——类

「北京大学 17门计算机课」，点击链接保存，或者复制本段内容，打开「阿里云盘」APP ，无需下载，极速在线查看享用。
链接：

该网盘链接需要登录后才能查看，请先[登录]。