本课程《程序设计基础》是计算机科学的入门核心课程，旨在系统性地讲解程序设计的基本思想、方法与技术。课程从预备知识（如数的进制）开始，逐步深入，涵盖程序基本结构、数据类型、分支与循环控制、数组、函数、指针、结构体等核心概念，并进一步拓展至面向对象编程（类与对象、运算符重载、组合与继承）、模板、输入输出流及文件操作，最后探讨递归、回溯与分治等高级算法思想。通过本课程的学习，学生将建立起扎实的编程基础，掌握使用C++语言解决实际问题的能力。

视频课程目录：
1. 预备知识-数的进制
2. 绪论
3. 程序的基本组成
4. 分支程序设计
5. 循环程序设计
6. 数组
7. 函数
8. 指针
9. 结构体
10. 创建新的类型（类与对象）
11. 运算符重载
12. 组合与继承
13. 模板
14. 输入输出和文件
15. 递归、回溯与分治




├─{01}--预备知识-数的进制
│ [1.1]--0预备知识1-数的进制概念.mp4
│ [1.2]--0预备知识2-数的进制10和N进制转换.mp4
│ [1.3]--0预备知识3-数的进制2、8和16进制转换.mp4
│ [1.4]--0预备知识4-数的进制计算机中的数.mp4
│
├─{02}--绪论
│ [2.1]--01绪论.mp4
│
├─{03}--程序的基本组成
│ │ [3.10]--02-13程序设计风格及小结.mp4
│ │ [3.11]--02-14补充：逗号表达式.mp4
│ │ [3.1]--02-1程序基本结构.mp4
│ │ [3.2]--02-2变量定义.mp4
│ │ [3.4]--02-7常量.mp4
│ │ [3.5]--02-8算术表达式.mp4
│ │ [3.6]--02-9赋值表达式.mp4
│ │ [3.7]--02-10自增自减运算符.mp4
│ │ [3.8]--02-11强制类型转换.mp4
│ │ [3.9]--02-12数据的输入输出.mp4
│ │
│ └─{03}--数据类型
│ [3.3.1]--02-3数据类型：整型.mp4
│ [3.3.2]--02-4数据类型：浮点型.mp4
│ [3.3.3]--02-5数据类型：字符型.mp4
│ [3.3.4]--02-6数据类型：布尔型及类型总结.mp4
│
├─{04}--分支程序设计
│ │ [4.2]--03-3关系表达式.mp4
│ │ [4.3]--03-4逻辑表达式.mp4
│ │
│ ├─{01}--引言
│ │ [4.1.1]--03-1引言-算法、顺序结构和选择结构.mp4
│ │ [4.1.2]--03-2引言-if语句处理选择结构示例.mp4
│ │
│ ├─{04}--if语句
│ │ [4.4.1]--03-5if语句格式及对应流程图.mp4
│ │ [4.4.2]--03-6选择结构的嵌套.mp4
│ │ [4.4.3]--03-7条件表达式(1).mp4
│ │ [4.4.4]--03-8用于多分支控制的条件语句.mp4
│ │
│ └─{05}--switch语句
│ [4.5.1]--03-9switch语句.mp4
│ [4.5.2]--03-10分支程序举例：四则运算出题.mp4
│
├─{05}--循环程序设计
│ │ [5.1]--04-1引言.mp4
│ │ [5.3]--04-4do-while循环.mp4
│ │ [5.5]--04-8循环的中途退出.mp4
│ │ [5.6]--04-9循环的嵌套.mp4
│ │
│ ├─{02}--while循环
│ │ [5.2.1]--04-2while循环语法.mp4
│ │ [5.2.2]--04-3while循环实例.mp4
│ │
│ ├─{04}--for循环
│ │ [5.4.1]--04-5for循环语法.mp4
│ │ [5.4.2]--04-6for语句说明.mp4
│ │ [5.4.3]--04-7for语句注意事项、for循环实例.mp4
│ │
│ └─{07}--循环实例
│ [5.7.1]--04-10循环实例-阶乘相关操作.mp4
│ [5.7.2]--04-11循环实例-级数的和.mp4
│
├─{06}--数组
│ ├─{01}--一维数组
│ │ [6.1.1]--05-1一维数组的定义与存储.mp4
│ │ [6.1.2]--05-2一维数组的引用与赋初值.mp4
│ │ [6.1.3]--05-3一维数组应用-均值和方差（可变大小数组）.mp4
│ │ [6.1.4]--05-4一维数组应用-字符计数.mp4
│ │ [6.1.5]--05-5一维数组应用-月份天数、Fibonacci数列.mp4
│ │ [6.1.6]--05-6数组下标越界问题.mp4
│ │
│ ├─{02}--排序和查找
│ │ [6.2.1]--05-7顺序查找.mp4
│ │ [6.2.2]--05-8折半查找.mp4
│ │ [6.2.3]--05-9选择排序.mp4
│ │ [6.2.4]--05-10冒泡排序.mp4
│ │
│ ├─{03}--二维数组
│ │ [6.3.1]--05-11二维数组的定义、引用与赋初值.mp4
│ │ [6.3.2]--05-12二维数组实例1.mp4
│ │ [6.3.3]--05-13二维数组实例2-打印魔阵.mp4
│ │
│ └─{04}--字符串
│ [6.4.1]--05-14字符串的存储与初始化.mp4
│ [6.4.2]--05-15字符串与字符数组的区别.mp4
│ [6.4.3]--05-16字符串的输入输出.mp4
│ [6.4.4]--05-17字符串应用-统计单词数.mp4
│ [6.4.5]--05-18字符串处理函数.mp4
│
├─{07}--函数
│ │ [7.10]--06-16函数模板.mp4
│ │ [7.1]--06-1函数的概念.mp4
│ │ [7.2]--06-2函数的定义.mp4
│ │ [7.5]--06-10变量的存储类别.mp4
│ │ [7.7]--06-13函数的默认形参.mp4
│ │ [7.8]--06-14内联函数.mp4
│ │ [7.9]--06-15重载函数.mp4
│ │
│ ├─{03}--函数的使用
│ │ [7.3.1]--06-3函数的使用-函数调用.mp4
│ │ [7.3.2]--06-4函数的使用-参数传递.mp4
│ │ [7.3.3]--06-5函数的使用-函数的返回值.mp4
│ │ [7.3.4]--06-6函数的使用-嵌套调用.mp4
│ │ [7.3.5]--06-7函数的使用-函数原型.mp4
│ │
│ ├─{04}--变量的作用域
│ │ [7.4.1]--06-8变量的作用域-局部变量.mp4
│ │ [7.4.2]--06-9变量的作用域-全局变量.mp4
│ │
│ └─{06}--数组作为参数
│ [7.6.1]--06-11数组作函数参数（一维数组）.mp4
│ [7.6.2]--06-12数组作函数参数（二维数组）.mp4
│
├─{08}--指针
│ │ [8.7]--07-15指针数组.mp4
│ │ [8.8]--07-16指向函数的指针.mp4
│ │ [8.9]--07-17使用指针时程序可能崩溃的情况.mp4
│ │
│ ├─{01}--指针的概念
│ │ [8.1.1]--07-1指针的概念.mp4
│ │ [8.1.2]--07-2指针变量的定义和初始化.mp4
│ │ [8.1.3]--07-3指针的使用.mp4
│ │
│ ├─{02}--指针运算与数组
│ │ [8.2.1]--07-4数组的指针基本概念.mp4
│ │ [8.2.2]--07-5通过指针引用数组元素.mp4
│ │
│ ├─{03}--字符串再讨论
│ │ [8.3.1]--07-6字符串指针概念.mp4
│ │ [8.3.2]--07-7字符串指针编程举例.mp4
│ │
│ ├─{04}--指针与函数
│ │ [8.4.1]--07-8指针作为函数参数.mp4
│ │ [8.4.2]--07-9数组指针作为函数参数.mp4
│ │ [8.4.3]--07-10返回指针的函数.mp4
│ │
│ ├─{05}--引用与函数
│ │ [8.5.1]--07-11引用的概念.mp4
│ │ [8.5.2]--07-12引用与函数.mp4
│ │
│ └─{06}--动态内存分配
│ [8.6.1]--07-13动态内存分配.mp4
│ [8.6.2]--07-14深入了解动态内存分配.mp4
│
├─{09}--结构体
│ [9.1]--8-1结构体概述.mp4
│ [9.2]--8-2结构体类型定义及变量定义.mp4
│ [9.3]--8-3结构体变量的使用.mp4
│ [9.4]--8-4结构体数组.mp4
│ [9.5]--8-5结构体指针.mp4
│ [9.6]--8-6结构体与函数.mp4
│
├─{10}--创建新的类型（类与对象）
│ │ [10.1]--10-1面向对象介绍.mp4
│ │ [10.5]--10-11常对象与常成员函数.mp4
│ │ [10.6]--10-12常数据成员.mp4
│ │ [10.8]--10-15友元.mp4
│ │
│ ├─{02}--类的定义
│ │ [10.2.1]--10-2类的定义-概念.mp4
│ │ [10.2.2]--10-3类的定义-举例.mp4
│ │
│ ├─{03}--对象的使用
│ │ [10.3.1]--10-4对象的使用-对象的访问.mp4
│ │ [10.3.2]--10-5对象的使用-对象指针.mp4
│ │ [10.3.3]--10-6对象的使用-对象引用.mp4
│ │ [10.3.4]--10-7对象的使用-对象数组.mp4
│ │ [10.3.5]--10-8对象的使用-动态对象.mp4
│ │
│ ├─{04}--构造函数
│ │ [10.4.1]--10-9构造函数-定义及注意事项.mp4
│ │ [10.4.2]--10-10构造函数-对象数组的初始化.mp4
│ │
│ ├─{07}--静态数据成员与静态成员函数
│ │ [10.7.1]--10-13静态数据成员.mp4
│ │ [10.7.2]--10-14静态成员函数.mp4
│ │
│ └─{09}--对象的析构与拷贝构造
│ [10.9.1]--10-16对象的析构与拷贝构造--析构函数.mp4
│ [10.9.2]--10-17对象的析构与拷贝构造--拷贝构造函数.mp4
│ [10.9.3]--10-18对象的析构与拷贝构造--浅拷贝与深拷贝.mp4
│
├─{11}--运算符重载
│ │ [11.1]--11-1什么是运算符重载.mp4
│ │ [11.2]--11-2运算符重载的方法.mp4
│ │ [11.4]--11-5运算符重载实例.mp4
│ │
│ └─{03}--几个运算符的重载
│ [11.3.1]--11-3几个运算符的重载.mp4
│ [11.3.2]--11-4输入输出运算符重载.mp4
│
├─{12}--组合与继承
│ ├─{01}--组合
│ │ [12.1.1]--12-1类的组合-概念.mp4
│ │ [12.1.2]--12-2类的组合-组合对象的初始化.mp4
│ │ [12.1.3]--12-3类的组合-构造函数调用顺序.mp4
│ │
│ ├─{02}--继承
│ │ [12.2.1]--12-4继承-概念.mp4
│ │ [12.2.2]--12-5继承-单继承的格式.mp4
│ │ [12.2.3]--12-6继承-三种继承方式.mp4
│ │ [12.2.4]--12-7继承-派生类的构造函数和析构函数.mp4
│ │ [12.2.5]--12-8继承-派生类作为基类.mp4
│ │ [12.2.6]--12-9继承-派生类的实现方式.mp4
│ │ [12.2.7]--12-10继承-多继承.mp4
│ │
│ └─{03}--虚函数与多态性
│ [12.3.1]--12-11虚函数与多态性-类型兼容.mp4
│ [12.3.2]--12-12虚函数与多态性-多态性概念.mp4
│ [12.3.3]--12-13虚函数与多态性-虚函数的定义与使用.mp4
│ [12.3.4]--12-14虚函数与多态性-虚析构函数.mp4
│ [12.3.5]--12-15纯虚函数与抽象类.mp4
│
├─{13}--模板
│ [13.1]--13-1类模板-定义.mp4
│ [13.2]--13-2类模板-实例化及示例.mp4
│
├─{14}--输入输出和文件
│ │ [14.1]--14-1输入输出流介绍.mp4
│ │ [14.2]--14-2字符串流.mp4
│ │
│ └─{03}--文件输入输出
│ [14.3.1]--14-3文件的概念.mp4
│ [14.3.2]--14-4文件的打开.mp4
│ [14.3.3]--14-5文件的输出.mp4
│ [14.3.4]--14-6文件的输入.mp4
│ [14.3.5]--14-7文本文件的输入的小提醒.mp4
│
└─{15}--递归、回溯与分治
│ [15.4]--6-20分治法.mp4
│
├─{01}--递归
│ [15.1.1]--6-7递归函数-概念和阶乘程序.mp4
│ [15.1.2]--6-8递归函数-Fibonacci函数.mp4
│ [15.1.3]--6-9递归函数-汉诺塔问题.mp4
│ [15.1.4]--6-10递归函数-打印三角形.mp4
│ [15.1.5]--6-11递归函数-数字旋转方阵.mp4
│ [15.1.6]--6-12递归函数-理解递归执行流程.mp4
│
├─{02}--递归算法-全排列
│ [15.2.1]--6-13递归算法-全排列介绍.mp4
│ [15.2.2]--6-14递归算法-全排列算法1.mp4
│ [15.2.3]--6-15递归算法-全排列算法2.mp4
│
└─{03}--回溯法
[15.3.1]--6-16回溯法-概念介绍.mp4
[15.3.2]--6-17回溯法-分书问题.mp4
[15.3.3]--6-18回溯法-八皇后问题解析.mp4
[15.3.4]--6-19回溯法-八皇后问题算法.mp4