mirror of
https://github.com/142vip/408CSFamily.git
synced 2026-02-03 02:23:38 +08:00
Merge pull request #63 from mmdapl/docs/md
This commit is contained in:
微信公众号：储凡
217
README.md
217
README.md
@@ -1,4 +1,3 @@
|
||||
|
||||
<div align="center">
|
||||
<p>
|
||||
<img alt="408Logo图片" width="240" src="https://cdn.statically.io/gh/142vip/cdn_service@main/doc_book/408/408_logo.png" style="text-align: center;">
|
||||
@@ -109,24 +108,23 @@
|
||||
|
||||
## 大纲目录（善用Ctrl+F）
|
||||
|
||||
**注意：没有链接的，可以在仓库找找，只是选择性进行博客和公众号发表**
|
||||
**注意：没有链接的，可以在仓库找找，只是选择性进行博客和公众号发表**
|
||||
|
||||
### 数据结构
|
||||
|
||||
> 参考资料：
|
||||
>
|
||||
> 1. 《数据结构》 .
|
||||
> 2. 《大话数据结构》.
|
||||
> 3. 《数据结构与算法景点问题解析》 第二版 Narasimha Karumanchi著.
|
||||
> 4. 《计算机网络-王道考研》 2019 王道论坛著.
|
||||
> 参考资料
|
||||
> - 《数据结构》 .
|
||||
> - 《大话数据结构》.
|
||||
> - 《数据结构与算法景点问题解析》 第二版 Narasimha Karumanchi著.
|
||||
> - 《计算机网络-王道考研》 2019 王道论坛著.
|
||||
|
||||
#### [基础入门](./manuscripts/数据结构/基础入门/readme.md)
|
||||
#### 基础入门
|
||||
|
||||
- [基础概念](https://mp.weixin.qq.com/s/M8MOCVnbVxQ3GRuxRaEKIg)
|
||||
- [数据结构三要素](https://mp.weixin.qq.com/s/7sCoHDFtI-Qp0wBcvMH6kQ)
|
||||
- [算法与算法评价](https://mp.weixin.qq.com/s/58fBAwoyg2Ali-HqOJ6t9g)
|
||||
|
||||
#### [线性表](./manuscripts/数据结构/线性表/readme.md)
|
||||
#### 线性表
|
||||
|
||||
- [基础概念和基本操作](https://mp.weixin.qq.com/s/3e5LX9HbnjfT980zV3veXA)
|
||||
- [线性表的顺序表示](https://mp.weixin.qq.com/s/gaXmF3tqZxxFXhhDyPZv-A)
|
||||
@@ -139,118 +137,110 @@
|
||||
- [零碎知识补充](https://mp.weixin.qq.com/s?__biz=MzU3MTUxOTIwMw==&mid=2247485549&idx=2&sn=5282cd006b6c33e4bfe992298602e053&chksm=fcdfb1e1cba838f743a335bad530cf415eef57a417b807257d8ed6983047c2d57d5552b34cb0&token=1697862929&lang=zh_CN#rd)
|
||||
|
||||
|
||||
#### [栈和队列](Readme.md)
|
||||
#### 栈
|
||||
|
||||
- [栈的基本概念和基本操作](1.栈的基本概念和基本操作.md)
|
||||
- [栈的顺序存储结构](2.栈的顺序存储结构.md)
|
||||
- [栈的链式存储结构](3.栈链式存储结构.md)
|
||||
- [队列的基本概念和基础操作](4.队列的基本概念和基础操作.md)
|
||||
- [队列的顺序存储](5.队列的顺序存储结构.md)
|
||||
- [队列的链式存储](6.队列的链式存储结构.md)
|
||||
- [栈和队列的应用](栈和队列的应用.md)
|
||||
- [特殊矩阵的压缩存储](8.特殊矩阵的压缩存储.md)
|
||||
- 基本概念和操作
|
||||
- 顺序存储结构
|
||||
- 链式存储结构
|
||||
|
||||
#### 队列
|
||||
|
||||
- 基本概念和操作
|
||||
- 顺序存储结构
|
||||
- 链式存储结构
|
||||
|
||||
#### 串
|
||||
|
||||
- 基本概念
|
||||
- 简单的模式匹配
|
||||
- KMP算法
|
||||
|
||||
#### 树与二叉树
|
||||
|
||||
- 树
|
||||
- 定义
|
||||
- 术语
|
||||
- 性质
|
||||
- 基本概念
|
||||
- 二叉树
|
||||
- 定义和特性
|
||||
- 存储结构
|
||||
- 二叉树遍历
|
||||
- 线索二叉树
|
||||
- 二叉树遍历
|
||||
- 线索二叉树
|
||||
- 树和森林
|
||||
- 存储结构
|
||||
- 树、森林与二叉树转换
|
||||
- 遍历
|
||||
- 并查集应用
|
||||
- 树的应用
|
||||
- 二叉排序树
|
||||
- 平衡二叉树
|
||||
- 哈夫曼树
|
||||
- 哈夫曼编码
|
||||
|
||||
|
||||
#### 图论
|
||||
|
||||
- 基本概念
|
||||
- 图的存储
|
||||
- 图的遍历
|
||||
- 图的应用
|
||||
|
||||
|
||||
#### 查找
|
||||
|
||||
- 基本概念
|
||||
- 顺序查找
|
||||
- 折半查找
|
||||
- B树和B+树
|
||||
- 散列表
|
||||
|
||||
#### 排序
|
||||
|
||||
- 排序的基础概念
|
||||
- 直接排序
|
||||
- 交换排序之冒泡排序
|
||||
- 交换排序之快速排序
|
||||
- 基本概念
|
||||
- 插入排序
|
||||
- 交换排序
|
||||
- 选择排序
|
||||
- 归并排序
|
||||
- 基数排序
|
||||
- 内部排序算法的比较和应用
|
||||
- 外部排序的基本概念
|
||||
- 外部排序方法整理
|
||||
|
||||
|
||||
|
||||
|
||||
### 计算机网络
|
||||
|
||||
> 参考资料：
|
||||
>
|
||||
> 1. 《计算机网络》 第七版 谢希仁著.
|
||||
> 2. 《计算机网络-王道考研》 2019 王道论坛.
|
||||
|
||||
|
||||
|
||||
- [第一章：绪论]()
|
||||
- [第二章：物理层]()
|
||||
- [第三章：数据链路层]()
|
||||
- [第四章：网络层]()
|
||||
- [第五章：运输层]()
|
||||
- [第六章：应用层]()
|
||||
- [第七章：网络安全]()
|
||||
- [第八章：互联网上的音频/视频服务]()
|
||||
- [第九章：无线网络和移动网络]()
|
||||
|
||||
- 外部排序
|
||||
|
||||
|
||||
### 计算机操作系统
|
||||
|
||||
> 参考资料:
|
||||
>
|
||||
> 1. 《计算机操作系统》 第四版 汤小丹、梁红兵、汤子瀛著
|
||||
> 2. 《操作系统-王道考研》 2019 王道论坛
|
||||
> 参考资料
|
||||
> - 《计算机操作系统》 第四版 汤小丹、梁红兵、汤子瀛著
|
||||
> - 《操作系统-王道考研》 2019 王道论坛
|
||||
|
||||
#### 概述
|
||||
#### 系统概述
|
||||
|
||||
- 引论
|
||||
- 发展和分类
|
||||
- 运行环境
|
||||
- 体系结构
|
||||
|
||||
#### 进程管理
|
||||
|
||||
|
||||
- 进程和线程
|
||||
- 处理机调度
|
||||
- 进程同步
|
||||
- 死锁
|
||||
|
||||
|
||||
#### 内存管理
|
||||
|
||||
- 引论
|
||||
- 虚拟内存
|
||||
- 一些总结
|
||||
|
||||
#### 文件管理
|
||||
|
||||
- 基本概念
|
||||
- 文件系统
|
||||
- 磁盘管理
|
||||
- 一些总结
|
||||
|
||||
#### I/O管理
|
||||
|
||||
- 第一章：操作系统引论
|
||||
- 第二章：进程的描述与控制
|
||||
- 第三章：处理机调度与死锁
|
||||
- 第四章：存储器管理
|
||||
- 第五章：虚拟存储器
|
||||
- 第六章：虚拟存储器
|
||||
- 第七章：文件管理
|
||||
- 第八章：磁盘存储器的管理
|
||||
- 第九章：操作系统接口
|
||||
- 第十章：多处理机操作系统
|
||||
- 第十一章：多媒体操作系统
|
||||
- 第十二章：保护与安全
|
||||
#### 输入、输出管理
|
||||
|
||||
- 基本概述
|
||||
- 核心子系统
|
||||
- 高速缓存和缓冲区
|
||||
- 一些总结
|
||||
|
||||
|
||||
### 计算机组成原理
|
||||
|
||||
> 参考资料:
|
||||
> 1. 《计算机组成原理》 第二版 唐朔飞
|
||||
> 2. 《计算机组成原理-王道考研》 2019 王道论坛
|
||||
> 参考资料
|
||||
> - 《计算机组成原理》 第二版 唐朔飞
|
||||
> - 《计算机组成原理-王道考研》 2019 王道论坛
|
||||
|
||||
|
||||
#### 概述
|
||||
@@ -270,6 +260,61 @@
|
||||
#### 输入输出系统
|
||||
|
||||
|
||||
### 计算机网络
|
||||
|
||||
> 参考资料
|
||||
> - 《计算机网络-第七版》 谢希仁著.
|
||||
> - 《计算机网络-王道考研》 2019 王道论坛.
|
||||
|
||||
|
||||
#### 体系机构
|
||||
|
||||
- 基本介绍
|
||||
- 体系结构与参考模型
|
||||
|
||||
|
||||
#### 物理层
|
||||
|
||||
- 通信基础
|
||||
- 传输介质
|
||||
- 物理层设备
|
||||
|
||||
#### 数据链路层
|
||||
|
||||
- 基本功能
|
||||
- 组帧
|
||||
- 差错控制
|
||||
- 流量控制&可靠传输
|
||||
- 介质访问控制
|
||||
- 局域网
|
||||
- 广域网
|
||||
- 通信设备
|
||||
|
||||
#### 网络层
|
||||
|
||||
- 基本功能
|
||||
- 路由算法
|
||||
- 路由协议
|
||||
- IPV4
|
||||
- IPV6
|
||||
- IP组播&移动IP
|
||||
- 网络层设备
|
||||
|
||||
#### 传输层
|
||||
|
||||
- 提供的服务
|
||||
- UDP协议
|
||||
- TCP协议
|
||||
|
||||
|
||||
#### 应用层
|
||||
|
||||
- 应用模型
|
||||
- DNS
|
||||
- FTP协议
|
||||
- 电子邮件
|
||||
- HTTP协议
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -35,6 +35,9 @@ export default defineUserConfig({
|
||||
})();`
|
||||
]
|
||||
],
|
||||
// 配置永久链接，参考：https://v2.vuepress.vuejs.org/zh/reference/frontmatter.html#permalink
|
||||
// permalink: "/:year/:month/:day/:slug",
|
||||
// permalinkPattern: `:slug.html`,
|
||||
markdown: {
|
||||
// todo 引入代码文件时的路径替换
|
||||
importCode: {
|
||||
|
||||
@@ -6,10 +6,11 @@ export const navbar = [
|
||||
text: '首页',
|
||||
link: '/'
|
||||
},
|
||||
{
|
||||
text: "数据结构",
|
||||
link: "/manuscripts/ds"
|
||||
},
|
||||
// {
|
||||
// text: "数据结构",
|
||||
// link: "/manuscripts/ds"
|
||||
// },
|
||||
"/manuscripts/ds",
|
||||
{
|
||||
text: "操作系统",
|
||||
link: "/manuscripts/os"
|
||||
|
||||
@@ -14,21 +14,21 @@ export default {
|
||||
// HelloWorld: path.resolve(__dirname, '../components/HelloWorld.vue')
|
||||
// }
|
||||
}),
|
||||
searchProPlugin({
|
||||
// 索引全部内容
|
||||
indexContent: true,
|
||||
// 为分类和标签添加索引
|
||||
customFields: [
|
||||
{
|
||||
getter: (page: any) => page.frontmatter.category,
|
||||
formatter: "分类：$content",
|
||||
},
|
||||
{
|
||||
getter: (page) => page.frontmatter.tag,
|
||||
formatter: "标签：$content",
|
||||
},
|
||||
],
|
||||
}),
|
||||
// searchProPlugin({
|
||||
// // 索引全部内容
|
||||
// indexContent: true,
|
||||
// // 为分类和标签添加索引
|
||||
// customFields: [
|
||||
// {
|
||||
// getter: (page: any) => page.frontmatter.category,
|
||||
// formatter: "分类：$content",
|
||||
// },
|
||||
// {
|
||||
// getter: (page) => page.frontmatter.tag,
|
||||
// formatter: "标签：$content",
|
||||
// },
|
||||
// ],
|
||||
// }),
|
||||
// // md文档增强
|
||||
// mdEnhancePlugin({
|
||||
// // 文件导入
|
||||
|
||||
@@ -1,10 +1,65 @@
|
||||
|
||||
# 计算机网络
|
||||
|
||||
```mindmap
|
||||
root(计算机网络)
|
||||
体系机构
|
||||
物理层
|
||||
数据链路层
|
||||
网络层
|
||||
传输层
|
||||
应用层
|
||||
```
|
||||
|
||||
### 体系结构
|
||||
### 物理层
|
||||
### 数据链路层
|
||||
### 网络层
|
||||
### 传输层
|
||||
### 应用层
|
||||
## 体系机构
|
||||
|
||||
- 基本介绍
|
||||
- 体系结构与参考模型
|
||||
|
||||
|
||||
## 物理层
|
||||
|
||||
- 通信基础
|
||||
- 传输介质
|
||||
- 物理层设备
|
||||
|
||||
## 数据链路层
|
||||
|
||||
- 基本功能
|
||||
- 组帧
|
||||
- 差错控制
|
||||
- 流量控制&可靠传输
|
||||
- 介质访问控制
|
||||
- 局域网
|
||||
- 广域网
|
||||
- 通信设备
|
||||
|
||||
## 网络层
|
||||
|
||||
- 基本功能
|
||||
- 路由算法
|
||||
- 路由协议
|
||||
- IPV4
|
||||
- IPV6
|
||||
- IP组播&移动IP
|
||||
- 网络层设备
|
||||
|
||||
## 传输层
|
||||
|
||||
- 提供的服务
|
||||
- UDP协议
|
||||
- TCP协议
|
||||
|
||||
|
||||
## 应用层
|
||||
|
||||
- 应用模型
|
||||
- DNS
|
||||
- FTP协议
|
||||
- 电子邮件
|
||||
- HTTP协议
|
||||
|
||||
## 参考资料
|
||||
|
||||
-《计算机网络-第七版》谢希仁著.
|
||||
-《计算机网络-王道考研》2019 王道论坛.
|
||||
@@ -42,36 +42,43 @@ export const dsSidebar = [
|
||||
]
|
||||
},
|
||||
{
|
||||
text: '栈和队列',
|
||||
text: '栈',
|
||||
prefix: '栈和队列',
|
||||
collapsible: false,
|
||||
children: [
|
||||
{
|
||||
text: '栈-基本概念和操作',
|
||||
text: '基本概念和操作',
|
||||
link: '1.栈的基本概念和基本操作.md'
|
||||
},
|
||||
{
|
||||
text: '栈-顺序存储结构',
|
||||
text: '顺序存储结构',
|
||||
link: '2.栈的顺序存储结构.md'
|
||||
},
|
||||
{
|
||||
text: '栈-链式存储结构',
|
||||
text: '链式存储结构',
|
||||
link: '3.栈的链式存储结构.md'
|
||||
},
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
text: '队列',
|
||||
prefix: '栈和队列',
|
||||
collapsible: false,
|
||||
children: [
|
||||
{
|
||||
text: '队列-基本概念和操作',
|
||||
text: '基本概念和操作',
|
||||
link: '4.队列的基本概念和操作.md'
|
||||
}, {
|
||||
text: '队列-顺序存储结构',
|
||||
text: '顺序存储结构',
|
||||
link: '5.队列的顺序存储结构.md'
|
||||
},
|
||||
{
|
||||
text: '队列-链式存储结构',
|
||||
text: '链式存储结构',
|
||||
link: '6.队列的链式存储结构.md'
|
||||
},
|
||||
{
|
||||
text: '一些总结',
|
||||
link: '7.总结.md'
|
||||
text: '栈VS队列补充',
|
||||
link: '7.栈VS队列补充.md'
|
||||
}
|
||||
]
|
||||
},
|
||||
|
||||
@@ -1,5 +1,19 @@
|
||||
# 数据结构
|
||||
|
||||
```mindmap
|
||||
root(数据结构)
|
||||
基础入门
|
||||
线性表
|
||||
栈和队列
|
||||
队列
|
||||
串
|
||||
树与二叉树
|
||||
图论
|
||||
查找
|
||||
排序
|
||||
```
|
||||
|
||||
|
||||
## 基础入门
|
||||
|
||||
- [x] 基本概念
|
||||
@@ -14,7 +28,7 @@
|
||||
- [x] 链式表示
|
||||
- [x] 一些总结
|
||||
|
||||
## 栈和队列
|
||||
## 栈
|
||||
|
||||
- [x] 基本概念和操作
|
||||
- [x] 顺序存储结构
|
||||
@@ -29,12 +43,55 @@
|
||||
- [x] 一些总结
|
||||
|
||||
|
||||
## 串
|
||||
|
||||
- 基本概念
|
||||
- 简单的模式匹配
|
||||
- KMP算法
|
||||
|
||||
## 树与二叉树
|
||||
|
||||
- 基本概念
|
||||
- 二叉树
|
||||
- 二叉树遍历
|
||||
- 线索二叉树
|
||||
- 树和森林
|
||||
- 树的应用
|
||||
|
||||
|
||||
## 参考资料:
|
||||
## 图论
|
||||
|
||||
- 《数据结构》. 严蔚敏著
|
||||
- 《数据结构-王道考研》. 2019 王道论坛
|
||||
- 基本概念
|
||||
- 图的存储
|
||||
- 图的遍历
|
||||
- 图的应用
|
||||
|
||||
|
||||
## 查找
|
||||
|
||||
- 基本概念
|
||||
- 顺序查找
|
||||
- 折半查找
|
||||
- B树和B+树
|
||||
- 散列表
|
||||
|
||||
## 排序
|
||||
|
||||
- 基本概念
|
||||
- 插入排序
|
||||
- 交换排序
|
||||
- 选择排序
|
||||
- 归并排序
|
||||
- 基数排序
|
||||
- 外部排序
|
||||
|
||||
|
||||
|
||||
|
||||
## 参考资料
|
||||
|
||||
- 《数据结构》严蔚敏著.
|
||||
- 《数据结构-王道考研》2019 王道论坛.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,5 +1,10 @@
|
||||
---
|
||||
permalink: /test
|
||||
---
|
||||
# 基本概念和基本操作
|
||||
|
||||
## 基本概念
|
||||
|
||||
`栈`： 只允许在一端进行插入或者删除操作的**线性表**，`后进先出的线性表`。
|
||||
|
||||
|
||||
@@ -36,7 +41,7 @@
|
||||
可以得出结论：栈是后进先出（先进后出），即：LIFO（Last In First Out），也可以叫**后进先出的线性表**
|
||||
|
||||
|
||||
## 栈的基本操作
|
||||
## 基本操作
|
||||
|
||||
|
||||
- `InitStack(&S)`: 初始化一个空栈`S`，栈顶指针初始化为-1
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
> 指针指向栈顶（top）主要是因为栈在线性表的一端操作，操作的那端就是栈顶，方便操作。
|
||||
|
||||
|
||||
### 顺序栈的存储类型
|
||||
## 顺序栈的存储类型
|
||||
|
||||
```cpp
|
||||
// 定义栈中元素的最大个数
|
||||
@@ -42,7 +42,7 @@ typedef struct{
|
||||
|
||||
|
||||
|
||||
### 顺序栈的基本运算
|
||||
## 顺序栈的基本运算
|
||||
|
||||
|
||||
- `InitStack(&S)`: 初始化一个空栈`S`,栈顶指针初始化为-1
|
||||
@@ -53,7 +53,7 @@ typedef struct{
|
||||
- `ClearStack(&S)`: 销毁栈，释放栈`S`占用的存储空间。
|
||||
|
||||
|
||||
#### 初始化
|
||||
### 初始化
|
||||
|
||||
|
||||
`InitStack(&S)`: 初始化一个空栈`S`,栈顶指针初始化为-1
|
||||
@@ -68,7 +68,7 @@ void InitStack(&S){
|
||||
```
|
||||
|
||||
|
||||
#### 栈空判断
|
||||
### 栈空判断
|
||||
|
||||
`StackEmpty(S)`: 判断一个栈是否为空，即：栈顶指针是否为-1，如果栈空则返回`true`,否则返回`false`
|
||||
|
||||
@@ -87,7 +87,7 @@ bool StackEmpty(S){
|
||||
```
|
||||
|
||||
|
||||
#### 进栈
|
||||
### 进栈
|
||||
|
||||
|
||||
`Push(&S,x)`: 进栈，若栈未满，`x`进栈操作，插入到栈内成为`新的栈顶元素`。
|
||||
@@ -113,7 +113,7 @@ bool Push(SqStack &S,ElemType x){
|
||||
- 进栈先移动栈顶指针+1，再操作入栈元素
|
||||
- `++i`是简写，先对变量i进行递加操作，再进行使用，即：先加后用
|
||||
|
||||
#### 出栈
|
||||
### 出栈
|
||||
|
||||
`Pop(&S,&x)`: 出栈，若栈非空，出栈操作，**弹出栈顶元素**，用指针`x`进行返回。
|
||||
|
||||
@@ -141,7 +141,7 @@ bool Pop(SqStack &S,ElemType &x){
|
||||
|
||||
|
||||
|
||||
#### 读（获取）栈顶元素
|
||||
### 读（获取）栈顶元素
|
||||
|
||||
`GetTop(S,&x)`: 读栈顶元素，若栈`S`非空，用x返回栈顶元素。
|
||||
|
||||
@@ -178,7 +178,7 @@ bool GetTop(SqStack S,ElemType &x){
|
||||
|
||||
|
||||
|
||||
### 共享栈
|
||||
## 共享栈
|
||||
|
||||
|
||||
`共享栈`：利用栈底位置相对不变的特性，可以让两个顺序栈共享一个`一维存储空间`，将两个栈的栈底分别设置在共享空间的两端，两个栈顶则向共享空间的中间延伸
|
||||
@@ -196,7 +196,7 @@ bool GetTop(SqStack S,ElemType &x){
|
||||
当且仅当两个栈的栈顶指针相邻(`top1-top0=1`),可以判断共享栈栈满
|
||||
|
||||
|
||||
#### 进栈
|
||||
### 进栈
|
||||
|
||||
|
||||
> 进栈：先移动指针，后进行赋值
|
||||
@@ -205,7 +205,7 @@ bool GetTop(SqStack S,ElemType &x){
|
||||
- 当0号栈进栈时，0号栈栈顶指针top0`先加1后赋值`
|
||||
- 当1号栈进栈时，0号栈栈顶指针top1`先减1后赋值`
|
||||
|
||||
#### 出栈
|
||||
### 出栈
|
||||
|
||||
> 出栈：先进行赋值，后移动指针
|
||||
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
|
||||
# 栈的链式存储结构
|
||||
|
||||
`链栈`： 采用链式存储的栈
|
||||
@@ -43,14 +42,14 @@ typedef struct LinkStack
|
||||
|
||||
```
|
||||
|
||||
### 优点
|
||||
优点：
|
||||
|
||||
- 便于多个栈共享存储空间
|
||||
- 不存在栈满上溢的情况，避免程序因溢出导致出错
|
||||
- 有效的提高存取效率
|
||||
|
||||
|
||||
### 进栈
|
||||
## 进栈
|
||||
|
||||
- 如果链栈不存在，则栈满，入栈操作失败，返回false;
|
||||
- 如果链栈存在，进行单链表的结点插入操作，移动指针，结点元素赋值，再将结点压入链栈中，移动链栈栈顶指针，最后链栈元素总数+1，返回true
|
||||
@@ -88,7 +87,7 @@ bool linkStackPushNode(LinkStack* linkStack,int e){
|
||||
}
|
||||
```
|
||||
|
||||
### 出栈
|
||||
## 出栈
|
||||
|
||||
- 如果链栈不存在，或者为空栈，则无法进行出栈操作，返回false
|
||||
- 如果链栈满足出栈条件，则通过栈顶指针获取到链栈栈底结点，将其数据域赋值给变量e，移动栈顶指针指向待出栈元素的后继结点，同时释放待出栈元素的内存空间，链栈元素总数-1 ，出栈成功，返回true.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# 队列的基本概念和操作
|
||||
|
||||
|
||||
### 基本概念
|
||||
## 基本概念
|
||||
|
||||
`队列`：和栈一样，是一种操作受限制的线性表,只允许在表的一端进行插入，在表的另外一端进行删除，简称为`队`，常记作：`Queue`
|
||||
|
||||
@@ -29,7 +29,7 @@
|
||||
|
||||
|
||||
|
||||
### 基础操作
|
||||
## 基础操作
|
||||
|
||||
|
||||
> 和栈一样，队列是操作受限的线性表，具有`先进先出`的特性，不是任何对线性表的操作都可以作为队列的操作。例如：无法随便读取到队列中间的某个数据，需要将前面的元素先出队
|
||||
|
||||
@@ -75,7 +75,7 @@ typedef struct {
|
||||
|
||||
|
||||
|
||||
### 循环队列
|
||||
## 循环队列
|
||||
|
||||
在上面的顺序队列中，当队满后进行出队列，由于顺序队列出队只在队首进行操作，并且只会修改队首指针，这时候就会出现队尾指针一直`Q.rear===MaxSize`情况，就如下：
|
||||
|
||||
@@ -124,10 +124,10 @@ typedef struct {
|
||||
|
||||
|
||||
|
||||
#### 如何区别队空还是队满
|
||||
### 如何区别队空还是队满
|
||||
|
||||
> 为了很好的区别循环队列的`队空`还是`队满`的情况，一般有三种处理方式.
|
||||
##### 牺牲一个单元来区分队空和队满
|
||||
#### 牺牲一个单元来区分队空和队满
|
||||
|
||||
这种方式**要求在入队时少用一个队列单元**，是一种比较普遍的做法。约定：
|
||||
|
||||
@@ -138,7 +138,7 @@ typedef struct {
|
||||
- 队列中元素个数：`(Q.rear+MaxSize-Q.front)%MaxSize`
|
||||
|
||||
|
||||
##### 类型中增设表示元素个数的数据成员
|
||||
#### 类型中增设表示元素个数的数据成员
|
||||
|
||||
这种就很直接了，直接和MaxSize去比较，就可以有：
|
||||
|
||||
@@ -148,7 +148,7 @@ typedef struct {
|
||||
|
||||
值的注意的是：在这个前提下，不论是`队空`还是`队满`，对会存在`Q.front=Q.rear`,这个可以通过前面方案解决。
|
||||
|
||||
##### 类型中增设tag数据成员标记
|
||||
#### 类型中增设tag数据成员标记
|
||||
|
||||
通过添加tag标记的方式，区分`队空`还是`队满`
|
||||
|
||||
@@ -194,13 +194,13 @@ int DeLoopQueue(SqQueue &Q, ElemType &x){
|
||||
}
|
||||
|
||||
```
|
||||
#####
|
||||
####
|
||||
|
||||
|
||||
### 代码实现
|
||||
## 代码实现
|
||||
|
||||
|
||||
#### 初始化空队列
|
||||
### 初始化空队列
|
||||
|
||||
|
||||
```cpp
|
||||
@@ -217,7 +217,7 @@ void InitLoopQueque(&Q){
|
||||
}
|
||||
```
|
||||
|
||||
#### 队列是否为空
|
||||
### 队列是否为空
|
||||
|
||||
```cpp
|
||||
/*
|
||||
@@ -242,7 +242,7 @@ bool isEmpatyLoopQueue(Q){
|
||||
```
|
||||
|
||||
|
||||
#### 入队操作
|
||||
### 入队操作
|
||||
|
||||
```cpp
|
||||
/*
|
||||
@@ -273,7 +273,7 @@ bool EnLoopQueue(SqQueue &Q, ElemType x){
|
||||
|
||||
```
|
||||
|
||||
#### 出队操作
|
||||
### 出队操作
|
||||
|
||||
|
||||
```cpp
|
||||
@@ -309,8 +309,7 @@ bool DeLoopQueue(SqQueue &Q, ElemType &x){
|
||||
|
||||
```
|
||||
|
||||
#### 获取队头元素
|
||||
|
||||
### 获取队头元素
|
||||
```cpp
|
||||
/*
|
||||
* @Description: 获取循环队列队头元素
|
||||
|
||||
@@ -59,11 +59,11 @@ typedef struct{
|
||||
- 不存在队满情况，也不会出现溢出情况；
|
||||
- 链式队列不会出现存储分配不合理、“溢出”的情况，内存动态分配
|
||||
|
||||
### 基本操作
|
||||
## 基本操作
|
||||
|
||||
> Tips: 基于带头结点链式队列的基础操作
|
||||
|
||||
#### 队列初始化
|
||||
### 队列初始化
|
||||
|
||||
```cpp
|
||||
|
||||
@@ -89,7 +89,7 @@ voide InitLinkQueue(LinkQueue &Q){
|
||||
|
||||
> 链式队列，本质是基于单链表的队列，那带头结点的链式队列，其实强调的也就是单链表要带头结点。队列的队首指针和队尾指针确定指向单表的队首和队尾就ok；初始化的时候，带头结点的单链表实质就只有一个头结点。而此时的链式队列，需要将队首指针和队尾指针指向单链表的头结点就行，好像到这里就完了。但是这样却忽视了单链表，只是注重的队列的front和rear指针。单链表的结点元素是分数据域和指针域的，即便是头结点的数据域可以不存什么（当然也常会存一些链表信息什么的）,此处的`Q.front->next=NULL`就是用来处理链表的头结点的指针域的，让其指向下一个单链表元素为空，这里是非常需要处理的，非常细节！
|
||||
|
||||
#### 判断队空
|
||||
### 判断队空
|
||||
|
||||
```cpp
|
||||
|
||||
@@ -112,7 +112,7 @@ bool IsEmptyLinkQueue(LinkQueue Q){
|
||||
}
|
||||
```
|
||||
|
||||
#### 入队
|
||||
### 入队
|
||||
|
||||
|
||||
```cpp
|
||||
@@ -143,7 +143,7 @@ void EnLinkQueue(LinkQueue &Q, ElemType x){
|
||||
```
|
||||
|
||||
|
||||
#### 出队
|
||||
### 出队
|
||||
|
||||
```cpp
|
||||
|
||||
@@ -193,7 +193,7 @@ bool DeLinkQueue(LinkQueue &Q, ElemType &x){
|
||||
|
||||
|
||||
|
||||
### 双端队列
|
||||
## 双端队列
|
||||
|
||||
`双端队列`: 允许在两端都可以进行入队和出队操作的队列，元素的逻辑结构仍然是线性结构
|
||||
|
||||
@@ -216,7 +216,7 @@ bool DeLinkQueue(LinkQueue &Q, ElemType &x){
|
||||
|
||||
|
||||
|
||||
### 队列的补充
|
||||
## 知识补充
|
||||
|
||||
- 最适合用来链队的链表是：`带队首指针和队尾指针的非循环单链表`
|
||||
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
|
||||
# 栈和队列总结
|
||||
# 栈VS队列补充
|
||||
|
||||
> Tips: 这里不会做过多文字介绍相关应用，具体需要自己看书、查资料揣摩
|
||||
|
||||
|
||||
```mindmap
|
||||
root(栈和队列总结)
|
||||
root(栈VS队列补充)
|
||||
栈的应用
|
||||
队列的应用
|
||||
数组的定义
|
||||
@@ -1,20 +1,16 @@
|
||||
# 操作系统
|
||||
|
||||
|
||||
|
||||
```mindmap
|
||||
操作系统
|
||||
系统概述
|
||||
|
||||
进程管理
|
||||
|
||||
进程管理
|
||||
|
||||
文件管理
|
||||
|
||||
I/O管理
|
||||
输入、输出管理
|
||||
```
|
||||
|
||||
|
||||
|
||||
## 系统概述
|
||||
|
||||
- 引论
|
||||
@@ -24,16 +20,37 @@
|
||||
|
||||
## 进程管理
|
||||
|
||||
- 进程基本概念和特征
|
||||
- 进程的运行
|
||||
|
||||
- 进程和线程
|
||||
- 处理机调度
|
||||
- 进程同步
|
||||
- 死锁
|
||||
|
||||
|
||||
## 内存管理
|
||||
|
||||
- 引论
|
||||
- 虚拟内存
|
||||
- 一些总结
|
||||
|
||||
## 文件管理
|
||||
|
||||
## I/O管理
|
||||
- 基本概念
|
||||
- 文件系统
|
||||
- 磁盘管理
|
||||
- 一些总结
|
||||
|
||||
## 参考资料:
|
||||
|
||||
- 《计算机操作系统-第四版》. 汤小丹、梁红兵、汤子瀛著
|
||||
- 《操作系统-王道考研》. 2019 王道论坛
|
||||
## 输入、输出管理
|
||||
|
||||
- 基本概述
|
||||
- 核心子系统
|
||||
- 高速缓存和缓冲区
|
||||
- 一些总结
|
||||
|
||||
|
||||
|
||||
## 参考资料
|
||||
|
||||
- 《计算机操作系统》 第四版 汤小丹、梁红兵、汤子瀛著
|
||||
- 《操作系统-王道考研》 2019 王道论坛
|
||||
|
||||
@@ -1,71 +0,0 @@
|
||||
# 基础概念
|
||||
|
||||
### 数据
|
||||
|
||||
**信息的载体**，是客观事物属性的数、字符以及所有能够输入到计算机包中并且被计算机程序识别和处理的**集合**
|
||||
|
||||
### 数据元素
|
||||
|
||||
**数据的基本单位**，通常按照一个整数来进行考虑和处理。
|
||||
|
||||
|
||||
特别注意：一个数据元素由若干个**数据项**组成，数据项是构成数组元素的最小单位，且不可分割。
|
||||
|
||||
|
||||
|
||||
### 数据对象
|
||||
|
||||
具有**相同性质**的数据元素的**集合**，**是数据的子集**
|
||||
|
||||
|
||||
### 数据类型
|
||||
|
||||
值的集合和定义在此集合上一组操作的总称
|
||||
|
||||
- 原子类型：不可再分的数据类型；
|
||||
- 结构类型：可以分解成若干分量（成分）的数据类型；
|
||||
- **抽象数据类型**：抽象出具组织和其相关的操作；
|
||||
|
||||
|
||||
|
||||
### 抽象数据类型（ADT）
|
||||
|
||||
> Tips: 可以结合高级语言中类对象封装来理解；
|
||||
|
||||
```bash
|
||||
ADT抽象数据类型名{
|
||||
数据对象：<数据对象的定义>
|
||||
数据关系：<数据关系的定义>
|
||||
基本操作：<基本操作的定义>
|
||||
} ADT抽象数据类型名
|
||||
```
|
||||
|
||||
|
||||
|
||||
一个数学模型以及定义在该模型上的一组操作。定义仅仅取决于它的一组逻辑操作。与计算机内部如何表示和实现是没有关系；
|
||||
|
||||
**不论内部结构如何变化，只要其数学特性不变，就不会影响到外部的使用，实现了数据封装和信息隐藏**
|
||||
|
||||
|
||||
通常由（数据对象、数据关系、数据操作集）三元组来表示抽象数据类型；
|
||||
|
||||
抽象数据类型的主要作用是**数据封装和信息隐藏，让实现与使用相分离**。数据及其相关操作的结合称为数据封装。对象可以对其他对象隐藏某些操作细节，从而使这些操作不会受到其他对象的影响。
|
||||
|
||||
抽象数据类型独立于运算的具体实现，使用户程序只能通过抽象数据类型定义的某些操作来访问其中的数据，实现了信息隐藏。
|
||||
|
||||
|
||||
### 数据结构
|
||||
|
||||
|
||||
首先明确：数据元素都不是孤立存在的。元素与元素之间存在着某种关系，这种相互之间的关系就是**结构**。
|
||||
|
||||
**数据结构是相互之间存在一种或者多种特定关系的数据元素的集合**
|
||||
|
||||
- 逻辑结构
|
||||
- 存储结构（物理结构）
|
||||
- 数据运算
|
||||
|
||||
数据的逻辑结构和存储结构是密不可分的。
|
||||
|
||||
**算法的设计取决于所选定的逻辑结构；算法的实现依赖于所采用的存储结构；**
|
||||
|
||||
@@ -1,133 +0,0 @@
|
||||
# 数据结构三要素
|
||||
|
||||
- 数据的逻辑结构
|
||||
- 数据的存储结构
|
||||
- 数据的运算
|
||||
|
||||
|
||||
### 数据的逻辑结构
|
||||
|
||||
数据元素之间的逻辑关系，从逻辑关系上描述数据，叫做数据的逻辑结构。
|
||||
|
||||
与数据的存储（物理）结构无关，是独立于计算机的。
|
||||
|
||||
可以分为：
|
||||
|
||||
- 线性结构
|
||||
- 非线性结构
|
||||
|
||||
|
||||
线性表是典型的线性结构，衍生出的栈、队列、串、数组、广义表也都是线性结构；
|
||||
|
||||
非线性结构主要有：集合、树（一般树、二叉树）、图（有向图、无向图）
|
||||
|
||||
|
||||
特别注意：
|
||||
|
||||
- `集合`：结构中的数据元素之间**除了“同属于一个集合”的关系外，别无其他关系。**
|
||||
- `线性结构`：结构中的数据元素之间**只存在一对一的关系**。
|
||||
- `树形结构`：结构中的数据元素之间**存在一对多的关系。**
|
||||
- `图状结构和网状结构`：结构中的数据元素之间**存在多对多的关系。**
|
||||
|
||||
|
||||
|
||||
### 数据的存储（物理）结构
|
||||
|
||||
数据结构在计算机中的表示（映像）。包括数据`元素的表示`和`关系的表示`。
|
||||
|
||||
存储结构是逻辑结构用计算机语言实现的，依赖于计算机语言。
|
||||
|
||||
|
||||
可以分为：
|
||||
|
||||
- 顺序存储
|
||||
- 链式存储
|
||||
- 索引存储
|
||||
- 散列（Hash）存储
|
||||
|
||||
**注意：存储和存取的概念不一样**
|
||||
|
||||
#### 顺序存储
|
||||
|
||||
**逻辑上相邻的元素存储在物理位置上也相邻的存储单元里，元素之间的关系由存储单元的邻接关系来体现。**
|
||||
|
||||
优点：
|
||||
|
||||
- 可以实现随机存取
|
||||
- 元素占用最少的存储空间
|
||||
|
||||
缺点：
|
||||
|
||||
- 只能使用相邻的一整块存储单元，依赖于物理结构相邻；
|
||||
- 容易产生`外部碎片`
|
||||
|
||||
什么是内外部碎片？
|
||||
|
||||
> 参考资料：https://blog.csdn.net/qq_22238021/article/details/80209062
|
||||
|
||||
- 外部碎片：`还没有分配出去`（不属于任何进程），但是**由于大小而无法分配给申请内存空间的新进程的内存空闲块。**
|
||||
- 内部碎片：`已经被分配出去`（能明确指出属于哪个进程）的**内存空间大于请求所需的内存空间，不能被利用的内存空间就是内部碎片。**
|
||||
|
||||
|
||||
#### 链式存储
|
||||
|
||||
与顺序存储不同，**链式存储不要求逻辑上相邻的元素在物理位置上也相邻。**
|
||||
|
||||
借助指示元素存储地址的`指针`表示元素之间的逻辑关系。
|
||||
|
||||
|
||||
优点：
|
||||
|
||||
- 不会出现碎片现象
|
||||
- 充分利用所有存储单元
|
||||
|
||||
缺点：
|
||||
|
||||
- 除了存储元素外，还需要额外存储指针，会占用额外的存储空间（结合数据库索引学习）。
|
||||
- 链式存储，**只能实现`顺序存取`，不能实现`随机存取`（指针的遍历）**
|
||||
|
||||
|
||||
#### 索引存储
|
||||
|
||||
存放数据元素和元素间关系的存储方式，在存储元素信息的同时，还需要建立附加的`索引表`。
|
||||
|
||||
**索引表的每一项称为索引项，索引项的一般形式是：<关键字，地址>**
|
||||
|
||||
优点：
|
||||
|
||||
- 检索快（就好比字典有了目录，查询就很快了）
|
||||
|
||||
|
||||
缺点：
|
||||
|
||||
- 增加了索引表，占用较多的存储空间（典型的空间换时间策略）
|
||||
- 增加、删除数据时，需要对应修改索引表，花费更多时间。
|
||||
|
||||
#### 散列（Hash）存储
|
||||
|
||||
根据元素的关键字直接通过散列（Hash）函数计算出元素的存储地址。
|
||||
|
||||
|
||||
优点：
|
||||
|
||||
- 检索快，添加、删除元素结点操作快（获取元素地址直接，整体时间就少了）
|
||||
|
||||
|
||||
缺点：
|
||||
|
||||
- 非常依赖于`散列函数`
|
||||
- 会出现`散列冲突`（主要依赖与散列函数，散列函数不好就很容易出现散列冲突）
|
||||
- 出现`散列冲突`时，解决冲突就会增加时间和空间上的开销
|
||||
|
||||
|
||||
### 数据的运算
|
||||
|
||||
数据上的运算包括：`运算的定义` 、`运算的实现`
|
||||
|
||||
- `运算的定义`：针对逻辑结构，指出运算的功能
|
||||
- `原酸的实现`：针对存储结构，指出运算的具体操作步骤
|
||||
|
||||
|
||||
|
||||
|
||||
线性表既可以用顺序存储方式实现，也可以用链式存储方式实现。
|
||||
@@ -1,102 +0,0 @@
|
||||
# 算法和算法评价
|
||||
|
||||
|
||||
### 算法
|
||||
|
||||
`算法` ： 对特定问题求解步骤的一种描述，**是指令的有序集合**，每一条指令表示一个或多个操作。
|
||||
|
||||
|
||||
#### 重要特性
|
||||
|
||||
- `有穷性`：必须总是（对任何合法的输入值）在**执行有穷步后结束**，并且每一步都可**在有穷时间内完成**
|
||||
- `确定性`：每条指令的含义明确，不会产生二义性（歧义），**对相同的输入只能得出相同的结果**
|
||||
- `可行性`：算法是可行的。**算法中描述的操作都是可以通过已经实现的基本运算执行有限次来实现的**
|
||||
- `输入`：有零个或者多个输入，**输入取决于某个特定的对象的集合。**
|
||||
- `输出`：有一个或者多个输出，**输出是和输入有着某种特定关系的量（强调输出与输入的关系）**
|
||||
|
||||
|
||||
> **算法是有穷的，但是程序不一定满足有穷性**，程序只是算法在计算机上的特定的实现， 例如：死循环
|
||||
|
||||
#### 算法的目标
|
||||
|
||||
由于设计思路、解决问题方案等方面不同，不同算法之间也是有好坏的，就像人与人之间存在着差异。为设计出更好的算算法，往往需要追求更高的目标，而好的算法需要考虑到的目标就有：
|
||||
|
||||
- 正确性：首先算法肯定是**需要正确的解决求解问题**
|
||||
- 可读性：**算法应该具有良好的可读性**，就像项目代码一样，好的业务代码、逻辑清楚，**便于理解**。
|
||||
- 健壮性：**在输入非法数据时，算法也能适当地做出反应或进行处理，而不会产生莫名奇妙的输出结果**（在高级语言编程中，类似于强调封装方法的参数校验）
|
||||
- 效率与低存储量需求：**效率即算法执行的时间**，**存储量需求即算法那执行过程中所有要的最大存储空间**，这些与算法所解决问题的规模有关；
|
||||
|
||||
|
||||
> Tips： 效率可以结合时间复杂度来理解，存储量需求可以结合空间复杂度理解；
|
||||
|
||||
|
||||
### 效率的度量
|
||||
|
||||
算法效率的度量是通过`时间复杂度`和`空间复杂度`来描述的；
|
||||
|
||||
#### 时间复杂度
|
||||
|
||||
语句的频度：语句在算法中被重复执行的次数
|
||||
|
||||
算法中所有语句的`频度之和`记作T(n),即：对应算法问题规模n的函数，时间复杂度主要是来分析T(n)的数量级；
|
||||
|
||||
**算法的时间复杂度不仅依赖于问题的规模n，也取决于待输入的数据的性质（例如：输入元素的初始状态）**
|
||||
|
||||
上面这句话是不是不能理解？？？ 哈哈哈，我第一次看，也是！！
|
||||
|
||||
```c
|
||||
|
||||
int test(n) {
|
||||
if(n< 1){
|
||||
return 0;
|
||||
}
|
||||
// 循环叠加 输出
|
||||
.....
|
||||
}
|
||||
|
||||
|
||||
|
||||
```
|
||||
在这个简单的函数里
|
||||
|
||||
- 当n<1的时候，例如：-2，就不需要循环，此时时间复杂度可以理解为T(1)
|
||||
- 当n>1的时候，例如：5 此时时间复杂度可以理解为T(n)
|
||||
|
||||
当然，这里只是简单举例子便于理解：
|
||||
|
||||
> **算法的时间复杂度不仅依赖于问题的规模n，也取决于待输入的数据的性质（例如：输入元素的初始状态）**
|
||||
|
||||
|
||||
|
||||
- `最坏时间复杂度`：**最坏情况下**，算法的时间复杂度
|
||||
- `平均时间复杂度`：**所有可能输入实例在同等概率出现的情况下**，算法的期望运行时间
|
||||
- `最好时间复杂度`：**最好的情况下**，算法的时间复杂度
|
||||
|
||||
|
||||
一般情况下，考虑最坏情况的时间复杂度（即：最坏时间复杂度），保证算法的运行时间不会更长（最糟糕我都能预料，难道还有更糟糕？？？？？噗呲）
|
||||
|
||||
#### 空间复杂度
|
||||
|
||||
算法的空间复杂度可以用函数记作：S(n),**用来定义算法运行过程中需要耗费的存储空间**，是问题规模n的函数；
|
||||
|
||||
> 渐进空间复杂度也被称为空间复杂度，记作：S(n)=O(g(n))
|
||||
|
||||
|
||||
**一个程序除了需要存储空间来存放本身所用的指令、常数、变量和输入数据外，也需要对数据进行操作的工作单元和存储一些实现计算所需要信息的辅助空间。**
|
||||
|
||||
当输入数据所占用的空间只取决于问题本身，和算法无关时，只需要去分析除了输入和程序之外的额外空间
|
||||
|
||||
|
||||
|
||||
算法原地工作：算法所需要辅助空间是常量，记作S(1)，例如：
|
||||
|
||||
```c
|
||||
int switchValue(a,b){
|
||||
// 定义临时变量
|
||||
int temp=a;
|
||||
b=temp;
|
||||
a=b;
|
||||
}
|
||||
```
|
||||
|
||||
在上面的函数中，只是通过临时变量temp来实现a和b的值交换，没有需要更多变量，因此可以简单理解函数的在`原地工作`，辅助空间是常量，记作S(1)
|
||||
@@ -1,10 +0,0 @@
|
||||
## 基础入门
|
||||
|
||||
|
||||
### 主要内容
|
||||
|
||||
- [基础概念](1.基础概念.md)
|
||||
- [数据结构三要素](2.数据结构三要素.md)
|
||||
- [算法与算法评价](3.算法和算法评价.md)
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 752 KiB |
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@@ -1,51 +0,0 @@
|
||||
## 基本概念和基本操作
|
||||
|
||||
`栈`： 只允许在一端进行插入或者删除操作的**线性表**，`后进先出的线性表`。
|
||||
|
||||
|
||||
- 明确栈是一种线性表
|
||||
- 限定栈只能在某一端进行插入或者删除操作
|
||||
|
||||
|
||||
|
||||
`栈顶`：线性表允许进行插入和删除的一端。
|
||||
|
||||
`栈底`：不允许进行插入和删除的另外一端，是**固定的**。类似杯底这中概念
|
||||
|
||||
`空栈`：不含任何元素的空表，也叫**栈空**
|
||||
|
||||
|
||||
|
||||
基本结构如下：
|
||||
|
||||
|
||||
|
||||
|
||||
在上面的基本结构中，可以假设存在栈S=(a1,a2,a3,a4,a5,a6,a7,a8),很明显
|
||||
|
||||
- 栈顶元素：a1
|
||||
- 栈底元素：a8
|
||||
|
||||
|
||||
栈只能在栈顶进行插入和删除操作
|
||||
|
||||
- 进栈顺序：a1->a2->a3->a4->a5->a6->a7->a8
|
||||
- 出栈顺序：a8->a7->a6->a5->a4->a3->a2->a1
|
||||
|
||||
|
||||
可以得出结论：栈是后进先出（先进后出），即：LIFO（Last In First Out），也可以叫**后进先出的线性表**
|
||||
|
||||
|
||||
## 栈的基本操作
|
||||
|
||||
|
||||
- `InitStack(&S)`: 初始化一个空栈`S`，栈顶指针初始化为-1
|
||||
- `StackEmpty(S)`: 判断一个栈是否为空，如果栈空则返回`true`,否则返回`false`
|
||||
- `Push(&S,x)`: 进栈，若栈未满，`x`进栈操作，插入到栈内成为`新的栈顶元素`。
|
||||
- `Pop(&S,&x)`: 出栈，若栈非空，出栈操作，**弹出栈顶元素**，用指针`x`进行返回。
|
||||
- `GetTop(S,&x)`: 读栈顶元素，若栈`S`非空，用x返回栈顶元素。
|
||||
- `ClearStack(&S)`: 销毁栈，释放栈`S`占用的存储空间。
|
||||
|
||||
|
||||
|
||||
> Tips: `&`是C++特有的，可以用来表示引用调用，类似`传址目的`，可以类比指针。 当然，在C语言中*代表指针，指向存储地址，也是具有`传址目的`
|
||||
@@ -1,221 +0,0 @@
|
||||
|
||||
## 栈的顺序存储结构
|
||||
|
||||
|
||||
`顺序栈`：栈的顺序存储，利用一组地址连续的存储单元存放自栈底到栈顶的所有元素，同时**附加一个用来指向当前栈顶位置的指针**
|
||||
|
||||
> 指针指向栈顶（top）主要是因为栈在线性表的一端操作，操作的那端就是栈顶，方便操作。
|
||||
|
||||
|
||||
### 顺序栈的存储类型
|
||||
|
||||
```cpp
|
||||
// 定义栈中元素的最大个数
|
||||
# define MaxSize 50
|
||||
|
||||
// 结构体定义
|
||||
typedef struct{
|
||||
ElemType data[MaxSize]; // 存放栈中元素
|
||||
int top; // 栈顶指针
|
||||
}SqStack;
|
||||
|
||||
```
|
||||
|
||||
假设存在顺序栈S，则：
|
||||
|
||||
- 栈顶指针：S.top 初始化时设置S.top=-1
|
||||
- 栈顶元素：S.data[S.top]，其中S.top为栈顶指针
|
||||
- 进栈操作：栈不满时，栈顶指针+1，再送值到栈顶元素
|
||||
- 出栈操作：栈非空时，先取栈顶元素值，再将栈顶指针-1
|
||||
- 栈空条件：S.top=-1
|
||||
- 栈满条件：S.top=MaxSize-1
|
||||
- 栈长：S.top+1
|
||||
|
||||
|
||||
> Tips: 进栈先移动指针，避免占满，元素无法添加，出现外溢；出栈先取栈顶元素，保证指针永远指向栈顶。
|
||||
|
||||
|
||||
|
||||
顺序栈的存储结构体定义可以很明显看出，顺序栈的入栈操作会受到数组上界(MaxSize)的约束。
|
||||
|
||||
**当对栈的最大使用空间估计不足时，容易出现栈上溢(外溢)，需要主动向用户报告反馈，避免出现错误；**
|
||||
|
||||
|
||||
|
||||
### 顺序栈的基本运算
|
||||
|
||||
|
||||
- `InitStack(&S)`: 初始化一个空栈`S`,栈顶指针初始化为-1
|
||||
- `StackEmpty(S)`: 判断一个栈是否为空，如果栈空则返回`true`,否则返回`false`
|
||||
- `Push(&S,x)`: 进栈，若栈未满，`x`进栈操作，插入到栈内成为`新的栈顶元素`。
|
||||
- `Pop(&S,&x)`: 出栈，若栈非空，出栈操作，**弹出栈顶元素**，用指针`x`进行返回。
|
||||
- `GetTop(S,&x)`: 读栈顶元素，若栈`S`非空，用x返回栈顶元素。
|
||||
- `ClearStack(&S)`: 销毁栈，释放栈`S`占用的存储空间。
|
||||
|
||||
|
||||
#### 初始化
|
||||
|
||||
|
||||
`InitStack(&S)`: 初始化一个空栈`S`,栈顶指针初始化为-1
|
||||
|
||||
```cpp
|
||||
|
||||
void InitStack(&S){
|
||||
// 栈顶指针-1
|
||||
s.top=-1;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### 栈空判断
|
||||
|
||||
`StackEmpty(S)`: 判断一个栈是否为空，即：栈顶指针是否为-1，如果栈空则返回`true`,否则返回`false`
|
||||
|
||||
```C++
|
||||
|
||||
bool StackEmpty(S){
|
||||
if(S.top==-1){
|
||||
// 栈空
|
||||
return true;
|
||||
}else{
|
||||
// 栈非空
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### 进栈
|
||||
|
||||
|
||||
`Push(&S,x)`: 进栈，若栈未满，`x`进栈操作，插入到栈内成为`新的栈顶元素`。
|
||||
|
||||
```C++
|
||||
|
||||
bool Push(SqStack &S,ElemType x){
|
||||
if(S.top==MaxSize-1){
|
||||
// 栈满，返回false，元素无法进行进栈操作
|
||||
return false;
|
||||
}else{
|
||||
// 可进栈，栈顶指针+1，再元素入栈
|
||||
S.data[++S.top]=x;
|
||||
|
||||
// 入栈成功
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
注意：
|
||||
|
||||
- 进栈先移动栈顶指针+1，再操作入栈元素
|
||||
- `++i`是简写，先对变量i进行递加操作，再进行使用，即：先加后用
|
||||
|
||||
#### 出栈
|
||||
|
||||
`Pop(&S,&x)`: 出栈，若栈非空，出栈操作，**弹出栈顶元素**，用指针`x`进行返回。
|
||||
|
||||
```C++
|
||||
|
||||
bool Pop(SqStack &S,ElemType &x){
|
||||
if(S.top==-1){
|
||||
// 栈空，无栈顶元素可出栈，返回false
|
||||
return false;
|
||||
}else{
|
||||
// 栈非空，先元素出栈，再进行指针-1
|
||||
x=S.data[S.top--];
|
||||
|
||||
// 出栈成功，返回true
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
注意：
|
||||
|
||||
- 出栈操作，先让元素出栈，获取栈顶元素，再移动指针-1
|
||||
- `i--`是先使用变量i，再对变量做递减操作，即：先用后加（减）
|
||||
|
||||
|
||||
|
||||
#### 读（获取）栈顶元素
|
||||
|
||||
`GetTop(S,&x)`: 读栈顶元素，若栈`S`非空，用x返回栈顶元素。
|
||||
|
||||
```C++
|
||||
|
||||
bool GetTop(SqStack S,ElemType &x){
|
||||
|
||||
if(S.top==-1){
|
||||
// 栈空，无栈顶元素,返回false
|
||||
return false;
|
||||
}else{
|
||||
|
||||
// 通过栈顶指针，获取栈顶元素，赋值给变量x
|
||||
x=S.data[S.top];
|
||||
|
||||
// 读取栈顶元素成功，返回true
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
|
||||
**上面的这些操作都是基于栈顶指针初始化为`-1`的情况**
|
||||
|
||||
当栈顶指针初始化为`S.top=0`,相关操作操作会有区别：
|
||||
|
||||
- 入栈： `S.data[S.top++]=x`
|
||||
- 出栈： `x=S.data[--S.top]`
|
||||
|
||||
|
||||
**同时， 栈空、栈满条件也会有变化，要仔细对比揣摩**
|
||||
|
||||
|
||||
|
||||
### 共享栈
|
||||
|
||||
|
||||
`共享栈`：利用栈底位置相对不变的特性，可以让两个顺序栈共享一个`一维存储空间`，将两个栈的栈底分别设置在共享空间的两端，两个栈顶则向共享空间的中间延伸
|
||||
|
||||
>Tips: 类似头对头，一致对外这种感觉，噗呲哈哈
|
||||
|
||||
|
||||
|
||||
|
||||
在上面的共享栈结构图中，两个栈（0、1号顺序栈）的栈顶指针都指向栈顶元素
|
||||
|
||||
- 0号栈栈顶指针`top=-1`时，0号栈为空
|
||||
- 1号栈栈顶指针`top=MaxSize`时，1号栈为空
|
||||
|
||||
当且仅当两个栈的栈顶指针相邻(`top1-top0=1`),可以判断共享栈栈满
|
||||
|
||||
|
||||
#### 进栈
|
||||
|
||||
|
||||
> 进栈：先移动指针，后进行赋值
|
||||
|
||||
|
||||
- 当0号栈进栈时，0号栈栈顶指针top0`先加1后赋值`
|
||||
- 当1号栈进栈时，0号栈栈顶指针top1`先减1后赋值`
|
||||
|
||||
#### 出栈
|
||||
|
||||
> 出栈：先进行赋值，后移动指针
|
||||
|
||||
|
||||
- 当0号栈进栈时，0号栈栈顶指针top0`先赋值后减1`
|
||||
- 当1号栈进栈时，0号栈栈顶指针top1`先赋值后加1`
|
||||
|
||||
|
||||
|
||||
共享栈能够更有效的利用存储空间，两个栈空间进行相互调节。只有当这个存储空间（即：共享空间）被占满时才会发生上溢。存取数据的时间复杂度都为O(1)，在栈顶操作。
|
||||
|
||||
|
||||
**共享栈对存取效率没有什么影响**
|
||||
@@ -1,131 +0,0 @@
|
||||
|
||||
## 栈的链式存储结构
|
||||
|
||||
`链栈`： 采用链式存储的栈
|
||||
|
||||
`栈满`：对于链栈来说，是基于链式存储的，基本不存在栈满的情况，除非内存已经没有使用空间了。
|
||||
|
||||
`栈空`：对于空栈来说，链表原来的定义是头指针指向空，那么链栈的空其实就是`top＝NULL`,链栈元素总数为0
|
||||
|
||||
|
||||
栈只是栈顶在做插入和删除操作，栈顶应该放在单链表的头部，所以单链表中的头结点也就失去了意义。
|
||||
|
||||
**通常对于链栈来说，是不需要头结点的，当然也存在带头结点的链栈**
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
栈的链式存储类型：
|
||||
|
||||
```cpp
|
||||
|
||||
// 链栈类型定义【基础】
|
||||
typedef struct LinkNode{
|
||||
ElemType data; // 栈元素结点数据域
|
||||
struct LinkNode *next; // 栈元素结点指针域
|
||||
} *LinkStack;
|
||||
|
||||
// 更为详细的定义
|
||||
|
||||
typedef struct StackNode
|
||||
{
|
||||
int data;//结点数据域
|
||||
struct StackNode* next;//结点指针域
|
||||
}StackNode,* Linktop;
|
||||
|
||||
//链栈的数据结构
|
||||
typedef struct LinkStack
|
||||
{
|
||||
Linktop top; //栈顶结点,定义了一个指向上个结构体的指针
|
||||
int count;//元素个数
|
||||
}LinkStack;
|
||||
|
||||
```
|
||||
|
||||
### 优点
|
||||
|
||||
- 便于多个栈共享存储空间
|
||||
- 不存在栈满上溢的情况，避免程序因溢出导致出错
|
||||
- 有效的提高存取效率
|
||||
|
||||
|
||||
### 进栈
|
||||
|
||||
- 如果链栈不存在，则栈满，入栈操作失败，返回false;
|
||||
- 如果链栈存在，进行单链表的结点插入操作，移动指针，结点元素赋值，再将结点压入链栈中，移动链栈栈顶指针，最后链栈元素总数+1，返回true
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 基于单链表链栈的进栈操作
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-03-04 07:36:04
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-03-04 11:39:16
|
||||
*/
|
||||
bool linkStackPushNode(LinkStack* linkStack,int e){
|
||||
|
||||
// 判断链栈是否存在
|
||||
if (!linkStack){
|
||||
//链栈不存在，无法进栈操作，返回false
|
||||
return false;
|
||||
}
|
||||
// 开辟栈结点元素内存控件
|
||||
StackNode* node = (StackNode*)malloc(sizeof(StackNode));
|
||||
// 新结点指针域指向链表，即栈顶指针位置，元素加入链表
|
||||
node->next = linkStack->top;
|
||||
// 新结点数据域赋值
|
||||
node->data = e;
|
||||
// 元素进栈，移动栈顶指针，指向新入栈的元素
|
||||
linkStack->top = node;
|
||||
// 链栈元素总数+1
|
||||
linkStack->count++;
|
||||
//链栈入栈成功，返回true
|
||||
return true;
|
||||
}
|
||||
```
|
||||
|
||||
### 出栈
|
||||
|
||||
- 如果链栈不存在，或者为空栈，则无法进行出栈操作，返回false
|
||||
- 如果链栈满足出栈条件，则通过栈顶指针获取到链栈栈底结点，将其数据域赋值给变量e，移动栈顶指针指向待出栈元素的后继结点，同时释放待出栈元素的内存空间，链栈元素总数-1 ，出栈成功，返回true.
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 基于单链表链栈的出栈操作
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-03-04 23:38:04
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-03-04 23:39:16
|
||||
*/
|
||||
bool linkStackPopNode(LinkStack* linkStack,int *e){
|
||||
// 判断链栈是否存在及是否为空
|
||||
if (!linkStack || linkStack->count==0){
|
||||
//出栈失败，返回false
|
||||
return false;
|
||||
}
|
||||
// 获取栈顶元素结点
|
||||
StackNode* node = stack->top;
|
||||
|
||||
// 结点元素数据域赋值给变量e
|
||||
*e = linkStack->data;
|
||||
// 移动栈顶指向，栈顶指针指向待出栈结点的后继结点
|
||||
linkStack->top = node->next;
|
||||
// 变量e已被赋值，释放链栈出栈元素的内存控件
|
||||
free(node);
|
||||
// 链栈元素个数-1
|
||||
linkStack->count--;
|
||||
// 出栈成功，返回true.
|
||||
return true;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
以上是基于单链表的链栈入栈、出栈操作，很明显**时间复杂度都为O(1）**,重点`注意移动指针，保持不断链`
|
||||
@@ -1,42 +0,0 @@
|
||||
## 队列的基本概念和基础操作
|
||||
|
||||
|
||||
### 基本概念
|
||||
|
||||
`队列`：和栈一样，是一种操作受限制的线性表,只允许在表的一端进行插入，在表的另外一端进行删除，简称为`队`，常记作：`Queue`
|
||||
|
||||
`入队`： 向队列中插入元素，也叫做`进队`
|
||||
|
||||
`出队`： 删除队列元素，也叫做`离队`
|
||||
|
||||
|
||||
|
||||
|
||||
结合生活中排队的经验，在群体素质高、无人插队的情况下(`薛定谔排队`,噗呲，哈哈哈),**一般最早排队的也是最早离队的**，和栈的`后进先出`不一样的是，队列是`先进先出`的，即：First In Frist Out
|
||||
|
||||
> Tips
|
||||
> - 栈：又叫做后进先出的线性表
|
||||
> - 队列：又叫做先进先出的线性表
|
||||
|
||||
|
||||
|
||||
`队头`：允许进行删除操作的一端，也叫做`队首`，常记作：`Front`
|
||||
|
||||
`队尾`：允许进行插入操作的一端，常记作：`Rear`
|
||||
|
||||
`空队列`：不含任何元素的空表，注意这个表是指`线性表`
|
||||
|
||||
|
||||
|
||||
|
||||
### 基础操作
|
||||
|
||||
|
||||
> 和栈一样，队列是操作受限的线性表，具有`先进先出`的特性，不是任何对线性表的操作都可以作为队列的操作。例如：无法随便读取到队列中间的某个数据，需要将前面的元素先出队
|
||||
|
||||
|
||||
- `InitQueue(&Q)`： 初始化一个队列，构造空队列Q
|
||||
- `QueueEmpty(Q)`： 判断队列是否为空，队空返回true,否则返回false
|
||||
- `EnEmpty(&Q,x)`： 入队，如果队列Q未满，将x入队，成为新的队尾元素
|
||||
- `DeEmpty(&Q,&x)`： 出队，如果队列Q非空，删除队头元素，复制给x返回
|
||||
- `GetHead(Q,&x)`： 读取队头元素，如果队列Q非空，则将队头元素赋值给x
|
||||
@@ -1,337 +0,0 @@
|
||||
|
||||
## 队列的顺序存储结构
|
||||
|
||||
|
||||
> 队列的顺序实现是指分配一块连续的存储单元用来存放队列中的元素，并且附加两个指针。
|
||||
> - `front指针`： 指向队头元素的位置
|
||||
> - `rear指针`： 指向队尾元素的位置
|
||||
|
||||
队列顺序存储类型：
|
||||
|
||||
```cpp
|
||||
// 队列最大存储元素个数
|
||||
#define MaxSize 50
|
||||
|
||||
// 结构体定义
|
||||
typedef struct {
|
||||
// 存放队列元素
|
||||
ElemType data[MaxSize];
|
||||
// 队头指针和队尾指针
|
||||
int front,rear;
|
||||
} SqQueue;
|
||||
```
|
||||
|
||||
|
||||
假定：
|
||||
|
||||
- 队头指针指向队头元素
|
||||
- 队尾指针指向队尾元素的下一个位置
|
||||
|
||||
则：
|
||||
|
||||
- 初始状态（**队空条件**）：`Q.front`===`Q.rear`===0
|
||||
- 入队操作：队不满时，先赋值给队尾元素，再移动队尾指针+1
|
||||
- 出队操作： 队不空时，先取队头元素值，再移动队头指针+1
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
在空队列中，初始状态为`Q.front===Q.rear==0`,当元素a入队时,队尾指针rear后移+1，入队成功后，`Q.front==0`、`Q.rear==1`，在队不满的情况下进队，都是`先赋值给队尾元素，再移动队尾指针rear+1`,通过上面的图宝贝可以看到，队列被元素打满的时：
|
||||
|
||||
- 在这个进队的过程中，没有元素出队，队头指针并没有做改变，`Q.front==0`
|
||||
- 进队操作直接影响队尾指针的变化，队列满的时候`Q.rear==Maxsize`
|
||||
|
||||
> Tips: MaxSize为队列结构体定义中，最大存储元素个数哦~
|
||||
|
||||
|
||||
|
||||
|
||||
进队说完了，那给宝贝来说说出队吧。以上图为例，队列中`Q.rear==Maxsize`、`Q.front==0`；当出现元素在队首出队，就会直接影响队首指针，从上面的流程上看：
|
||||
|
||||
- 元素出队，front指针后移+1，在队不空的情况下，操作为：`先取队头元素值，再移动队头指针+1`
|
||||
|
||||
- 当队列中的元素都陆续出队，抛弃了宝贝（都是渣男，噗呲，哈哈哈），指针会是：`Q.rear==Q.front==MaxSize`
|
||||
|
||||
|
||||
|
||||
从上面两张图中，我们来思考：
|
||||
|
||||
> 前面队空条件为：`Q.front===Q.rear===0`,那能用`Q.rear==MaxSize`来表示队满嘛？
|
||||
|
||||
|
||||
傻瓜，你在瞅瞅前面的图，明显存在`Q.rear==MaxSize`，但队列确实空的情况呀。队满要灵活判断，可不要死记书上总结的。书上说的很多结论都是有前提的，老师记结论不记前提容易张冠李戴、含糊不清的呀~
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
很显然，也存在下面这种情况：
|
||||
|
||||
- 队头指针指向队头元素的前一个位置
|
||||
- 队尾指针指向队尾元素
|
||||
|
||||
此时的入队、出队过程就宝贝自己去画流程图咯
|
||||
|
||||
|
||||
|
||||
### 循环队列
|
||||
|
||||
在上面的顺序队列中，当队满后进行出队列，由于顺序队列出队只在队首进行操作，并且只会修改队首指针，这时候就会出现队尾指针一直`Q.rear===MaxSize`情况，就如下：
|
||||
|
||||
|
||||
|
||||
|
||||
可以很明显的看到，明明队列不满，但是由于进队列只能在队尾操作，因此不能进行进队操作；通常在这种情况下入队就会出现“上溢出”。
|
||||
|
||||
> 需要明确的是：上溢出并不是真正的溢出，只是表明在顺序队列中队不满却无法入队的情况，是一种假的”溢出“
|
||||
|
||||
|
||||
|
||||
|
||||
这种情况在顺序队列中是非常常见的，也是顺序队列的一大缺点。为了克服这个缺点，计算机先贤们总是能够有很多很好的办法，这里不得不佩服！！，所以就有了循环队列，**一个将顺序队列臆想为一个环状的空间**
|
||||
|
||||
|
||||
> 很多时候就是这样，为了解决一个问题，从而衍生出一个新的知识
|
||||
|
||||
|
||||
`循环队列`：把顺序队列臆想为一个环状的空间，将存储队列元素的表从逻辑上看做为一个环
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
当队首指针`Q.front=MaxSize-1`后，再有元素`出队`就前进一个位置自动到位置0了【注意：可以结合时钟来理解，一圈转完了】
|
||||
|
||||
|
||||
- 初始时：`Q.front=Q.rear=0`
|
||||
- 队首指针进1： `Q.front=(Q.front+1)%MaxSize`
|
||||
- 队尾指针进1： `Q.rear=(Q.rear+1)%MaxSize`
|
||||
- 队列长度： `(Q.rear+MaxSize-Q.front)%MaxSize`
|
||||
|
||||
|
||||
> 是不是理解起来有点抽象，其实我最开始学到这里的时候，也不明白为什么要用`除法取余运算（%）`来实现。后来我看看了手机上的时钟指针，一圈两圈三圈的转，好像就开始悟了...其实这种取余操作在计算机知识体系中还是非常常见的，例如：组成原理中将会学到的补码，据说idea就是来源于时钟..
|
||||
|
||||
|
||||
**和时钟一样，顺时钟进行时间变换，在出队、入队时，队首、队尾指针都是按顺时针方向进1**
|
||||
|
||||
|
||||
|
||||
|
||||
如上图，循环队列从最开始初始化为空队列时:`Q.front==Q.rear==0`,经过元素a入队，队尾指针顺时针前移`Q.rear+1`，到元素a、b、c、d陆续入队，就好像时钟转完了一圈，循环队列已满，此时发现：`Q.front==Q.rear==0`在队满时候依然成立，所以结合前面提到的初始化对空条件:`Q.front==Q.rear==0`,用`Q.front==Q.rear`来区分`队空`和`队满`是非常不合适的。
|
||||
|
||||
|
||||
|
||||
|
||||
#### 如何区别队空还是队满
|
||||
|
||||
> 为了很好的区别循环队列的`队空`还是`队满`的情况，一般有三种处理方式.
|
||||
##### 牺牲一个单元来区分队空和队满
|
||||
|
||||
这种方式**要求在入队时少用一个队列单元**，是一种比较普遍的做法。约定：
|
||||
|
||||
**队头指针在队尾指针在队尾指针的下一个位置作为队满标志【重要】**
|
||||
|
||||
- 队满条件：`(Q.rear+1)%MaxSize==Q.front`
|
||||
- 队空条件：`Q.front==Q.rear`
|
||||
- 队列中元素个数：`(Q.rear+MaxSize-Q.front)%MaxSize`
|
||||
|
||||
|
||||
##### 类型中增设表示元素个数的数据成员
|
||||
|
||||
这种就很直接了，直接和MaxSize去比较，就可以有：
|
||||
|
||||
- 队空条件： `Q.count=0`
|
||||
- 队满条件： `Q.count=MaxSize`
|
||||
|
||||
|
||||
值的注意的是：在这个前提下，不论是`队空`还是`队满`，对会存在`Q.front=Q.rear`,这个可以通过前面方案解决。
|
||||
|
||||
##### 类型中增设tag数据成员标记
|
||||
|
||||
通过添加tag标记的方式，区分`队空`还是`队满`
|
||||
|
||||
- `tag==0`的情况下，如果因为删除导致`Q.front==Q.rear`，则队空；
|
||||
- `tag==1`的情况下，如果因为插入导致`Q.front==Q.rear`，则队满；
|
||||
|
||||
可能你会对上面的这两种情况有迷惑，说实话我第一次看的时候，也挺迷惑的，这里我按照我的理解来解释一下：
|
||||
|
||||
> 在循环队列中增加tag数据成员标记，tag的主要作用：
|
||||
> - 在有元素入队的时候，设置tag=1
|
||||
> - 在有元素出队的时候，设置tag=0
|
||||
|
||||
|
||||
对应的算法实现：
|
||||
```cpp
|
||||
// 入队算法
|
||||
// 尾插法：Q.data[Q.rear]=x;Q.rear=(Q.rear+1)%Maxsize;Q.tag=1
|
||||
// 队空条件：Q.front== Q.rear且Q.tag==0
|
||||
int EnLoopQueue(SqQueue &Q, ElemType x){
|
||||
if(Q.front==Q.rear&&Q.tag==1){
|
||||
return 0;
|
||||
}
|
||||
Q.data[Q.rear]=x;
|
||||
Q.rear=(Q.rear+1)%MaxSize;
|
||||
Q.tag=1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// 出队算法
|
||||
// 头结点删除：x=Q.data[Q.front];Q.front=(Q.front +1)%Maxsize;Q.tag=0
|
||||
// 队满条件：Q.front == Q.rear且Q.tag=1
|
||||
// 注意：当删除之后链表为空时，还需增加一步，将尾指针指向头结点
|
||||
int DeLoopQueue(SqQueue &Q, ElemType &x){
|
||||
if (Q.front==Q.rear&&Q.tag==0){
|
||||
return 0;
|
||||
}
|
||||
x=Q.data[Q.front];
|
||||
Q.front=(Q.front+1)%MaxSize;
|
||||
Q.tag=0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
```
|
||||
#####
|
||||
|
||||
|
||||
### 代码实现
|
||||
|
||||
|
||||
#### 初始化空队列
|
||||
|
||||
|
||||
```cpp
|
||||
/*
|
||||
* @Description: 循环队列初始化，队列为空
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2019-09-27 14:17:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-18 22:15:06
|
||||
*/
|
||||
void InitLoopQueque(&Q){
|
||||
Q.front=Q.rear=0;
|
||||
}
|
||||
```
|
||||
|
||||
#### 队列是否为空
|
||||
|
||||
```C++
|
||||
/*
|
||||
* @Description: 判断循环队列是否为空
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2019-09-27 14:17:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-18 22:15:06
|
||||
*/
|
||||
bool isEmpatyLoopQueue(Q){
|
||||
// 注意循环队列对空条件：Q.rear=Q.front
|
||||
if(Q.rear=Q.front){
|
||||
// 队空
|
||||
return true;
|
||||
}else{
|
||||
// 非空
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### 入队操作
|
||||
|
||||
```C++
|
||||
/*
|
||||
* @Description: 循环队列元素入队
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2019-09-27 14:17:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-18 22:15:06
|
||||
*/
|
||||
bool EnLoopQueue(SqQueue &Q, ElemType x){
|
||||
// 判断循环队列是否已满 注意判断条件：(Q.rear+1)%MaxSize===Q.front
|
||||
if((Q.rear+1)%MaxSize===Q.front){
|
||||
// 循环队列满
|
||||
return false;
|
||||
}
|
||||
// 队列未满，可进行入队操作【队尾进行】
|
||||
|
||||
// 队尾指针指向的数据域进行赋值
|
||||
Q.data[Q.rear]=x;
|
||||
|
||||
//队尾指针后移+1【类似时钟的顺时针方向】
|
||||
Q.rear=((Q.rear+1)%MaxSize);
|
||||
|
||||
// 入队成功，返回true
|
||||
return true;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
#### 出队操作
|
||||
|
||||
|
||||
```C++
|
||||
|
||||
/*
|
||||
* @Description: 循环队列元素出队
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2019-09-27 14:17:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-18 20:32:18
|
||||
*/
|
||||
bool DeLoopQueue(SqQueue &Q, ElemType &x){
|
||||
|
||||
// 判断循环队列是否为空队列
|
||||
if(Q.rear==Q.front){
|
||||
|
||||
// 队列为空，无法进行出队操作，返回false
|
||||
return false;
|
||||
}
|
||||
|
||||
// 循环队列非空,元素可出队【队首操作】
|
||||
|
||||
// 将循环队列队首指针指向的元素的数据域赋值给变量x
|
||||
x=Q.data[Q.front];
|
||||
|
||||
// 移动队首指针，顺时针后移+1
|
||||
Q.front=(Q.front+1)%MaxSize;
|
||||
|
||||
// 出队成功，返回true
|
||||
return true;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
#### 获取队头元素
|
||||
|
||||
```C++
|
||||
/*
|
||||
* @Description: 获取循环队列队头元素
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2019-09-27 14:17:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-18 20:15:33
|
||||
*/
|
||||
bool GetLoopQueueHead(SqQueue &Q, ElemType &x){
|
||||
// 判断循环队列是否为空队列
|
||||
if(Q.front==Q.rear){
|
||||
// 队列为空，没有队头元素，返回false
|
||||
return false;
|
||||
}else{
|
||||
// 获取队头指针指向元素的数据域，赋值给x
|
||||
x=Q.data[Q.front];
|
||||
|
||||
// 获取队头元素成功，返回true
|
||||
return true;
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -1,231 +0,0 @@
|
||||
|
||||
## 队列的链式存储结构
|
||||
|
||||
`链队列`：和顺序队列一样，基于队列的链式表示叫做`链队列`，实际上为：**一个同时带有队头指针和队尾指针的单链表**
|
||||
|
||||
- 头指针指向队头结点
|
||||
- 尾指针指向队尾结点（单链表的最后一个结点）
|
||||
|
||||
|
||||
这里复习下顺序队列的定义，进行比较学习
|
||||
|
||||
> 队列的顺序实现是指分配一块连续的存储单元用来存放队列中的元素，并且附加两个指针。
|
||||
> - 队头指针指向队头元素
|
||||
> - 队尾指针指向队尾元素的下一个位置
|
||||
|
||||
|
||||
|
||||
|
||||
队列的链式存储结构：
|
||||
|
||||
|
||||
```cpp
|
||||
// 链式队列节点定义
|
||||
typedef struct{
|
||||
// 结果点数据域
|
||||
ElemType data;
|
||||
// 结点指针域
|
||||
struct LinkNode *next;
|
||||
}LinkNode;
|
||||
|
||||
// 链式队列定义
|
||||
typedef struct{
|
||||
// front 队头指针，rear 队尾指针
|
||||
LinkNode *front,*rear;
|
||||
}LinkQueue;
|
||||
|
||||
```
|
||||
|
||||
结合上面的`不带头结点`链式队列结构图，假设存在链式队列<LinkQueue,linkQueue>
|
||||
|
||||
- 队空： `linkQueue.front==NULL`且`linkQueue.rear==NULL`
|
||||
- 出队： 先判断队列是否为空，非空队列则取出队头元素，从链表中闪出去，`队头指针Q.front指向下一个结点`，如果出队的结此为尾结点，出队后队空，需要将Q.front和Q.rear都置为NULL
|
||||
- 入队： 建立一个新的结点，将新的结点插入到链表的尾部，修改队尾指针Q.rear指向新插入的结点。如果原队列为空，需要将队首指针也指向该结点
|
||||
|
||||
仔细思考上面的入队、出队操作，都需要考虑队空的情况下的特殊处理，不带头结点的队列导致队空队首和队尾指针都为NULL，比较麻烦；结合之前整理、学习过的单链表，套用一下先贤的思路，也整上一个头结点，就会发现容易处理很多；
|
||||
|
||||
|
||||
|
||||
链式队列加上头结点后，之前较为复杂的入队、出队操作就统一起来了。
|
||||
|
||||
- 队空：`Q.front==Q.rear`,都指向头结点，一般数据域可以为空
|
||||
- 出队：判断队列是否为空，队列非空则在队首移动指针，将队首指针指向下一个元素。如果队列中就一个元素，则出队后将成为空队，`Q.rear==Q.front`,最后释放元素内存空间。
|
||||
- 入队：将元素插入队尾，移动队尾指针，即便为空队列入队，由于队列带有头结点，此时就很好的避免操作队首指针了。
|
||||
|
||||
|
||||
特别注意：
|
||||
|
||||
- 用单链表表示的链式队列非常适合频繁出队、入队、元素变化大的场景
|
||||
- 不存在队满情况，也不会出现溢出情况；
|
||||
- 链式队列不会出现存储分配不合理、“溢出”的情况，内存动态分配
|
||||
|
||||
### 基本操作
|
||||
|
||||
> Tips: 基于带头结点链式队列的基础操作
|
||||
|
||||
#### 队列初始化
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 链式队列初始化
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-06-27 14:17:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-02-18 22:15:06
|
||||
*/
|
||||
voide InitLinkQueue(LinkQueue &Q){
|
||||
|
||||
// 创建头结点
|
||||
Q.front=Q.rear=(LinkNode*)malloc(sizeof (LinkNode));
|
||||
|
||||
// 头结点的指针域指向的下一个结点为空
|
||||
Q.front->next=NULL;
|
||||
}
|
||||
```
|
||||
|
||||
注意这个初始化操作，我第一次看的时候，非常不理解为什么在队首指针和队尾指针都指向已经创建好的头结点后，突然写一行`Q.front->next=NULL;`,后来的的理解是：
|
||||
|
||||
> 链式队列，本质是基于单链表的队列，那带头结点的链式队列，其实强调的也就是单链表要带头结点。队列的队首指针和队尾指针确定指向单表的队首和队尾就ok；初始化的时候，带头结点的单链表实质就只有一个头结点。而此时的链式队列，需要将队首指针和队尾指针指向单链表的头结点就行，好像到这里就完了。但是这样却忽视了单链表，只是注重的队列的front和rear指针。单链表的结点元素是分数据域和指针域的，即便是头结点的数据域可以不存什么（当然也常会存一些链表信息什么的）,此处的`Q.front->next=NULL`就是用来处理链表的头结点的指针域的，让其指向下一个单链表元素为空，这里是非常需要处理的，非常细节！
|
||||
|
||||
#### 判断队空
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 判断链式队列是否为空
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-06-27 14:24:22
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-02-16 22:15:06
|
||||
*/
|
||||
bool IsEmptyLinkQueue(LinkQueue Q){
|
||||
if(Q.front==Q.rear){
|
||||
// 队首、队尾指针指向同一个结点内存地址，队空
|
||||
return true;
|
||||
}else{
|
||||
// 非空
|
||||
return false;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### 入队
|
||||
|
||||
|
||||
```cpp
|
||||
/*
|
||||
* @Description: 链式队列入队操作
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-06-46 14:17:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-02-18 22:15:06
|
||||
*/
|
||||
void EnLinkQueue(LinkQueue &Q, ElemType x){
|
||||
|
||||
//创建入队结点元素
|
||||
node=(LinkNode *)malloc(sizeof(LinkNode));
|
||||
|
||||
// 赋值给结点数据域
|
||||
node->data=x;
|
||||
// 单链表中结点的指针指向下一个元素，为空
|
||||
node->next=NULL;
|
||||
|
||||
// 队尾进队，将结点node和队尾结点链接起来，确保不断链
|
||||
Q.rear->next=node;
|
||||
// 修改队尾指针，指向新入队的结点node
|
||||
Q.rear=node;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### 出队
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 链式队列出队操作
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-05-18 11:25:28
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-02-22 06:15:06
|
||||
*/
|
||||
bool DeLinkQueue(LinkQueue &Q, ElemType &x){
|
||||
|
||||
// 判断队列是否为空
|
||||
if(Q.front==Q.rear){
|
||||
// 队列为空，没有元素出队
|
||||
return false;
|
||||
}
|
||||
|
||||
// Q.front指向单链表的头结点，出队需要出单链表的除头结点外的第一个结点（头结点的下一个结点：Q.front->next）
|
||||
temp=Q.front->next;
|
||||
|
||||
// 变量x赋值
|
||||
x=temp->data;
|
||||
|
||||
// 修改单例表的头指针，指向链表中待删除元素的下一个元素
|
||||
Q.front->next=temp->next;
|
||||
|
||||
// 队尾指针和队首指针的下一个结点重合，表示当前链式队列只有一个元素，删除后，队列为空
|
||||
if(Q.rear==temp){
|
||||
// 链表中队首、队尾指针重合，队列为空
|
||||
Q.rear=Q.front;
|
||||
}
|
||||
|
||||
// 释放删除元素的内存空间,注意，这里释放的是头结点的下一个结点
|
||||
free(temp);
|
||||
|
||||
// 出队成功
|
||||
return true;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
出队的时候明显有些绕，需要明确队列中头结点的存在，出队出的是单链表中头结点的后一个结点，同时要确保整个过程`不断链`
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### 双端队列
|
||||
|
||||
`双端队列`: 允许在两端都可以进行入队和出队操作的队列，元素的逻辑结构仍然是线性结构
|
||||
|
||||
|
||||
|
||||
**双端队列的两端分别称为`前端`和`后端`，两端都可以`入队`和`出队`**
|
||||
|
||||
- 进队：前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列前端进的元素后面;
|
||||
- 出队：无论是前端还是后端出队，先出的的元素排列在后出的元素的前面
|
||||
|
||||
|
||||
在双端队列的基础上，还衍生出：
|
||||
|
||||
- `输入受限的双端队列`：允许在一端进行插入和删除操作，但在另外一端只允许进行删除的双端队列
|
||||
- `输出受限的双端队列`：允许在一端进行插入和删除曹组，但在另外一端只允许进行插入的双端队列
|
||||
|
||||
|
||||
当然，如果`限定双端队列从某个断点插入的元素只能从该端点删除`，那么此时的双端队列就演变为两个栈底相邻的栈了。
|
||||
|
||||
|
||||
|
||||
|
||||
### 队列的补充
|
||||
|
||||
- 最适合用来链队的链表是：`带队首指针和队尾指针的非循环单链表`
|
||||
|
||||
- 栈和队列的逻辑结构都是线性表，存储结构可能是顺序的（顺序栈、顺序队列），也可能是链式的（链栈、链队）
|
||||
- 不论是顺序存储还是链式存储，**栈和队列都只能进行顺序存取（本质是线性表）**。数组是可以做到随机存取（本质是顺序表）
|
||||
- 队列先进先出的特性：`先进队列的元素先出队列，后进队列的元素后出队列`
|
||||
|
||||
|
||||
特别注意：
|
||||
|
||||
队列用链表形式存储时，删除元素，需要从队头删除，一般情况下，仅仅修改头指针,但是如果此时队列中
|
||||
仅有一个元素，则尾指针也是需要被修改的。**因为队列中只有一个元素时，删除后队列为空，需要修改尾指针为：`rear=front`**
|
||||
@@ -1,126 +0,0 @@
|
||||
## 栈和队列的应用
|
||||
|
||||
> Tips: 这里不会做过多文字介绍相关应用，具体需要自己看书、查资料揣摩
|
||||
|
||||
### 栈的应用
|
||||
|
||||
- 括号匹配
|
||||
- 表达式求值
|
||||
> 表达式求值是程序设计语言编译中一个最基本的问题，类似有前缀、中缀、后缀表达式转换等典型问题。
|
||||
- 递归
|
||||
|
||||
这里重点总结下递归，递归非常重要，是一种很经典的程序设计方法
|
||||
|
||||
> 递归的简单定义： 如果在一个函数、过程或数据结构的定义中又应用了自身，那么这个函数、过程或者数据结构称为递归定义的，简称递归。
|
||||
|
||||
|
||||
|
||||
递归通常把一个大型的复杂问题，层层转化为一个与原问题相似的规模较小的问题来求解。
|
||||
|
||||
**递归策略只需要少量的代码就可以描述出解题过程所需要的多次重复的计算，很大程度上减少了程序的代码量，当时通常情况下，递归的效率并不是很高**
|
||||
|
||||
|
||||
经典的斐波拉切数列，可以用递归来实现：
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
// 定义递归函数，实现斐波拉切数列
|
||||
|
||||
int Fibonacci(n){
|
||||
if(n==0){
|
||||
return 0;
|
||||
}else if(n==1){
|
||||
return 1;
|
||||
}else{
|
||||
// 调用Fibonacci函数，进行递归
|
||||
return Fibonacci(n-1)+Fib(n-2);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
```
|
||||
|
||||
上面很基础的代码，是分`n=0`和`n=1`的情况，先进行过滤，其他情况下则进行递归，其实在日常开发中，经常会有简化的函数封装
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
// 定义递归函数，实现斐波拉切数列
|
||||
|
||||
int Fibonacci(n){
|
||||
if(n<2){
|
||||
return n;
|
||||
}else{
|
||||
// 调用Fibonacci函数，进行递归
|
||||
return Fibonacci(n-1)+Fib(n-2);
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
上面的简化，则需要程序考虑变量n是整数。
|
||||
|
||||
当然，前面有说道：**通常情况下，递归的效率并不搞**，主要原因就是递归通过返回调用自己本身，导致往往时间复杂度较高。
|
||||
|
||||
可以采用空间换时间的思路，来降低算法的时间复杂度
|
||||
|
||||
```cpp
|
||||
// 使用非递归实现
|
||||
int Fibonacci(int n) {
|
||||
if(n < 2)
|
||||
return n;
|
||||
int f = 0, g = 1;
|
||||
int result = 0;
|
||||
|
||||
// 迭代
|
||||
for(int i = 1; i < n; i++){
|
||||
result = f + g;
|
||||
f = g;
|
||||
g = result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// 利用数组，空间换时间
|
||||
int Fibonacci(n){
|
||||
// 注意溢出
|
||||
int arr[100]={0,1,1}
|
||||
|
||||
// 叠加，结果存放在数组中
|
||||
for(let i=3;i<=n;i++){
|
||||
arr[i]=arr[i-1]+arr[i-2]
|
||||
}
|
||||
return arr[n]
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
必须注意递归模型不能是循环定义的，满足条件：
|
||||
|
||||
- 递归表达式（递归体）
|
||||
- 边界条件（递归出口），即：算法结束条件
|
||||
|
||||
|
||||
递归的精髓在于是否能够将原来的问题转化为属性相同但规模较小的问题。有点类似实现目标过程中，将大目标转化为小目标（1亿....）来解决,噗呲啊哈哈哈
|
||||
|
||||
**递归次数过多容易造成栈溢出，效率不高的主要原因是递归调用过程中包含很多重复的计算**
|
||||
|
||||
|
||||
### 队列的应用
|
||||
|
||||
- 层次遍历
|
||||
|
||||
> 例如：二叉树的遍历
|
||||
|
||||
- 计算机系统
|
||||
|
||||
|
||||
队列在计算机系统中的应用非常广泛，作用：
|
||||
|
||||
- 解决主机和外部设备之间速度不匹配的问题（例如：内存和打印机）
|
||||
- 解决由多用户引起的资源竞争问题（例如：操作系统中的进程调度...）
|
||||
|
||||
|
||||
其实，队列在计算机系统的中应用， 在看完操作系统那本书后，就会很好理解，建议学到这里，也去翻翻操作系统，汤晓丹那本很经典哟...
|
||||
@@ -1,57 +0,0 @@
|
||||
## 特殊矩阵的压缩存储
|
||||
|
||||
> 这部分知识我个人觉得以了解为主，复习、学习的时候还是要以前面的部分为主！
|
||||
|
||||
矩阵在`计算机图形学`、`工程计算`中占有举足轻重的地位。
|
||||
|
||||
|
||||
### 数组的定义
|
||||
|
||||
`数组`： 由n(n≥1)个相同类型的数据元素构成的有限序列。
|
||||
|
||||
每个数据元素称为一个数组元素，同时每个元素受n个线性关系的约束，**每个元素在n个线性关系中的序号称为元素的`下标`**，称为该数组为n的数组。
|
||||
|
||||
数组和线性表的关系：
|
||||
- 数组是线性表的推广。
|
||||
- 数组一旦被定义，维数和维界就不再改变。
|
||||
- 除了结构的初始化和销毁外，数组只会有存取元素和修改元素的操作。
|
||||
|
||||
|
||||
一维数组可以看做是一个线性表
|
||||
|
||||
二维数组可以看做元素是线性表的线性表
|
||||
|
||||
....
|
||||
|
||||
|
||||
### 矩阵的压缩存储
|
||||
|
||||
|
||||
`压缩存储`：多个值相同的元素只分配一个存储空间，对零元素不分配存储空间---->节省存储空间。
|
||||
|
||||
`特殊矩阵`：具有很多相同矩阵元素或零元素，并且这些相同矩阵元素或零元素的分布有一定规律性的矩阵。
|
||||
|
||||
- 对称矩阵
|
||||
- 上、下三角矩阵
|
||||
- 对角矩阵（带状矩阵）
|
||||
- ....
|
||||
|
||||
这里如果学过线性代数这本书，其实也就很好理解（赶紧去把数学知识捡起来鸭，噗呲哈哈啊哈）
|
||||
|
||||
`稀疏矩阵`：矩阵元素个数s相对于矩阵中非零元素的个数t来说非常多、差距非常大，即`s>>t的矩阵`可以叫`稀疏矩阵`
|
||||
|
||||
|
||||
注意：
|
||||
|
||||
- 常规方法来存储稀疏矩阵，会想当浪费存储空间，所以稀疏矩阵只需要存储非零元素
|
||||
- 通常非零元素的分布是没有规律的，除了存储非零元素外，还需要存储元素所在位置的行和列
|
||||
- 寻相互存储三元组 `<行标，列表，值>`
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
三元组的结点存储了行标(row)、列表(col)、值(value)三种信息，是主要用来存储稀疏矩阵的一种数据结构。
|
||||
|
||||
|
||||
**注意：矩阵压缩存储的目的就是为了节省空间，已经存过的就不存或者少存（经典想法）**
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 54 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 22 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 44 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 29 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 43 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 19 KiB |
@@ -1,24 +0,0 @@
|
||||
<!--
|
||||
* @Description: 数据结构-栈和队列
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-22 08:02:29
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-22 08:02:43
|
||||
-->
|
||||
|
||||
|
||||
## 栈和队列
|
||||
|
||||
### 主要内容
|
||||
|
||||
- [栈的基本概念和基本操作](1.栈的基本概念和基本操作.md)
|
||||
- [栈的顺序存储结构](2.栈的顺序存储结构.md)
|
||||
- [栈的链式存储结构](3.栈链式存储结构.md)
|
||||
- [队列的基本概念和基础操作](4.队列的基本概念和基础操作.md)
|
||||
- [队列的顺序存储](5.队列的顺序存储结构.md)
|
||||
- [队列的链式存储](6.队列的链式存储结构.md)
|
||||
- [栈和队列的应用](7.栈和队列的应用.md)
|
||||
- [特殊矩阵的压缩存储](8.特殊矩阵的压缩存储.md)
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 1.5 MiB |
@@ -1,64 +0,0 @@
|
||||
<!--
|
||||
* @Description: 基本概念和操作
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-03-07 18:57:27
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-17 22:14:35
|
||||
-->
|
||||
|
||||
|
||||
|
||||
## 线性表的基础概念和基本操作
|
||||
|
||||
> 强调：线性表是一种逻辑结构，不是存储结构
|
||||
|
||||
|
||||
### 定义
|
||||
|
||||
**线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列.**
|
||||
|
||||
一般表示：
|
||||
|
||||
L=(a<sub>1</sub>,a<sub>2</sub>,a<sub>3</sub>......a<sub>n</sub>) 其中n可以理解为表长（线性表的长度），n=0时候，即表空
|
||||
|
||||
|
||||
- `表头元素`：线性表中唯一的“第一个”数据元素，例如a<sub>1</sub>
|
||||
- `表尾元素`：线性表中唯一的“最后一个”数据元素，例如a<sub>n</sub>
|
||||
|
||||
|
||||
重要逻辑特性：
|
||||
|
||||
- 除表头元素外，线性表中每个元素有且仅有一个`直接前驱`
|
||||
- 除表尾元素外，线性表中每个元素有且仅有一个`直接后继`
|
||||
|
||||
基于此，这种**线性有序的逻辑结构**,使得线性表的特点如下：
|
||||
|
||||
- 元素的**个数有限**（强调有限序列）
|
||||
- 元素在逻辑上具有**顺序性**，在序列中每个元素都是都有先后次序的
|
||||
- 元素都数据元素，**每个元素都是单个元素**
|
||||
- 元素的**数据类型都相同**（强调相同数据类型），每个数据元素占用相同大小的存储空间
|
||||
- 元素具有**抽象性**，仅仅讨论元素之间的逻辑关系，不需要去考虑元素究竟表示的什么内容
|
||||
|
||||
|
||||
> Tips: **线性表是一种逻辑结构**，表示元素之间一对一的相邻关系。**顺序表和链表则指的是存储结构**
|
||||
|
||||
|
||||
|
||||
### 基本操作
|
||||
|
||||
- `InitList(&L)`： **初始化表**。构造空的线性表
|
||||
- `Length(L)`：**获取表的长度**。返回线性表L的长度，即表中的数据元素个数
|
||||
- `LocateElem(L,e)`：**按值查找操作**。在表L中国查找具有给定关键字的元素
|
||||
- `GetElem(L,i)`：**按位查找操作**。获取表中第i个位置的元素的值
|
||||
- `ListInsert(&L,i,e)`：**插入操作**。在表的第i个位置上插入指定元素e
|
||||
- `ListDelete(&L,i,&e)`：**删除操作**。删除表中第i个位置的元素，并用e返回删除元素的值
|
||||
- `PrintList(L)`：**输出操作**。按照前后顺序（如：1、2....n）输出线性表的所有元素值
|
||||
- `Empty(L)`：**判空操作**。当表L为空，则返回true，否则返回false
|
||||
- `DestoryList(&L)`：**销毁操作**。将线性表销毁，释放线性表L所占用的内存空间（类似：释放内存）
|
||||
|
||||
|
||||
线性表是具有相同的数据类型的有限个数据元素组成的，**数据元素是由数据项组成的**
|
||||
|
||||
|
||||
|
||||
@@ -1,277 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 21:57:52
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-19 08:16:00
|
||||
-->
|
||||
|
||||
|
||||
## 线性表的顺序表示
|
||||
|
||||
|
||||
### 定义
|
||||
|
||||
`顺序表`：顺序存储的线性表，**是用一组地址连续的存储单元，依次存储线性表中的数据元素，使得在逻辑上相邻的两个元素在物理位置上也相邻。**
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
顺序表中的元素的逻辑顺序与实际的物理位置相同
|
||||
|
||||
|
||||
|
||||
注意：
|
||||
|
||||
- 线性表中的元素的位序是从1开始的，例如1、2、3...
|
||||
- 数组中的元素的下标是从0开始的，例如0、1、2...
|
||||
|
||||
```c
|
||||
# define MaxSize 20 // 定义常量MaxSize 用来声明顺序表的最大长度
|
||||
|
||||
// 线性表结构体定义【ElemType用来代指顺序表中元素的类型，例如高级语言中的int、string....】
|
||||
typedef struct{
|
||||
ElemType data[MaxSize]; // 顺序表的元素
|
||||
int length; // 顺序表的长度
|
||||
}SqList
|
||||
|
||||
```
|
||||
|
||||
#### 存储分配
|
||||
|
||||
`静态分配`：数组的大小和空间都是实现确定好的，一旦存储空间占满就会产生溢出，直接导致程序崩溃。（有点内存不够，宕机重启的意思....）
|
||||
|
||||
`动态分配`：存储数据的空间在程序执行过程中通过`动态存储分配语句`分配的，即便是数据空间占满，也可以另外开辟一块更大的空间，来替换原来的存储空间，满足扩充数据空间的目的。（有点动态规划的意思....）最重要的是：**不需要像静态分配那样，一次性地固定线性表的空间和大小**
|
||||
|
||||
|
||||
|
||||
```c
|
||||
#define InitSize 100 // 表长度初始化
|
||||
|
||||
|
||||
// 动态分配数组顺序表的结构体定义
|
||||
typedef struct{
|
||||
ElemType *data; // 动态分配数组的指针
|
||||
int MaxSize,length; // 数组的最大容量和当前元素个数
|
||||
}SqList;
|
||||
|
||||
```
|
||||
|
||||
动态分配语句
|
||||
|
||||
```C
|
||||
// C语言中
|
||||
|
||||
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);
|
||||
|
||||
|
||||
// C++ 中
|
||||
|
||||
L.data=new ElemType[InitSize];
|
||||
|
||||
```
|
||||
|
||||
`malloc()函数`： 指针型函数，返回的指针指向该分配域的开头的位置。作用是在内存的动态存储区中分配一个长度为size的连续空间。[百度百科](https://baike.baidu.com/item/malloc%E5%87%BD%E6%95%B0/8582146?fr=aladdin)
|
||||
|
||||
**动态分配不是链式存储，而是属于顺序存储结构**，动态分配的物理结构没有改变，依然是随机存取的方式。只是分配的空间大小可以在运行时决定；
|
||||
|
||||
|
||||
#### 顺序表的特点
|
||||
|
||||
|
||||
- 随机访问【这是最主要的特点】，通过存储起始地址和元素序号O(1)时间内访问指定元素。
|
||||
- 存储密度高，没有结点只存储数据元素，不像索引存储那样，还需要索引表什么的..
|
||||
- 逻辑上相邻的元素物理上也相邻，插入和删除需要移动大量元素
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### 基本操作
|
||||
|
||||
|
||||
#### 插入
|
||||
|
||||
在顺序表L的第i（1≤i≤L.length+1）个位置插入新的元素e
|
||||
|
||||
- 第一步：如果i非法，则直接返回false，插入失败，结束插入过程
|
||||
- 第二步：i正常，将表的第i个元素以及后面的所有元素都向右移动一个位置，在腾出来的空位置插入元素e
|
||||
- 第三步：顺序表插入成功，返回true
|
||||
|
||||
注意：先判空和临界值，提高算法健壮性
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 顺序表的插入操作
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-02-23 07:48:26
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-02-23 07:48:26
|
||||
*/
|
||||
bool ListInsert(SqList &L, int i, ElemType e){
|
||||
|
||||
// i非法 i=1 表头 i=L.length+1 表尾巴
|
||||
if(i<1||i>L.length+1){
|
||||
return false;
|
||||
}
|
||||
|
||||
// 存储空间满，无法插入
|
||||
if(L.length >= MaxSize){
|
||||
return false;
|
||||
}
|
||||
|
||||
// 遍历，将位置元素往后移动，注意从后往前循环，避免值被覆盖
|
||||
for(int j=L.length; j>=i;j--){
|
||||
L.data[j]=L.data[j-1];
|
||||
}
|
||||
|
||||
// 此时，表L中的第i个元素和第i+1元素素值一样，将新元素存入i位置即可
|
||||
|
||||
// 第i个元素，对应的位置角标为i-1
|
||||
L.data[i-1]=e;
|
||||
|
||||
// 表长度加1
|
||||
L.length++;
|
||||
|
||||
// 返回插入成功
|
||||
return true;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
注意：区别顺序表中的位序和角标；
|
||||
|
||||
**时间复杂度**
|
||||
|
||||
|
||||
|
||||
- 最好情况：在表尾插入，元素向后移动循环没有执行，时间复杂度O(1);
|
||||
- 最坏情况：在表头插入，元素后移循环执行n次，时间复杂度为O(n);
|
||||
- 平均情况：随机插入，平均次数为：n/2，对应的平均复杂度为O(n);
|
||||
|
||||
|
||||
**线性表插入算法的平均时间复杂度为：O(n)**
|
||||
|
||||
> Tips: 需要根据实现代码理解循环为什么是从后往前来实现元素后移，通过for循环可以很明显的看出表尾插入快，表头插入慢
|
||||
|
||||
#### 删除
|
||||
|
||||
删除顺序表L中第i（1≤i≤L.length+1）个位置的元素
|
||||
|
||||
- 成功，返回true,将被删除的元素用引用变量返回；
|
||||
- 失败，返回false
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 顺序表的删除操作
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-02-23 07:48:26
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-02-23 07:48:26
|
||||
*/
|
||||
bool ListDelete(SqList &L, int i, ElemType &e){
|
||||
|
||||
// i非法 i=1 表头 i=L.length+1 表尾巴
|
||||
if(i<1||i>L.length+1){
|
||||
return false;
|
||||
}
|
||||
|
||||
// 存储空间满，无法插入
|
||||
if(L.length >= MaxSize){
|
||||
return false;
|
||||
}
|
||||
|
||||
// 引用变量e赋值
|
||||
e=L.data[i-1]
|
||||
|
||||
// 遍历，第i个元素后面的往前移动
|
||||
for(int j=i; j<=L.length;j++){
|
||||
// 从第i个元素开始，角标从i-1开始
|
||||
L.data[j-1]=L.data[j];
|
||||
}
|
||||
|
||||
// 此时，表L中的表尾元素和倒数第二个元素值一样，将表的长度-1
|
||||
|
||||
// 表长度减1
|
||||
L.length--;
|
||||
|
||||
// 返回删除成功
|
||||
return true;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
从这里来看，删除、插入元素都会涉及到大量的元素的移动（最好情况例外），总结而言：
|
||||
- 元素从后往前移，循环从前往后遍历
|
||||
- 元素从前往后移，循环从后往前遍历
|
||||
|
||||
|
||||
**时间复杂度：**
|
||||
|
||||
|
||||
|
||||
- 最好情况：删除表尾元素，不需要移动任何元素，时间复杂度为O(1)；
|
||||
- 最坏情况：删除表头元素，需要移动除第一个元素外的所有元素，时间复杂度为O(n)；
|
||||
- 平均情况：随机删除，平均需要(n-1)/2，对应的时间复杂度为O(n)；
|
||||
|
||||
|
||||
|
||||
**线性表删除算法的平均时间复杂度为O(n)；**
|
||||
|
||||
|
||||
#### 按值查找（顺序查找）
|
||||
|
||||
在顺序表L中查找第一个元素值等于e的元素，并返回位序
|
||||
|
||||
|
||||
```cpp
|
||||
/*
|
||||
* @Description: 顺序表的按值查找（顺序查找）
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-02-23 07:48:26
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-02-23 07:48:26
|
||||
*/
|
||||
int LocateElem(SqList L,ElemType e){
|
||||
int i;
|
||||
// 循环判断
|
||||
for(i=0;i<L.length;i++){
|
||||
if(L.data[i]===e){
|
||||
// i是元素的角标，i+1是具体元素的位序号
|
||||
return i+1;
|
||||
}
|
||||
}
|
||||
|
||||
// 未命中，返回0,即：没有
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
注意理解`位序`的含义，即元素在线性表中的位置序号，角标为`i`（角标从0开始）,对应的位序为`i+1`（位序从1开始）。当返回为0时，则直接代表没有`命中`；
|
||||
|
||||
|
||||
**时间复杂度：**
|
||||
|
||||
- 最好情况：查找的元素在表头，只需要比较一次，循环成本最小，时间复杂度为O(1);
|
||||
- 最坏情况：查找的元素在表尾或者不存在，需要完整遍历，比较n次，时间复杂度为O(n);
|
||||
- 平均情况：随机查找表上的第i个（1≤i≤L.length）元素,平均次数为(n+1)/2,对应时间复杂度为O(n)
|
||||
|
||||
|
||||
|
||||
**线性表按值查找（顺序查找）的平均时间复杂度为O(n)；**
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
**顺序存取是读写方式，不是存储结构；顺序存储是存储结构，包括有：顺序存储、链式存储、索引存储、散列存储**
|
||||
@@ -1,440 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 21:58:40
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-21 17:37:36
|
||||
-->
|
||||
|
||||
|
||||
|
||||
|
||||
## 线性表的链式表示
|
||||
|
||||
顺序表的插入、删除操作需要移动大量元素，影响了运行效率（虽然时间复杂度为O(1)的情况也存在）。
|
||||
|
||||
|
||||
**链式存储线性表时，不需要使用连续的存储单元，不要求逻辑上相邻的两个元素在物理位置上也相邻**
|
||||
|
||||
|
||||
理解“链”的含义，链条--->捆绑、指向------>指针
|
||||
|
||||
|
||||
**链式存储线性表时，对线性表的插入、删除元素是不需要移动元素的，只是需要修改指针**
|
||||
|
||||
|
||||
- 单链表
|
||||
- 双链表
|
||||
- 循环链表
|
||||
- 静态链表
|
||||
|
||||
|
||||
|
||||
### 单链表
|
||||
|
||||
线性表的链式存储称作`单链表`，通过**一组任意的存储单元**来存储线性表中的数据元素。
|
||||
|
||||
|
||||
每个链表结点（node）除了存放元素自身的信息外，还需要存放一个指向其后继结点的指针。目的是：**通过指针建立起链表元素之间的线性关系**
|
||||
|
||||
|
||||
单链表中结点类型的描述：
|
||||
```cpp
|
||||
|
||||
// 单链表结点类型定义
|
||||
typeof struct LNode{
|
||||
ElemType data; // 数据域
|
||||
struct LNode *next; // 指针域
|
||||
}LNode , *LinkList;
|
||||
|
||||
```
|
||||
|
||||
|
||||
单链表可以解决顺序表需要大量连续存储空间的缺点，但是单链表在数据域的基础上附加了指针域，存在浪费存储空间的缺点；
|
||||
|
||||
|
||||
单链表的元素是**离散地分布**在存储空间中的，因此**单链表是非随机存取的存储结构**，不能直接找到表中特定的结点，需要从头开始遍历、一次查找；
|
||||
|
||||
|
||||
通常，**头指针用来标识一个单链表**。头指针指向`NULL`时，标识单链表为空。
|
||||
|
||||
|
||||
|
||||
#### 头结点
|
||||
|
||||
为了操作上的方便，在单链表第一个结点之前附加一个结点，叫做**头结点**。
|
||||
|
||||
- 头结点的数据域可以不存任何信息、也可以记录表长等基础信息
|
||||
- 头结点的指针域指向线性表的第一个元素结点；
|
||||
|
||||
|
||||
|
||||
|
||||
**不论单链表是否带头结点（可选），头指针始终指向链表的第一个结点。**
|
||||
|
||||
头结点是带头结点的链表中的第一个结点【重要】
|
||||
|
||||
- 头结点的数据域可以不存任何信息、也可以记录表长等基础信息
|
||||
- 头结点的指针域指向线性表的第一个元素结点；
|
||||
|
||||
|
||||
头结点的优点：
|
||||
|
||||
- 因为开始结点的位置被存放在头结点的指针域中，所以在链表的第一个位置上的操作和在表的其他位置上的操作一致，不需要进行特殊处理；
|
||||
- 无论链表是否为空，头指针始终是指向头结点的头结点的非空指针【空表中，往往就只有头结点，此时头结点的指针域为空，可以有效避免头指针空指针异常问题】-----> **头结点的引入，很好的统一了空表和非空表的操作；**
|
||||
|
||||
|
||||
|
||||
#### 头插法
|
||||
|
||||
> 从空表开始，生成新的结点，将读取的数据存放在新结点的数据域中，将新结点插入到当前链表的表头【头结点之后】
|
||||
|
||||
|
||||
```cpp
|
||||
/*
|
||||
* @Description: 单链表头插法创建
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-03-04 23:38:04
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-03-04 23:39:16
|
||||
*/
|
||||
LinkList CreateListWithStartNode(LinkList &L){
|
||||
|
||||
LNode *s;
|
||||
int x;
|
||||
L=(LinkList)malloc(sizeof(LNode)); // 创建头结点L
|
||||
L->next=NULL; // 初始化空链表
|
||||
|
||||
// 控制台输入值
|
||||
scanf("%d",&x);
|
||||
|
||||
// 输入9999 表示结束
|
||||
while(x!==9999){
|
||||
// 开辟新结点存储空间
|
||||
s=(LNode*)malloc(sizeof(LNode));
|
||||
// 结点数据域赋值
|
||||
s->data=x;
|
||||
// 修改指针，新结点插入表中【注意：L->next为头结点的指针域】
|
||||
s->next=L->next;
|
||||
L->next=s;
|
||||
scanf("%d",&x);
|
||||
}
|
||||
|
||||
// 返回单链表
|
||||
return L;
|
||||
}
|
||||
|
||||
|
||||
```
|
||||
|
||||
特点：
|
||||
|
||||
- 读入数据的顺序与生成的链表中的元素顺序是相反的【结合队列先进先出思考】
|
||||
- 每个结点插入的时间复杂度为O(1),单链表长度为n时，头插法的时间复杂度为O(n)【结合算法中的while循环，可以很明确看出时间复杂度】
|
||||
|
||||
|
||||
#### 尾插法
|
||||
|
||||
头插法建立的单链表，链表中结点的次序和输入数据的顺序不一致【相反】，尾插法则很好的避免了这个问题；
|
||||
|
||||
>新结点插入到当前链表的表尾上，必须增加一个尾指针r,始终指向当前链表的尾结点；
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 单链表尾插法创建
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-03-04 23:38:04
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-03-04 23:39:16
|
||||
*/
|
||||
LinkList CreateListWithEndNode(LinkList &L){
|
||||
|
||||
|
||||
int x; // 输入结点值
|
||||
L=(LinkList)malloc(sizeof(LNode));
|
||||
LNode *s; // 新结点s
|
||||
LNode *r=L; // r为尾指针
|
||||
|
||||
// 控制台输入值
|
||||
scanf("%d",&x);
|
||||
|
||||
while(x!==9999){
|
||||
// 开辟新结点存储空间
|
||||
s=(LNode *)malloc(sizeof(LNode));
|
||||
|
||||
// 新结点s的数据域赋值为x
|
||||
s->data=x;
|
||||
// 单链表L的尾指针指向新的结点s
|
||||
r->next=s;
|
||||
|
||||
// 指针r指向新的表尾结点
|
||||
r=s;
|
||||
|
||||
scanf("%d",&x);
|
||||
}
|
||||
|
||||
// 表尾指针置空【重要】
|
||||
r->next=NULL;
|
||||
|
||||
// 返回单链表
|
||||
return L;
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
特点：
|
||||
|
||||
- 读入数据的顺序与生成的链表中的元素顺序完全一致
|
||||
- 每个结点插入的时间复杂度为O(1),单链表长度为n时，尾巴插法的时间复杂度为O(n)【结合算法中的while循环，可以很明确看出时间复杂度】
|
||||
- 相比头插法附设了一个指向表尾结点的指针，但时间复杂度与头插法相同
|
||||
|
||||
|
||||
|
||||
#### 按序号查找
|
||||
|
||||
> 在单链表中从第一个结点出发，顺指针next域逐个往下搜索、遍历，直到找出第i个结点为止，否则返回最后一个结点指针域NULL
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 单链表按序号查找
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-03-04 23:38:04
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-03-04 23:39:16
|
||||
*/
|
||||
LNode *GetElem(LinkList L,int i){
|
||||
int j=1; // 查询计数，初始为1
|
||||
LNode *p=L->next; // 单链表头结点指针赋值给指针p
|
||||
|
||||
|
||||
// 第0个元素，则指向头结点，返回头结点
|
||||
if(i==0){
|
||||
// 头结点包含数据域和指针域
|
||||
return L;
|
||||
}
|
||||
|
||||
// 不等于0，却小于1，则i为负数无效，直接返回NULL，查询结果空；
|
||||
if(i<1){
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// p存在且计数没有走到初始i的位置
|
||||
while(p&&j<i){
|
||||
|
||||
// 指针后移
|
||||
p=p->next;
|
||||
|
||||
// 计数标记+1
|
||||
j++;
|
||||
}
|
||||
|
||||
// 注意： 当p不存在时， 跳出循环，p=NULL; 当p存在但是j大于等于i，跳出循环，返回查找的结果，返回p
|
||||
// 从跳出循环上来分析，p要么存在即：找到的结点元素，要么为空即NULL
|
||||
|
||||
// 跳出循环，返回第i个结点的指针
|
||||
return p;
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
需要遍历（扫描）单链表，时间复杂度为：O(n)
|
||||
|
||||
|
||||
|
||||
#### 按值查找
|
||||
|
||||
> 从单链表的第一个结点开始，从前往后依次比较表中个结点数据域的值，等于给定值e，则返回该结点的指针；若整个单链表【遍历完】中没有数据域值为e的结点，则返回NULL；
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
/*
|
||||
* @Description: 单链表按值查找
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2020-03-04 23:38:04
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2020-03-04 23:39:16
|
||||
*/
|
||||
LNode *LocateElem(LinkList L,ElemType e){
|
||||
|
||||
// 指针【哨兵】
|
||||
LNode *p=L->next;
|
||||
// 从第1个结点开始查找数据域(data)为e的结点
|
||||
while(p!=NULL&&p->data!=e){
|
||||
// 无法匹配，指针后移
|
||||
p=p->next;
|
||||
}
|
||||
|
||||
// 注意：p为NULL的时候，说明单链表已经遍历的尾结点了，跳出循环，没有找到目标结点；
|
||||
|
||||
// 查找到第1个匹配的结点，跳出循环，返回结点指针
|
||||
return p;
|
||||
//
|
||||
}
|
||||
|
||||
```
|
||||
链表遍历无法匹配，会返回NULL,因为在尾结点无法匹配的时候，直接返回尾结点指针域
|
||||
|
||||
需要遍历（扫描）单链表，时间复杂度为：O(n)
|
||||
|
||||
|
||||
#### 结点插入
|
||||
|
||||
> 单链表中，将值为x的新结点插入到单链表的第i个位置上
|
||||
|
||||
- 第一步： 检查插入位置的合法性；
|
||||
- 第二步： 找到待插入位置的前驱结点，即第（i-1）个结点；
|
||||
- 第三部： 在前驱结点后插入新结点；
|
||||
|
||||
```cpp
|
||||
// 循环遍历，时间复杂度O(n)
|
||||
p=GetElem(L,i-1);
|
||||
|
||||
// 移动指针，时间复杂度O(1)
|
||||
s->next=p->next;
|
||||
p->next=s;
|
||||
```
|
||||
|
||||
结合上面的代码可以看出，将元素x插入到单链表L的第i个元素上，必须先找到单链表L的i个结点的前驱结点，即（i-1）的位置，需要采用`GetElem()`函数，按照序号查找；
|
||||
|
||||
如果返回的前驱结点不为空，则说明插入的位置i合法，否则位置非法，插入失败；
|
||||
|
||||
找到前驱结点p后，最重要的是移动指针，将新的结点s的指针域指向结点p的指针域，也就是s的指针域指向元素p的后继结点，第i个结点元素
|
||||
|
||||
原来的(i-1)位置上的元素，也就是前驱结点p的指针域则必须指向新的结点元素；
|
||||
|
||||
**上面的过程不能更换，避免后继指针不存在的问题**
|
||||
|
||||
|
||||
最后的最后，一定要注意将s的数据域赋值x
|
||||
|
||||
|
||||
插入结点的时间复杂度集中在查找第(i-1)个元素，时间复杂度为O(n);如果在给定结点的后面插入新结点，只需要执行`p->next=s`操作，时间复杂度为O(1)
|
||||
|
||||
|
||||
|
||||
##### 前插操作
|
||||
|
||||
> 在某结点的前面插入一个新的结点
|
||||
|
||||
**对结点的前插操作都可以转化为后插操作，前提：需要从单链表的头结点开始顺序查找到其前驱结点；时间复杂度为O(n)。**
|
||||
|
||||
##### 后插操作
|
||||
|
||||
> 在某结点的后面插入一个新的结点，单链表插入算法中，通常采用后插操作的
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
// 结点s插入到结点p的前面，修改指针域，顺序不能改变
|
||||
s->next=p->next;
|
||||
p->next=s;
|
||||
|
||||
|
||||
// 经典的借助变量，进行值交换
|
||||
temp=p->data;
|
||||
p->data=s->data;
|
||||
s->data=temp;
|
||||
|
||||
```
|
||||
|
||||
上述借助临时变量`temp`来将结点s和结点p的数据域进行交换，需要开辟O(1)的空间复杂度，但是时间复杂度却从O(n)改变为O(1)，典型的空间换时间策略
|
||||
|
||||
|
||||
#### 删除结点
|
||||
|
||||
> 将单链表L的第i个结点元素删除；
|
||||
|
||||
|
||||
- 第一步： 先检查删除位置的合法性；
|
||||
- 第二步： 查找表中的第（i-1）个结点，即被删结点的前驱结点；
|
||||
- 第三步： 移动指针，删除结点元素；
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
// 获取删除位置结点元素的前驱结点
|
||||
p=GetElem(L,i-1);
|
||||
|
||||
// 删除位置结点元素指针
|
||||
q=p->next;
|
||||
|
||||
// 修改指针，将删除位置结点元素前驱结点的指针域指向其后继结点
|
||||
p->next=q->next;
|
||||
|
||||
// 释放结点元素的内存控件
|
||||
free(q)
|
||||
|
||||
```
|
||||
|
||||
和插入算法一样，时间都消耗在查询前驱结点上，时间复杂度为：O(n)
|
||||
|
||||
|
||||
|
||||
|
||||
> 删除单链表L中给定结点元素*p，通常是按值查找获取到p结点的前驱元素，再执行删除操作，这样很明显会导致时间复杂度为：O(n)，主要都消耗在`按值查找`上
|
||||
|
||||
这里可以利用p结点的后继结点将p结点删除
|
||||
|
||||
- 第一步：申请结点q，使其指向p结点的后继结点；
|
||||
- 第二步：将p结点的数据域值换成其后继结点的数据域；【注意，交换没什么意义，最终p的后继结点会删除、释放】
|
||||
- 第三步：p的指针域指向q的指针域，q结点从链中“断开”
|
||||
- 第四步：释放q的内存空间
|
||||
|
||||
|
||||
```cpp
|
||||
// 存放p的后继结点指针
|
||||
q=p->next;
|
||||
|
||||
// 结点p的后继结点元素赋值给结点p，避免后继结点的数据域丢失
|
||||
p->data=p->next->data;
|
||||
p->next=q->next;
|
||||
|
||||
// 此时q指向更换数据域后的p，即原来p的后继结点
|
||||
free(q)
|
||||
|
||||
```
|
||||
|
||||
相比按值查找前驱结点来删除给定的结点p，利用后继结点来删除的时间复杂度更小，为：O(1)
|
||||
|
||||
|
||||
|
||||
#### 计算表长
|
||||
|
||||
> 计算单链表中数据结点（不含头结点）的个数
|
||||
|
||||
|
||||
算法思路：从第一个结点开始顺序依次访问表中的每一个结点，为此需要设置一个`计数器变量`，每访问一个结点，计算器加1，直到访问到空结点为止。
|
||||
|
||||
算法时间复杂度：O(n)
|
||||
|
||||
|
||||
**单链表的长度是不包括头结点的，不带头结点和带头结点的单链表在求表长操作上会略有不同。**
|
||||
|
||||
不带头结点的单链表，当表为空时候，需要单独处理；
|
||||
|
||||
```cpp
|
||||
// 不带头结点的单链表L为空,判定条件是L=NULL。
|
||||
if(L===NULL){
|
||||
// 链表为空，表长为0
|
||||
return 0;
|
||||
}
|
||||
|
||||
// 带头结点的单链表L为空，判空条件：L->next=NULL;
|
||||
|
||||
if(L->next===NULL){
|
||||
// 链表为空，不包含头结点，表长为0
|
||||
return 0;
|
||||
}
|
||||
|
||||
```
|
||||
@@ -1,92 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 21:59:05
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-21 17:35:27
|
||||
-->
|
||||
|
||||
|
||||
|
||||
|
||||
## 双链表
|
||||
|
||||
|
||||
从单链表的结构上来看
|
||||
- 访问特定结点的前驱结点需要遍历整个单链表，移动指针，时间复杂度为：O(n)
|
||||
- 访问特定结点的后继结点只需要移动一次指针，时间复杂度为：O(1)
|
||||
|
||||
|
||||
双链表的引入，很好的解决单链表访问前驱结点时间消耗大的问题。
|
||||
|
||||
|
||||
双链表结点由三部分组成：
|
||||
|
||||
- `数据域` 存放数据信息
|
||||
- `prior指针域` 指向结点的前驱结点
|
||||
- `next指针域` 指向结点的后继结点
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
// 双链表结点类型
|
||||
typedef struct DNode{
|
||||
ElemType data; // 结点的数据域
|
||||
struct DNode *prior; // 结点的前驱指针
|
||||
struct DNode *next; // 结点的后继指针
|
||||
}DNode, *DlinkList;
|
||||
|
||||
```
|
||||
|
||||
|
||||
### 基本特点
|
||||
|
||||
- 双链表仅仅在单链表的结点中增加了一个指向结点前驱的`prior`指针；
|
||||
- `按值查找`、`按序号查找`在单链表和双链表上的操作是相同的。
|
||||
- 和单链表不同，`插入`、`删除`操作除了修改`next`指针域，双链表还需要修改`prior`指针域，确保不断`链`，时间复杂度都为：O(1)
|
||||
|
||||
|
||||
|
||||
|
||||
### 插入结点
|
||||
|
||||
> 在双链表中p所指的结点之后插入结点s
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
// 第一步
|
||||
s->next=p->next;
|
||||
|
||||
// 第二步
|
||||
p->next->prior=s;
|
||||
|
||||
// 第三步
|
||||
s->prior=p;
|
||||
|
||||
// 第四步
|
||||
p->next=s
|
||||
|
||||
```
|
||||
|
||||
**第一步和第二步必须在第四步之前**，整体时间复杂度为：O(1)
|
||||
|
||||
### 删除结点
|
||||
|
||||
> 删除双链表中结点p的后继结点q
|
||||
|
||||
```cpp
|
||||
|
||||
// 第一步
|
||||
p->next=q->next;
|
||||
|
||||
// 第二步
|
||||
q->next->prior=p;
|
||||
|
||||
// 第三步
|
||||
free(q);
|
||||
|
||||
```
|
||||
|
||||
**第一步和第二步顺序可换**，整体时间复杂度为：O(1)
|
||||
@@ -1,76 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 21:59:27
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-07 21:59:27
|
||||
-->
|
||||
|
||||
|
||||
|
||||
|
||||
## 循环链表
|
||||
|
||||
- 循环单链表
|
||||
- 循环双链表
|
||||
|
||||
|
||||
### 循环单链表
|
||||
|
||||
`循环单链表`是在单链表的基础上，将最后一个结点（尾结点）的指针由`NULL`改为指向`头结点`，形成`环`。【单链表----->循环单链表】
|
||||
|
||||
|
||||
```cpp
|
||||
// 双链表结点类型
|
||||
typedef struct DNode{
|
||||
ElemType data; // 结点的数据域
|
||||
struct DNode *prior; // 结点的前驱指针
|
||||
struct DNode *next; // 结点的后继指针
|
||||
}DNode, *DlinkList;
|
||||
|
||||
```
|
||||
|
||||
#### 判空条件
|
||||
|
||||
**不是判断头结点的指针是否为空，而是需要判断是否等于头指针**，表为空时，头结点的next指针域其实是指向自己；
|
||||
|
||||
|
||||
|
||||
#### 特点
|
||||
|
||||
- 在循环单链表中，尾结点*p的next指针域指向链表L（即：头结点），形成了`闭环`,不存在指针域为`NULL`的结点。
|
||||
- **由于循环单链表是个`环`,在任何位置上的插入、删除操作都是等价的，不需要去判断是否是表尾**。当其中的结点的next指针指向自己，也就能判断表为空
|
||||
- 单链表只能从头结点（表头结点）开始往后顺序遍历整个表，循环单链表可以从表中任意位置开始遍历整个链表，结点是等价的；
|
||||
- **循环单链表可以抽象为时钟，形成的`环`是有顺序的；**
|
||||
- 频繁的`表头`和`表尾`操作，可以对循环单链表设置`尾指针`，而不设置`头指针`，明确尾指针r后，头指针即为：`r->next` ，减少头指针到尾指针间的遍历，时间复杂度:O(n)---->O(1)
|
||||
|
||||
|
||||
|
||||
|
||||
### 循环双链表
|
||||
|
||||
`循环双链表`是在双链表的基础上，将`尾结点`的`next`指针指向`头结点`，将`头结点`的`prior`指针指向`尾结点`。【双链表----->循环双链表】
|
||||
|
||||
|
||||
```cpp
|
||||
// 双链表结点类型
|
||||
typedef struct DNode{
|
||||
ElemType data; // 结点的数据域
|
||||
struct DNode *prior; // 结点的前驱指针
|
||||
struct DNode *next; // 结点的后继指针
|
||||
}DNode, *DlinkList;
|
||||
|
||||
```
|
||||
|
||||
#### 判空条件
|
||||
|
||||
循环双链表为空时，头结点*p的prior指针和next指针都指向L，即同时满足：
|
||||
|
||||
- p->next=L
|
||||
- p->prior=L
|
||||
|
||||
|
||||
#### 基本特点
|
||||
|
||||
- 从双向链表中的任意一个结点开始，都可以很方便地访问它的`前驱结点`和`后继结点`。
|
||||
@@ -1,44 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 21:59:47
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-07 21:59:47
|
||||
-->
|
||||
|
||||
|
||||
|
||||
|
||||
## 静态链表
|
||||
|
||||
> 借助数组来描述线性表的链式存储结构，结点元素同样存在数据域`data`和指针域`next`
|
||||
|
||||
|
||||
注意： 和普通的链表的指针域不同的是，静态链表的指针是结点元素的相对地址(数组下标)，也称为`游标`，建议结合高级语言中数组的概念来理解；
|
||||
|
||||
|
||||
**与顺序表一样，虽然静态链表属于链表，但是存储时需要预先分配一块连续的内存空间**
|
||||
|
||||
|
||||
静态链表结构类型：
|
||||
|
||||
|
||||
```cpp
|
||||
|
||||
// 定义静态链表的最大长度
|
||||
# define MaxSize 50
|
||||
|
||||
typedef struct{
|
||||
ElemType data; // 存储数据元素，数据域
|
||||
int next; // 下个元素的相对地址，数组下标
|
||||
}SLinkList[MaxSize];
|
||||
|
||||
```
|
||||
|
||||
很显然，静态链表是通过`数组游标`来访问下一个结点元素，可以和`指针域`的相关概念结合理解；
|
||||
|
||||
|
||||
- 静态链表以`next=-1`作为结束的标志【尾结点】
|
||||
- 和动态链表相同，**插入、删除操作不需要移动元素，只需要修改指针**；
|
||||
- 总体来说，静态链表没有单链表使用方便，需要将整个链表存储在一块连续的内存空间中，内部的存储可以分散，通过指针构成`链`的关系
|
||||
@@ -1,72 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 22:00:10
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-07 22:00:10
|
||||
-->
|
||||
|
||||
|
||||
|
||||
## 顺序表和链表的比较
|
||||
|
||||
|
||||
### 存取方式
|
||||
|
||||
- 顺序表支持顺序存取和随机存取；
|
||||
- 链表只能从表头顺序存取元素，支持顺序存取；
|
||||
|
||||
|
||||
### 逻辑结构与物理结构
|
||||
|
||||
|
||||
- 顺序存储时，逻辑上相邻的元素，对应的物理存储位置也相邻【一定性】。
|
||||
- 链式存储时，逻辑上相邻的元素，对应的物理存储位置不一定相邻【可以相邻，也可以不相邻】。
|
||||
- 链式存储的逻辑关系通过指针链接表示；
|
||||
|
||||
|
||||
|
||||
### 时间复杂度
|
||||
|
||||
#### 按值查找
|
||||
|
||||
- 顺序表无序的情况下，顺序表和链表的时间复杂度均为O(n)
|
||||
- 顺序表有序的情况下，顺序表的时间复杂度为O(log<sub>2</sub>n)，链表的时间复杂度为O(n)；
|
||||
|
||||
|
||||
**注意：O(log<sub>2</sub>n) < O(n)**
|
||||
|
||||
#### 按序号查找
|
||||
|
||||
- 顺序表支持随机访问，时间复杂度为O(1)；
|
||||
- 顺序表不支持随机访问，时间复杂度为O(n)；
|
||||
|
||||
#### 插入、删除
|
||||
|
||||
- 顺序表平均需要移动半个表长的元素；
|
||||
- 链表只需要修改相应结点的指针域，不需要移动元素；
|
||||
- 链表结点除了数据域，还有指针域，在存储空间上比顺序存储需要更大的存储空间，付出更大的存储代价，存储密度不够大
|
||||
|
||||
### 空间分配
|
||||
|
||||
#### 顺序存储
|
||||
|
||||
|
||||
##### 静态分配
|
||||
|
||||
- 需要预先分配足够大的存储空间；
|
||||
- 空间装满后不能扩充，存储新元素将出现`内存溢出`；
|
||||
- 存储空间过大，顺序表后部闲置空间过多，造成`内部碎片`
|
||||
- 存储空间过小，会造成`内存溢出`
|
||||
|
||||
##### 动态分配
|
||||
|
||||
- 动态分配能够扩充存储空间，但需要移动大量元素，操作效率降低
|
||||
- 内存中没有更大块的连续存储空间，将会导致空间分配失败；
|
||||
|
||||
|
||||
#### 链式存储
|
||||
|
||||
- 链式存储的结点空间只在需要的时候申请分配
|
||||
- 只要内存由空间就可以分配，操作灵活、高效
|
||||
@@ -1,45 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 22:00:36
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-07 22:00:43
|
||||
-->
|
||||
|
||||
|
||||
|
||||
|
||||
## 存储结构的选取
|
||||
|
||||
|
||||
|
||||
### 基于存储的考虑
|
||||
|
||||
- 对线性表的长度和存储规模难以估计时，不宜采用顺序表存储
|
||||
- 链表不用事先估计存储规模，但存储密度较低
|
||||
- 链式存储结构的存储密度小于1，不要求连续的存储空间
|
||||
|
||||
|
||||
|
||||
### 基于运算的考虑
|
||||
|
||||
- 顺序表支持随机存取，按序号查找顺序表的时间复杂度为O(1)；
|
||||
- 链表不支持随机存取，按序号查找链表的时间复杂度为O(n);
|
||||
- 顺序表的插入、删除操作，平均需要移动表中一半的元素，当表的数据量较大时，这种情况需要重点考虑的。
|
||||
- 链表的插入、删除操作，也是需要找插入位置（前驱结点、后继结点），主要的操作还是比较操作，相对较好；
|
||||
|
||||
|
||||
|
||||
|
||||
### 基于环境的考虑
|
||||
|
||||
- 顺序表容易实现，任何高级语言中都有数组类型；
|
||||
- 链表操作是基于指针的，指针移动，相对复杂；
|
||||
|
||||
|
||||
|
||||
综上比较
|
||||
|
||||
- 通常比较稳定的线性表选择顺序存储；
|
||||
- 频繁进行插入、删除操作的线性表，应该选择链式存储，动态性较强
|
||||
@@ -1,33 +0,0 @@
|
||||
<!--
|
||||
* @Description:
|
||||
* @Version: Beta1.0
|
||||
* @Author: 【B站&公众号】Rong姐姐好可爱
|
||||
* @Date: 2021-03-07 22:00:53
|
||||
* @LastEditors: 【B站&公众号】Rong姐姐好可爱
|
||||
* @LastEditTime: 2021-03-07 22:00:53
|
||||
-->
|
||||
|
||||
|
||||
|
||||
## 零碎知识补充
|
||||
|
||||
- 无论是链表的插入还是删除操作，必须保证不断链【重要】
|
||||
- 顺序存储结构可以随机存取也能顺序存取，链式结构只能进行顺序存取
|
||||
- 顺序存储方式同样适合图和树的存储，例如：满二叉树的顺序存储
|
||||
- 队列需要在表头删除元素，在表尾插入元素【先进先出】，采用带尾指针的循环单链表比较方便
|
||||
- 数组排序最少时间复杂度为O(nlog<sub>2</sub>n)【重要】
|
||||
- 静态链表中的指针称为`游标`，指示下一个元素在数组中的`下标`
|
||||
- 静态链表用数组表示，需要预先分配较大的连续空间，同时具有一般链表的特点（插入、删除元素不需要移动元素）
|
||||
|
||||
|
||||
### 单链表设置头结点
|
||||
|
||||
|
||||
目的
|
||||
|
||||
> 主要是方便运算。
|
||||
|
||||
好处
|
||||
|
||||
- 有头结点后，插入、删除数据元素的算法统一起来了，不需要判断是否在第一个元素之前插入或者删除第一个元素了。
|
||||
- 不论链表是否为空，头指针是指向头结点的`非空指针`，链表的头指针不变，因此空链表和非空链表的处理也就统一起来了。
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 42 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 106 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 80 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 38 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 24 KiB |
@@ -1,19 +0,0 @@
|
||||
## 线性表
|
||||
|
||||
|
||||
### 主要内容
|
||||
|
||||
- [基础概念和基本操作](1.基础概念和基本操作.md)
|
||||
- [线性表的顺序表示](2.线性表的顺序表示.md)
|
||||
- [线性表的链式表示之单链表](/数据结构/线性表/3.线性表的链式表示.md)
|
||||
- [线性表的链式表示之双链表](4.线性表的链式表示【双链表】.md)
|
||||
- [线性表的链式表示之循环链表](5.线性表的链式表示【循环链表】.md)
|
||||
- [线性表的链式表示之静态链表](6.线性表的链式表示【静态链表】.md)
|
||||
- [顺序表和链表的比较](7.顺序表和链表的比较.md)
|
||||
- [存储结构的选取](8.存储结构的选取.md)
|
||||
- [零碎知识补充](9.零碎知识补充.md)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 2.0 MiB |
@@ -1,35 +0,0 @@
|
||||
## 思维导图
|
||||
|
||||
> 内容同步与文档，可以结合思维导图对文档进行有效学习
|
||||
>
|
||||
> 创建时间：2020年4月9日
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## 目录内容（善用Ctrl+F）
|
||||
|
||||
> 计算机操作系统的相关基础知识主要依托《计算机操作系统》第四版内容进行整理，后续会结合王道考研书进行扩展补充
|
||||
>
|
||||
> 参考资料:
|
||||
>
|
||||
> 1. 《计算机操作系统》 第四版 汤小丹、梁红兵、汤子瀛著
|
||||
> 2. 《操作系统-王道考研》 2019 王道论坛
|
||||
|
||||
### 计算机操作系统
|
||||
|
||||
- [第一章：操作系统引论](第一章/操作系统引论.md)
|
||||
- [第二章：进程的描述与控制]()
|
||||
- [第三章：处理机调度与死锁]()
|
||||
- [第四章：存储器管理]()
|
||||
- [第五章：虚拟存储器]()
|
||||
- [第六章：输入输出系统]()
|
||||
- [第七章：文件管理]()
|
||||
- [第八章：磁盘存储器的管理]()
|
||||
- [第九章：操作系统接口]()
|
||||
- [第十章：多处理机操作系统]()
|
||||
- [第十一章：多媒体操作系统]()
|
||||
- [第十二章：保护与安全]()
|
||||
|
||||
### 王道论坛
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 8.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 51 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 308 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 345 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 8.0 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 51 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 308 KiB |
Binary file not shown.
@@ -1,266 +0,0 @@
|
||||
## 操作系统的目标和作用
|
||||
|
||||
> 操作系统（Operating System）是配置在计算机硬件上的第一层软件，是对硬件系统的首次扩充。主要作用是管理好硬件设备，提高硬件设备的利用率的系统吞吐量，并为用户和应用程序提供简单的接口，便于用户使用。**操作系统是现在计算机系统中最基本和最重要的系统软件**
|
||||
|
||||
### 操作系统的目标
|
||||
|
||||
> 方便性、有效性、可扩充性、开放性
|
||||
|
||||
#### 方便性
|
||||
|
||||
未配置操作系统(OS)的计算机系统必然是极难使用，不适合大多数人的，当用户需要在计算机硬件（裸机）上运行自己写的程序，就必须使用到机器语言。倘若计算机硬件配置了OS，系统便可以使用编译命令将用户采用高级语言（Java、C、C++等）编写的程序翻译成机器可执行代码，亦或通过OS所提供的各种命令来操作计算机系统，从而极大的方便用户，计算机也能更加易于使用和学习；
|
||||
|
||||
#### 有效性
|
||||
|
||||
操作系统的有效性包含的第一层含义是**提高系统资源的利用率**，同时，提高系统资源利用率也是推动OS发展最主要的动力；
|
||||
|
||||
另一层含义是**提高系统的吞吐量**，操作系统可以通过合理地组织计算机的工作流程， 加速程序的运行，速断程序的运行周期，以此来提高系统的吞吐量；
|
||||
|
||||
**方便性和有效性是设计OS时最重要的两个目标**
|
||||
|
||||
#### 可扩充性
|
||||
|
||||
为适应计算机硬件、体系结构以及计算机应用发展的要求，操作系统必须具有很好的可扩充性。然而操作系统的可扩充性好坏与OS的结构有着十分紧密的联系。正是因为如此，操作系统的发展也推动着操作系统接口的不断发展；
|
||||
|
||||
无结构系统------>模块化结构----->层次化结构----->微内核结构
|
||||
|
||||
#### 开放性
|
||||
|
||||
随着Internet的快速发展，计算机操作系统的应用环境也由单机环境转向了网络环境，应用环境需要更加的开放，因此对操作系统的开放性提出了更高的要求；
|
||||
|
||||
所谓开放性，即指系统能遵循世界标准规范，特别是遵循开放系统互连OSI国际标准；而事实上，方式遵循国际标准所开发的硬件和软件，都能够彼此兼容，方便实现互连。开放性是衡量一个新推出的系统或者软件能否被广泛应用的至关重要的因素
|
||||
|
||||
### 操作系统的作用
|
||||
|
||||
> 操作系统在计算机系统中所起的作用，可以从用户、资源管理、资源抽象等不通维度去分析和讨论
|
||||
>
|
||||
> - 作为用户与计算机硬件系统的接口
|
||||
> - 作为计算机系统资源的管理者
|
||||
> - 实现对计算机资源的抽象
|
||||
|
||||
#### 作为用户与计算机硬件系统的接口
|
||||
|
||||
操作系统作为用户与计算机硬件与系统之间接口的含义：**操作系统处于用户与计算机硬件系统之间，用户通过OS来使用计算机系统**，即：用户在操作系统的帮助下能够方便、快捷、可靠地操作计算机硬件和运行自己的程序。
|
||||
|
||||
从下图中可以看出，用户可以通过三种方式操作使用计算机
|
||||
|
||||
- 命令
|
||||
- 系统调用
|
||||
- 图标-窗口可视化
|
||||
|
||||
|
||||
|
||||
#### 作为计算机系统资源的管理者
|
||||
|
||||
操作系统的主要功能是管理多种硬件和软件资源，归纳起来分为：
|
||||
|
||||
- 处理机
|
||||
- 存储器
|
||||
- I/O设备
|
||||
- 文件（数据和程序）
|
||||
|
||||
四部分各司其职，同时操作系统必须为使用资源的请求进行**授权**，协调多用户对共享资源的使用，**避免发生冲突**；
|
||||
|
||||
- 处理机管理用于分配和控制处理机
|
||||
- 存储器管理主要负责内存的分配和回收
|
||||
- I/O设备管理是I/O设备的分配（回收）与操作
|
||||
- 文件管理是用于实现对文件的存取、共享和保护
|
||||
|
||||
#### 实现对计算机资源的抽象
|
||||
|
||||
从裸机（完全无软件的计算机系统）来看，仅仅向用户提供硬件接口（物理接口），用户必须对物理接口实现的细节有充分的了解，导致物理节气很难被广泛使用。**为了能够方便用户使用I/O设备，人们需要在裸机上覆盖一层I/O设备管理软件，借助I/O设备软件来实现对I/O设备操作的细节，并且需要向上将I/O设备抽象为一组数据结构以及一组操作命令（例：read命令、write命令）。使得用户通过利用这些数据结构及操作命令来进行数据输入和输出，不需要关系I/O设备在硬件上是如何实现的。**
|
||||
|
||||
> 在裸机上铺设的I/O软件隐藏了I/O设备的具体细节，向上提供了一组抽象的I/O设备
|
||||
|
||||
|
||||
|
||||
通常，将覆盖上述软件（I/O软件、物理接口、硬件）的机器成为`扩充机`或`虚拟机`,向用户提供一个对硬件操作的抽象模型。**I/O设备管理软件实现了对计算机硬件操作的第一层次的抽象；**
|
||||
|
||||
**操作系统是铺设在计算机硬件上的多层软件的集合，不仅增强了系统的功能，还隐藏了对硬件操作的具体细节，实现了对计算机硬件操作的多个层次的抽象模型。需要说明的是，不仅仅可以在底层对硬件资源加以抽象，还可以在高层对该资源底层已抽象的模型再次进行抽象，成为更加高层的抽象模型。**
|
||||
|
||||
> 随着抽象层次的提高，抽象接口所提供的功能也就越强，用户使用起来也越方便。
|
||||
|
||||
### 推动操作系统发展的主要动力
|
||||
|
||||
> 操作系统自20世纪50年代诞生后，经历了简单到复杂、低级到高级的发展，在60多年的时间里，操作系统在各方面都有长足的进步，能够很好的适应计算机硬件和体系结构的快速发展，以及应用需求下的不断变化。
|
||||
|
||||
主要推动力：
|
||||
|
||||
- 不断提高的计算机资源利用率
|
||||
- 方便用户
|
||||
- 器件的不断更新换代
|
||||
- 计算机体系结构的不断发展
|
||||
- 不断提出新的应用需求
|
||||
|
||||
### 操作系统的概念
|
||||
|
||||
在信息化是戴，软件被称作为计算机系统的灵魂，作为软件核心的操作系统，已经与现代计算机系统密不可分，融为一体。自下而上可错略的分为：硬件、操作系统、应用软件、用户（与组成原理中的分层不同）。**操作系统管理各种计算机硬件，为应用程序提供基础，并充当计算机硬件与用户之间的中介。控制和协调各用户的应用程序对硬件的分配和使用**
|
||||
|
||||
### 操作系统的定义
|
||||
|
||||
>操作系统（Operating System，OS）指控制和管理整个计算机系统的硬件和软件资源，并合理地组织调度计算机的工作和资源的分配，提供给用户和其他软件方便的接口和环境的程序集合。是最基础的系统软件
|
||||
|
||||
## 操作系统的发展过程
|
||||
|
||||
> 在20世纪50年代中期，出现了第一个简单的批处理操作系统；
|
||||
>
|
||||
> 60年代中期开发出多道程序批处理操作系统；
|
||||
>
|
||||
> 不久后，推出了分时操作系统，与此同时，用于工业 和武器控制的实时操作系统相继出现；
|
||||
>
|
||||
> 20世纪70到90年代，成为VLSI（超大规模集成电路）和计算机体系结构发展的年代，微型机、多处理机和计算机网络诞生并发展
|
||||
|
||||
### 操作系统发展历程
|
||||
|
||||
|
||||
|
||||
#### 手工操作阶段
|
||||
|
||||
首先明确，此阶段无操作系统；操作方式是由程序员将事先已经穿孔的纸带（卡片），装入纸带输入机（卡片输入机），在启动它们将纸带或者卡片上的程序和数据输入计算机。然后才能启动计算机运行。**仅当程序运行完毕并且取走结果后，才能允许下一个用户上机**，即存在着：程序装入、运行、结果的输出等操作。随着计算机硬件的快速发展，人机矛盾（处理速度和资源利用的矛盾）突显严重，从而促进操作系统的发展，寻求新的解决方法；
|
||||
|
||||
手工操作阶段有着明显的缺点：
|
||||
|
||||
- 用户独占主机（一台计算机的全部资源由上机用户所独占），不会出现因资源已经被其他用户占用而等待的现象，但是资源利用率低；
|
||||
- CPU等待手工操作，CPU及内存等资源是空闲的，资源利用也不充分
|
||||
|
||||
由于上面两个突显的缺点，**人工操作的方式严重降低了计算机资源的利用率，包括软件和硬件资源，即人机矛盾； ** 虽然CPU 的速度在迅速提高，但是I/O设备的比速度却提高 缓慢，使得CPU与I/O设备之间速度不匹配问题更加突出。**唯一的解决办法就是用高速的机器代替相对较慢的手工操作来对作业进行控制。** 先后出现过通道技术、缓冲技术、脱机输入/输出技术
|
||||
|
||||
#### 脱机处理阶段
|
||||
|
||||
为了能够充分地提高计算机的利用率，应该尽量的保持系统连续的运行，即在处理完一个作业任务后，紧接着处理下一个作业，减少机器空闲等待时间；
|
||||
|
||||
|
||||
|
||||
从上面的流程图中可以看出，单道批处理系统在解决人机矛盾和CPU与I/O设备速度不匹配矛盾的过程中形成的。**也可以理解为批处理系统的首要目的是在提高系统资源的利用率和系统吞吐量**。系统对作业的处理是成批进行的，内存中始终只能保存一道作业任务；
|
||||
|
||||
单道批处理系统的显著特征：
|
||||
|
||||
- **自动性** 在顺序的情况下，在磁带上的一批作业任务能够自动地逐个依次有序运行，不需要人工干预；
|
||||
- **顺序性** 各道作业都是顺序进入内存中，完成的顺序和进入内存顺序，在正常情况下是完全相同的。可以理解为类似队列的方式，先调入内存的作业先完成；
|
||||
- **单道性** 内存中仅仅只有一道程序运行，监督程序每次从磁带上只调用一道程序进入内存运行。只有当程序完成或者发生异常时，才会更换后续程序进入内存中；
|
||||
|
||||
单道批处理系统主要的缺点是：**系统中的资源得不到充分的利用**，程序在运行中发出I/O请求后，CPU便会处于等待状态，即：CPU空闲，同样也会造成内存的浪费；
|
||||
|
||||
#### 多道批处理系统
|
||||
|
||||
允许多个程序同时进入到内存并且运行。即同时会把多个程序放入内存，允许在CPU中交替运行。**共享系统中各种软件、硬件资源**。当一道程序因为I/O请求而暂停运行，CPU可以立即转去运行另外一道程序。最大程度的让系统的各个组成部分都“动起来”、“忙起来”,花费很少的时间去切换任务。实现系统各部件之间**并行工作，提高效率**；
|
||||
|
||||
多道程序设计的特点：**多道、宏观上并行、微观上串行**
|
||||
|
||||
>多道：计算机内存中同时存放多个相互独立的程序；
|
||||
>
|
||||
>宏观上并行：同时进入系统到的多道程序都处于运行过程中，先后开始了各自的运行，但是都处于运行中，没有运行完毕；
|
||||
>
|
||||
>微观上串行：内存中的多道程序轮流占有CPU资源，交替进行；
|
||||
|
||||
多道程序设计计算实现需要解决的问题：
|
||||
|
||||
- 如何分配处理器
|
||||
- 多道程序的内存分配问题
|
||||
- I/O设备如何分配
|
||||
- 如何组织和存放大量的程序和数据，便于用户使用和保证其安全性与一致性
|
||||
|
||||
**在批处理系统中采用多道程序设计技术，就形成了多道批处理操作系统**。由作业调度程序自动地选择作业运行；
|
||||
|
||||
多道批处理系统的优缺点：
|
||||
|
||||
- **资源利用率高**
|
||||
- **系统吞吐量大**
|
||||
- CPU和其他资源保持“忙碌”状态（主要原因）；
|
||||
- 仅仅当作业完成时或者运行不下去时才进行切换，系统开销小（主要原因）；
|
||||
|
||||
|
||||
- **平均周转时间长** 需要排队依次处理，响应时间长
|
||||
- **无交互能力** 修改和调试程序极其不方便，用户既不能了解程序的运行情况，也不能控制计算机；
|
||||
|
||||
#### 分时系统
|
||||
|
||||
> 推动多道批处理系统形成和发展的主要动力是**提高资源利用和系统吞吐量**；推动分时系统形成和发展的主要动力是**满足用户对人机交互的需求**，即满足：**人-机交互、共享主机**
|
||||
|
||||
分时系统定义：**在一台主机上连接了多个配有显示器和键盘的终端并由此组成的系统，允许多个用户同时通过自己的终端，以交互的方式使用计算机，共享主机中的资源**；
|
||||
|
||||
分时技术定义： 把处理器的运行时间分成很短的时间片，按照时间片轮转把处理器分配给各个联机作业使用。若某个作业在分配给它的时间片内不能完成计算，则该作业暂时停止运行，把处理器让给其他作业，等待下一轮再继续运行。**由于计算机速度很快，作业运行轮转也很快，给每个用户的实际的感觉就好像是独占一台计算机**
|
||||
|
||||
> 如何使用户能与自己的作业进行交互，是实现分时系统最关键的问题，需要处理好及时接收、及时处理的问题。
|
||||
|
||||
- 及时接收：可以通过在系统中配置多路卡，通过多路卡实现分时多路复用
|
||||
- 及时处理：关键是实现人-机交互，用户输入命令后 ，能够对自己的作业及其运行及时地**实施控制**或者**进行修改**。需要各用户的作业都必须驻留在内存中，并且可以频繁地获得处理机运行。推荐采用：**作业直接进入内存**或者**时间片轮转方式**
|
||||
|
||||
> 时间片简单解释：
|
||||
>
|
||||
> 一个时间片就是一段很短的时间，系统规定每个作业每次只能运行一个时间片，然后就暂停该作业的运行，通过调度算法立即调度到下一个作业运行。使得每个用户都能及时地与自己的作业进行交互，用户的请求得到及时的响应
|
||||
|
||||
**主要特征**
|
||||
|
||||
> 与多道批处理系统相比，分时系统具有非常明显的特性，包含：多路性、独立性、及时性、交互性
|
||||
|
||||
- **多路性** 也可以叫做同时性，允许多个终端同时使用一台计算机（即：一台计算机与若干的终端相连接，终端上的用户可以同时或者基本同时使用计算机）
|
||||
- **独立性** 系统中的多个用户可以彼此独立地进行操作，互不干扰，就像单独操作计算机一样，自我感觉为一人独用
|
||||
- **及时性** 用户的请求能够在很短时间（用户能够接收的时间间隔）内获得响应
|
||||
- **交互性** 用户能够方便地与系统进行人-机交互对话，用户通过终端采用人-机交互的方式控制程序运行调度，与程序进行交互
|
||||
|
||||
> 理解好交互对话中对话的含义，不是说像日常人们之间言语的对话，是通过人的操作来获取程序的响应，像领导发号命令会及时响应；
|
||||
>
|
||||
> **分时操作系统较好的解决人-机交互问题**
|
||||
|
||||
#### 实时系统
|
||||
|
||||
> 为了能够在某个时间限制内完成某些紧急任务而不需要进行时间片排队 ，诞生了**实时操作系统**，时间限制有两种情况：
|
||||
>
|
||||
> - 硬实时系统 规定某个动作必须绝对地在规定的时刻（或者规定的时间范围）发生
|
||||
> - 软实时系统 能够接受偶尔违反时间规定，并且不会引起任何永久性的损害
|
||||
>
|
||||
> 上面两种情况，可以类比公司的上班只读：硬实时----->打卡上班，讲究KPI ，软实时------>扁平管理，推崇OKR
|
||||
|
||||
在实时操作系统的控制下，计算机系统受到外部信号后及时进行处理，并且要在严格限制内完成接收的时间。**实时操作系统的主要特点是及时性和可靠性**
|
||||
|
||||
**实时系统的类型**
|
||||
|
||||
- 工业（武器）控制系统
|
||||
- 信号查询系统
|
||||
- 多媒体系统
|
||||
- 嵌入式系统
|
||||
|
||||
**实时任务的类型**
|
||||
|
||||
> 关于截止时间（DeadLine）也叫最后期限的理解：
|
||||
>
|
||||
> 1.开始截止时间，指某任务在某时间以前必须开始执行
|
||||
>
|
||||
> 2.完成截止时间，指某项任务在某时间以前必须完成
|
||||
|
||||
- 周期性实时任务和非周期性实时任务
|
||||
- 硬实时任务和软实时任务
|
||||
|
||||
|
||||
|
||||
## 操作系统的基本特性
|
||||
|
||||
> 例如批处理系统 有高资源利用率和系统吞吐量特点，分时系统能够获得及时响应，实时系统具有实时的特征。横向比较，不同操作系统之间功能具有**并发、共享、虚拟、异步**的基本特征
|
||||
|
||||
### 并发(Concurrence)
|
||||
|
||||
> 并发是指两个或者多个事件在**同一事件间隔**内发生。而并行是指两个或多个事件在**同一时刻**发生
|
||||
|
||||
在多道程序环境下，一段时间内宏观上有多道程序在同时执行，而在每一时刻，单处理机环境下实际仅仅能有一道程序在执行。因此，**微观上程序还是在分时地交替执行**，操作系统的并发性是通过分时去实现的。
|
||||
|
||||
在操作系统中，引入进程的目的就是为了让程序能够并发的执行，多个进程之间可以鬓发执行和交换信息
|
||||
|
||||
> 进程：在系统中能独立运行并作为**资源分配的基本单位**，由一组机器指令、数据和堆栈等组合而成，是一个能独立运行的活动实体
|
||||
|
||||
|
||||
|
||||
### 共享（Sharing）
|
||||
|
||||
### 虚拟（Virtual）
|
||||
|
||||
### 异步（Asynchronism）
|
||||
|
||||
## 操作系统的主要功能
|
||||
|
||||
> 为了能够给多道程序提供良好的运行环境，操作系统应该具有：处理机管理、存储器管理、设备管理、文件管理的功能，同时方便用户使用操作系统，还必须提供接口。
|
||||
>
|
||||
> 引入操作系统的主要目的：为多道程序的运行提供良好的运行环境，保证多道程序能够有条不紊地、高效地运行，最大程度的提高系统中各种资源的利用率
|
||||
|
||||
## 操作系统的结构设计
|
||||
|
||||
Reference in New Issue
Block a user