数据结构期末复习
引言
选择题 30分 共15道
应用题 类似离散数学应该 55分
算法设计题 手撕代码 15分
Ch 1-数据结构绪论
基本概念
数据的基本单位是？ 数据元素
构成数据元素的不可分割最小单位是？ 数据项
什么是算法？ 答：算法是对特定问题求解步骤的一种描述，是指令的有限序列
算法的五大特性
输入 输出 有穷性 确定性 可行性
考察重点
数据的存储结构
顺序存储
数据元素之间的逻辑关系由元素的存储位置来表示
链接存储
数据元素之间的逻辑关系用指针来表示
线性表、树、图的特征
线性表：数据元素之间存在着一对一的线性关系
树结构：数据元素之间存在着一对多的层次关系
图结构：数据元素之间存在着多对多的任意关系
常用时空复杂度一览
课后题
Ch 2-线性表
考察重点
顺序存储
使用数组进行实现
存储要点：用一段地址连续的存储单元
依次存储线性表中的数据元素
特点是：随机存取
顺序表的实现直接基于数组进行操作即可
单链表
线性表的链接存储结构
元素之间的逻辑关系使用指针来表示
单链表的实现依赖于动态内存申请（new和delete）
一定要分清头节点和首元结点
头结点：一个工具结点 其本身数据域为空 后继结点为首元结点
首元结点：线性表真正意义上的第一个元素结点
单链表算法的设计模式（重要）
在解答题目时，没有必要使用数据类型模板，直接使用int就可以了大哥
大哥一定要把这个算法的设计模式记住 到时候考试直接照搬就可以了
判空条件
头节点的后继是否为空指针？
注意：在判断时要使用双等号 ==
算法举例：按值查找
插入结点
删除结点
头插
尾插
顺序表和单链表的适用条件
牢记这张图
涉及频繁的插入和删除操作时宜使用单链表
涉及频繁的查找操作时宜使用顺序表
课后题
Ch 3-栈和队列
各自的特点
栈和队列都是操作受限的线性表
栈—后进先出 LIFO
队列—先进先出 FIFO
常用操作也是插入和删除
允许插入和删除的一端称为栈的栈顶
栈的实现有顺序栈（使用数组）和链栈（单链表）两种
队列的实现常用的有顺序队列、链队列、循环队列几种，其中循环队列的相关操作必考！
循环队列
循环队列在实现时会设置两个关键要素，一个是队头位置front，另外一个是队尾位置rear,
循环队列的核心便在于循环意义，也就是在每次操作时针对队列所设置的大小进行取余操作
循环队列的入队操作是要将队尾位置rear在循环意义下加1.然后插入
void CirQueue::EnQueue(int newData)
{
if((rear+1)%QueueSize==front)
{
throw "栈满";
}
rear=(rear+1)%QueueSize; //队尾指针在循环意义下加1
data[rear]=newData; //插入新元素
}
同理，栈的出队操作也只需要将队头位置front在循环意义下加1
void CirQueue::DeQueue(int newData)
{
if(rear==front)
{
throw "栈空";
}
front=(front+1)%QueueSize; //队头在循环意义下加1
return data[front]; //返回出队前的队头元素
}
判空条件
我们默认顺序栈初始时给定栈顶指针 top=-1，
- 顺序栈 if(top==-1) 其中top为栈的栈顶索引
- 链栈 if(top==nullptr) 其中top为栈顶指针
- 循环队列 if(front==rear) 判断队头队尾是否为同一指针
- 循环队列如何判满？ if((rear+1)%QueueSize==front) 其中QueueSize为给定的队列大小
进制转换
int Turn(int oldData, int n) //形参为需要转换进制的十进制数和需要转换到的进制
{
LinkStack s1; //初始化一个余数栈
int k = 0; //位数
int result = 0; //返回的最终结果
while (n <= oldData) //取余压栈循环体
{
//cout << "原被除数为：" << oldData << endl;
int temp = oldData % n;
s1.push(temp);
k++;
//cout << "余数为：" << temp << endl;
oldData /= n;
//cout << "新被除数为：" << oldData << endl;
//cout << "----------------------" << endl;
}
k++;
//cout << "位数" << k << endl;
s1.push(oldData); //最后余数压栈
while (k != 0)
{
result += s1.pop() * pow(10, --k);
}
return result;
}
表达式求值
表达式求值这一知识点也非常重要，需要掌握
各自的应用情形
栈
- 递归的实现
- 表达式求值
- 进制转换
- 括号匹配
队列
队列的应用应该不作考察
课后题
Ch 4-字符串和多维数组
字符串这一章应该没什么要考的
最多最多考一个next值的书写以及稀疏矩阵的特殊表示（十字链表+三元组）
等到时候咱们线下一块复习的时候看
现在是封校第二天 我们继续复习
字符串的模式匹配算法
BF算法
BF算法运行示例
暴力算法
BF算法的性能之所以较低，主要是因为其在每趟匹配不成功时存在大量回溯，没有利用已经部分匹配的结果。
KMP算法
KMP算法的精髓就在于利用了已经得到的部分匹配信息 关键在于寻找next值
矩阵的压缩存储及表示
小题：记住，稀疏矩阵不属于特殊矩阵
三元组
十字链表
示例
Ch 5-树和二叉树
树的一些术语
树的结构是递归定义的，树的算法也多是递归设计实现的。
在线性结构中，逻辑关系表现为前驱-后继
在树结构中，逻辑关系表现为双亲-孩子
树的逻辑特征：树的结点有固定的父亲，结点不能属于多个子树，且子树之间不能有关系。
- 节点的度：结点所拥有的子树的个数，如二叉树中结点的度<=2
- 树的度：树中各结点度的最大值，如二叉树的度为2
- 叶子结点：度为0的结点，又称终端结点。
- 孩子结点、双亲结点、兄弟结点等不做赘述
- 路径：由上往下寻找的过程
- 在树结构中，路径是唯一的
- 结点所在层数：根节点的层数为1，向下依次+1
- 树的深度（高度）：树中所有结点的最大层数
- 树的宽度：书中每一层结点个数的最大值
二叉树基本术语
遍历是二叉树操作的基础！！！
二叉树的特点
- 每个结点最多有两棵子树
- 二叉树是有序的，其次序不能任意颠倒
左（右）斜树：所有结点都只有左（子）树的二叉树
斜树相当于退化成了线性表结构
满二叉树：所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上的二叉树
满二叉树的特点
- 叶子只能出现在最下一层
- 只有度0和度为2的结点
- 在同样深度的二叉树中结点个数最多
- 在同样深度的二叉树中叶子结点个数最多+
- 满二叉树一定是完全二叉树
完全二叉树
完全二叉树：在满二叉树中，从最后一个结点开始，任意个结点得到的二叉树
特点：
- 叶子结点只能出现在最下两层
- 完全二叉树中如果有度为1的结点，只可能有1个，且该节点只有左孩子
- 深度为k的完全二叉树在k-1曾上一定是满二叉树
- 在同样结点个数的二叉树中，完全二叉树的深度最小
二叉树的性质！！！
-
在一颗二叉树中，如果叶子结点数为a，度为2的结点数为b，则有a=b+1
-
-
在此情况下，一定为满二叉树
-
-
二叉树的遍历
前、中、后序遍历的基本思想不再赘述 以一张图代为讲解
二叉树的存储结构及算法
二叉树可以使用顺序存储和链式存储两种
二叉树的顺序存储结构一般仅存储完全二叉树
我们的二叉树一般使用二叉链表进行实现
//结点结构体的定义
struct BiNode
{
/* data */
int data;
BiNode *lchild; //左孩子
BiNode *rchild; //右孩子
};
叶子结点的标志：左右孩子指针均为空
求问：n个结点的二叉链表有多少个空指针？
三叉链表就是在二叉链表中增加一个指向双亲的指针域
二叉链表前序遍历 递归
void BiTree::PreOrder(BiNode *bt)
{
//递归调用的终止条件
if (bt == nullptr)
{
return;
}
else
{
//前序遍历： 根节点 左子树 右子树
cout << bt->data << " "; //输出数据域
PreOrder(bt->lchild);
PreOrder(bt->rchild);
}
}
统计二叉树中叶子结点个数
int BiTree::Leaf(BiNode *bt)
{
//递归实现
if (bt == nullptr)
{
return 0;
}
if (bt->lchild == nullptr && bt->rchild == nullptr)
{
return 1;
}
return Leaf(bt->lchild) + Leaf(bt->rchild); //递归调用子函数，求子树中叶子结点的个数
}
求二叉树的深度
int BiTree::Height(BiNode *bt)
{
//求二叉树的高度(深度)
if (bt == nullptr)
{
return 0;
}
int i = Height(bt->lchild);
int j = Height(bt->rchild);
if(i<j)
{
return j+1;
}
else
{
return i+1;
}
}
层序遍历 基于队列
void BiTree::LevelOrder()
{
//层序遍历 基于队列
BiNode *Q[100]; //所需队列
BiNode *q = nullptr;
int front = -1, rear = -1; //队列初始条件
if (root == nullptr)
{
//空树不操作
return;
}
Q[++rear] = root; //根指针入队
while (front != rear)
{
//遍历条件：当队列非空时
q = Q[++front]; //出队
cout << q->data << " ";
if (q->lchild != nullptr)
Q[++rear] = q->lchild;
if (q->rchild != nullptr)
Q[++rear] = q->rchild;
}
}
线索二叉树！！！
个人看来，线索二叉树中的线索指的就是在不同序遍历情况下，二叉树中结点对应的在遍历序列中的前驱后继关系。
线索二叉树举例
树、森林与二叉树的转换
什么是森林？
树转换为二叉树
注意：
树的前序遍历等价于二叉树的前序遍历！
树的后序遍历等价于二叉树的中序遍历！
森林转换为二叉树
二叉树转换为树（森林）感觉不考
最优二叉树！！！
为结点加上权值
什么是最优二叉树？
最优二叉树又称哈夫曼树
特点
- 权值越大的叶子结点越靠近根结点
- 只有度为0和度为2的结点，不存在度为1的结点
哈夫曼算法
依次选取最小的个结点，然后组成树，再递归创建
哈夫曼编码 必考
我们一般使用前缀编码
前缀编码的特点
- 在一组编码中，任一编码都不是其它任何编码的前缀
哈夫曼编码示例 课后题
题目：
假设用于通信的电文由字符集{a,b,c,d,e,f,g}构成，它们在电文中出现的频率分别为{0.31,0.16,0.10,0.08,0.11,0.20,0.04}，请为这7个字符设计哈夫曼编码
课后题补充：
已知一棵度为m的树中有：n1个度为1的结点，n2个度为2的结点…nm个度为m的结点，问该树中共有多少个叶子结点？
答：
(n1*1+n2*2+...+nm*m)-(n1+n2+...+nm)+1
Ch 6-图
图的术语
- 图：图是由顶点的有穷非空集合和顶点之间边的集合组成
- 通常用G=(V,E)表示，V为顶点集，E为边集
- 图分为无向图和有向图
- 无向图：图中任意两个顶点之间的边都是无向边
- 权：对边赋予的有意义的数值量
- 带权图（网图）：边上带权的图 作为对比，在树中，权通常赋予结点
- 稠密图：边数很多的图
- 稀疏图：边数很少的图
- 无向完全图：无向图中，任意两个顶点之间都存在边
- n个顶点的无向完全图中有n*(n-1)/2条边
- 有向完全图：有向图中，任意两个顶点之间都存在方向相反的两条弧
- n个顶点的有向完全图中有n*(n-1)条弧
- 顶点的度：在无向图中，顶点v的度值得是依附于该顶点的边数
- 入度：指向该顶点的弧的数目
- 回路：第一个顶点和最后一个顶点相同的路径
- 简单路径：序列中顶点不重复出现的路径
- 简单回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路
- 路径长度：对于非带权图为路径上边的个数，对于带权图为路径上边的权值之和
图的核心操作-遍历
深度优先遍历
DFS，Depth First Search
假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。
看一张图：
上述由7个顶点构成的图的深度优先遍历顺序应该为？
答案是:
ACBEDFG
图的深度优先遍历技术需要借助栈结构，由于递归本身就使用了函数栈的特性，所以无需额外使用其余的栈。
void MGraph::DFTraverse(int v)
{
cout<<vertex[v]<<" ";
visited[v]=1;
for(int j=0;j<vertexNum;j++)
{
if(edge[v][j]==1 && visited[j]==0)
{
DFTraverse(j);
}
}
}
广度优先遍历
BFS，Breadth First Search
广度优先搜索思想：从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。
上述图的广度优先遍历序列为：
ABECDFGH
void MGraph::BFTraverse(int v)
{
int w,j,Q[MaxSize]; //顺序队列，有点取巧
int front=-1,rear=-1;
cout<<vertex[v]<<" ";
visited[v]=1;
Q[++rear]=v;
while(front!=rear)
{
//当队列非空时为循环条件
w=Q[++front];
for(j=0;j<vertexNum;j++)
{
if(edge[w][j]==1 && visited[j]==0)
{
cout<<vertex[j]<<" ";
visited[j]=1;
Q[++rear]=j;
}
}
}
}
图的存储结构
邻接矩阵
图的邻接矩阵（Adjacency Matrix)存储方式是用两个数组来表示图。一个一维的数组存储图中顶点信息，一个二维数组（称为邻接矩阵）存储图中的边或弧的信息。
设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：
来看一个实例
邻接表
图的链式存储结构
基于链表的相关操作
顶点表结点
struct VertexNode //顶点表结点
{
char vertex;
EdgeNode *firstEdge;
};
边表结点
struct EdgeNode //定义边表结点
{
int adjvex; //临接点域(编号)
EdgeNode *next;
};
邻接矩阵转换为邻接表
void MGraph::Turn()
{
//初始化指针数组
for(int i=0;i<MaxSize;i++)
{
this->adjlist[i].firstEdge=nullptr;
}
//将邻接矩阵转换为邻接表
EdgeNode *s1=nullptr; //工具指针
//先初始化vertex数组 点表 adjlist
for(int i=0;i<vertexNum;i++)
{
//初始化顶点表
adjlist[i].vertex=vertex[i];
}
//转换边表
for(int i=0;i<vertexNum;i++)
{
for(int j=0;j<vertexNum;j++)
{
if(edge[i][j]==1)
{
cout<<"["<<i<<","<<j<<"]"<<"值为1"<<endl; //输出方便看到过程
//如果有边的话就转换成邻接表
s1=new EdgeNode;
s1->adjvex=j;
s1->next=adjlist[i].firstEdge; //插入表头
adjlist[i].firstEdge=s1;
}
}
}
}
这一块后面看我其余的文章
邻接表与邻接矩阵的比较
最小生成树
Prim算法
核心思想：以某一点为起点开始，依次找最短边
KrusKal算法
边集的加入条件：最短边 处于不同的连通分量
最小生成树算法比较
最短路径问题
Dijkstra
Floyd-他似乎没怎么讲/。
AOV网与AOE网
AOV–用顶点表示活动，用弧表示活动间的优先关系
AOE–用边表示活动，用顶点表示事件
拓扑序列
关键路径问题
题目
解题
Ch 7-查找技术
查找的分类
静态查找：不涉及插入和删除操作的查找
动态查找：涉及插入和删除操作的查找
查找结构：查找所依赖的数据结构
线性表的查找技术
线性表的查找技术主要有顺序查找和折半查找两种
折半查找代码实现
二叉排序树（BST BiSortTree）
在二叉排序树中，要时刻牢记它的特点：
- 每一个结点的左子树都小于其父亲结点
- 每一个结点的右子树都大于其父亲结点
- 每一个结点的左右子树都是二叉排序树
二叉排序树是记录之间满足某种大小关系的二叉树
二叉排序树使用二叉链表进行存储
二叉排序树数据结构定义
struct BiNode
{
int data;
BiNode* lchild; //左子树
BiNode* rchild; //右子树
};
class BiSortTree
{
public:
BiSortTree(int a[], int n);
~BiSortTree() { Release(root); }
BiNode* InsertBST(int x) { return InSertBST(root, x); }
void DeleteBST(BiNode* p, BiNode* f);
BiNode* SearchBST(int k) { return SearchBST(root, k); }
private:
BiNode* root;
BiNode* InSertBST(BiNode* bt, int x);
BiNode* SearchBST(BiNode* bt, int k);
void Release(BiNode* bt);
};
二叉排序树的查找
二叉排序树的查找也是一个递归算法
有点像我们课设中的深度优先查找
递归算法
BiNode<int>* BiSortTree::SearchBST(BiNode<int>* bt,int k)
{
if(bt==nullptr)
{
return nullptr;
}
if(bt->data==k)
{
return bt; //查找成功
}
else if(bt->data>k)
{
return SearchBST(bt->lchild,k); //递归查找左子树
}
else
{
return SearchBST(bt->rchild,k); //递归查找右子树
}
}
二叉排序树的插入
BiNode<int>* BiSortTree::InsertBST(BiNode<int>* bt,int x)
{
if(bt==nullptr)
{
//初始化新结点 模板类
BiNode<int>* s=new BiNode<int>;
s->data=x;
s->lchild=s->rchild=nullptr;
bt=s;
return bt;
}
else if(bt->data>x)
{
//如果新结点数据小于父亲结点
bt->lchild=InsertBST(bt->lchild,x);
}
else
{
//如果新结点数据大于父亲结点
bt->rchild=InsertBST(bt->rchild,x);
}
}
二叉排序树的构造
二叉排序树的删除（重要！！）
二叉排序树结点的删除要考虑多种情况
因为二叉树的结点在删除结点后，仍然要保持二叉排序树的特性。
那么你还记得二叉排序树的特性吗？
- 二叉排序树左边的结点一定小于其双亲结点
- 二叉排序树右边的结点一定大于其双亲结点
- 二叉排序树中每个结点的左右子树都是二叉排序树
- 二叉排序树和二叉树一样也是通过递归进行定义的
删除情形1
情形1-被删除的结点是叶子结点
删除情形2
被删除的结点只有左子树或者只有右子树
删除情形3
被删除的结点既有左子树也有右子树
特点：以其左子树中的最大值结点替换之，然后再删除该结点。
但是要考虑特殊情况：左子树中的最大值结点是被删结点的孩子
void BiSortTree::DeleteBST(BiNode<int>* p,BiNode<int>* f)
{
if((p->lchild==nullptr)&&(p->rchild==nullptr))
{
//如果p为叶子结点
f->lchild=nullptr;
delete p;
return;
}
if(p->rchild==nullptr)
{
//p只有左子树
f->lchild=p->lchild;
delete p;
return;
}
if(p->lchild==nullptr)
{
//p只有右子树
f->lchild=p->rchild;
delete p;
return;
}
//情形：p的左右子树均不空
while(s->rchild!=nullptr)
{
//查找左子树的最右下结点
par=s;
s=s->rchild;
}
p->data=s->data;
if(par==p)
{
par->lchild=s->lchild;
}
else
{
par->rchild=s->lchild;
}
delete s;
}
二叉排序树的性能分析
二叉排序树的查找性能取决于树的深度
二叉排序树的比较次数不超过树的深度
平衡二叉树 次重点
平衡因子的计算
某结点的平衡因子=该结点的左子树深度-该结点的右子树深度
某结点的平衡因子只能够是1、0、-1
注意：在计算深度时，不能算上本结点，因为计算的是子树的深度
平衡二叉树的性质
- 根结点的左子树和右子树的深度最多相差1
- 根结点的左子树和右子树也都是平衡二叉树
- 结点的平衡因子只能够是1、0、-1
平衡调整方法
扁担原理：将根结点看成是扁担中肩膀的位置
旋转优先：旋转下来的结点作为新根结点的孩子
LL
RR
LR
RL
B树
B树–一棵m阶的B树或者为空树，或者为满足下列特性的m叉树：
- 每个结点至多有m棵子树
- 根结点至少有两棵子树
- 除根结点和叶子结点外，所有结点至少有 m/2棵子树
B树的插入（定位+分裂/提升）
散列
散列基本概念
散列是一种面向查找的存储结构
散列可以理解为C++中的字典
- 散列的基本思想：在记录的关键码和存储地址之间建立一个确定的对应的关系，通过计算得到待查记录的地址。
- 散列表：采用散列技术存储查找集合的连续存储空间
- 散列函数：将关键码映射为散列表中适当存储位置的函数
- 散列地址：由散列函数所得的存储地址
散列的关键问题-冲突
冲突：如果两个不同的关键码指向了同一散列地址，则称产生了冲突
散列函数
散列函数设计的原则
- 计算简单
- 地址均匀
常见的散列函数
- 直接定址法
- 平方取中法
- 除留余数法 H(key)=key mod p
开放定址法
开放定址法主要有线性探测法和二次探测法
线性探测法
线性探测法的核心思想：从冲突位置的下一个位置起，依次寻找空的散列地址。
堆积：非同义词对同一个散列地址争夺的现象
二次探测法
二次探测法的核心思想：以冲突位置为中心，跳跃式寻找空的散列地址
二次探测法相比线性探测法而言能够有效减少堆积的产生。
拉链法处理冲突
散列表的查找性能
开散列表与闭散列表的比较
Ch 8-排序技术
排序基本概念
排序算法还分为内排序和外排序
内排序：在排序的整个过程中，待排序的所有记录全部放在内存中
外排序：待排序的记录个数较多，整个排序过程需要在内外存之间多次交换数据才能得到排序的结果
排序算法类的定义
插入排序
直接插入排序 稳定
直接插入排序算法是一种稳定的排序算法
关键问题：在插入第i（i>1）个记录时，前面的i-1个记录已经排好序
//直接插入排序
void Sort::InsertSort()
{
int i,j,temp;
for(i=1;i<length;i++)
{
temp=data[i];
j=i-1;
while(j>=0&&temp<data[j])
{
data[j+1]=data[j];
j--;
}
data[j+1]=temp;
}
}
希尔排序
希尔排序是一种不稳定排序算法
我对于希尔排序的理解就是局部的直接插入排序
void Sort::ShellSort()
{
int d,i,j,temp;
//增量为d进行直接插入排序
for(d=length/2;d>=1;d=d/2)
{
for(i=d;i<length;i++)
{
//进行一趟希尔排序
temp=data[i]; //暂存待插入记录
for(j=i-d;j>=0&&temp<data[j];j=j-d)
{
data[j+d]=data[j];
}
data[j+d]=temp;
}
}
}
交换排序
交换排序，顾名思义，其核心思想就在于交换
交换排序是一种稳定的排序算法
在待排序列中选两个记录，将它们的关键码相比较，如果反序（即排列顺序与排序后的次序正好相反）。则交换它们的存储位置
起泡排序
基本思想：两两比较相邻记录，如果反序则交换，直到没有反序的记录为止。
void Sort::BubbleSort()
{
int j,exchange,bound,temp;
exchange=length-1; //第一趟起泡排序的区间是[0~length-1]
while(exchange!=0)
{
bound=exchange;
exchange=0;
for(j=0;j<bound;j++)
{
//一趟起泡排序的区间是[0~bound]
if(data[j]>data[j+1])
{
temp=data[j];
data[j]=data[j+1];
data[j+1]=temp;
exchange=j; //记载每一次记录交换的位置
}
}
}
}
快速排序 重要
快速排序是一种不稳定的排序算法
快速排序的基本思想：
选定一个轴值，将待排序记录划分成两部分，左侧记录均小于或等于轴值，右侧记录均大于或等于轴值，然后分别对这两部分重复上述过程，直到整个序列有序。
一次划分：以轴值为基准将无序序列划分为两部分
关键问题在于如何选择轴值和实现分隔
一次划分算法
如何处理分割得到的两个待排序子序列？
对分割得到的两个子序列递归地执行快速排序
算法描述
选择排序
选择排序的主要操作就是选择
选择排序的主要思想：每趟排序在当前待排序序列中选出关键码最小的记录，添加到有序序列中。
简单选择排序
简单选择排序是一种不稳定的排序算法
void Sort::SelectSort()
{
int i,j,index,temp;
for(i=0;i<length;i++)
{
index=i;
for(j=i+1;i<length-1;j++)
{
if(data[j]<data[index])
{
index=j;
}
}
if(index!=i)
{
temp=data[i];
data[i]=data[index];
data[index]=temp;
}
}
}
堆排序 重要
堆排序是一种不稳定的排序算法
什么是堆？
堆排序的基本思想
堆调整算法 Sift
void Sort::HeapSort()
{
int i,temp;
//建立堆：从最后一个分支结点至根结点调整
for(i=length/2-1;i>=0;i--)
{
Sift(i,length-1);
}
for(i=1;i<length;i++)
{
temp=data[0];
data[0]=data[length-i];
data[length-i]=temp;
Sift(0,length-i-1); //重建堆
}
}
归并排序
归并排序的主要操作是归并
主要思想：将若干有序序列逐步归并，最终得到一个有序序列
归并：将两个或两个以上的有序序列合并成一个有序序列的过程。
这一块截图不太方便
回头直播间里教大哥吧
各种排序算法的比较
在当前待排序序列中选出关键码最小的记录，添加到有序序列中。
简单选择排序
简单选择排序是一种不稳定的排序算法
void Sort::SelectSort()
{
int i,j,index,temp;
for(i=0;i<length;i++)
{
index=i;
for(j=i+1;i<length-1;j++)
{
if(data[j]<data[index])
{
index=j;
}
}
if(index!=i)
{
temp=data[i];
data[i]=data[index];
data[index]=temp;
}
}
}
堆排序 重要
堆排序是一种不稳定的排序算法
什么是堆？
堆排序的基本思想
堆调整算法 Sift
void Sort::HeapSort()
{
int i,temp;
//建立堆：从最后一个分支结点至根结点调整
for(i=length/2-1;i>=0;i--)
{
Sift(i,length-1);
}
for(i=1;i<length;i++)
{
temp=data[0];
data[0]=data[length-i];
data[length-i]=temp;
Sift(0,length-i-1); //重建堆
}
}
归并排序
归并排序的主要操作是归并
主要思想：将若干有序序列逐步归并，最终得到一个有序序列
归并：将两个或两个以上的有序序列合并成一个有序序列的过程。
这一块截图不太方便
回头直播间里教大哥吧
各种排序算法的比较
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
