栈和队列
栈和队列是两种特殊的线性表，是操作受限的线性表(限定性DS)
栈: 限定仅在表尾进行插入或删除操作的线性表，表尾—栈顶，表头—栈底，不含元素的空表称空栈；栈是一种先进后出(FILO)或者后进先出(LIFO)的数据结构
CPU中使用SP寄存器来作为栈的操作指针，使用sp寄存器来存储栈的地址(实际上栈是一块连续的内存空间)； -- 通过CPU指令系统中的指令直接操作
向上增长表示栈底元素的内存地址小于栈顶元素的内存地址
sp指向栈顶元素的时候称为满栈
sp指向下一次要插入的元素的位置空栈
向上增长满栈IF
入栈: sp++, *sp = data;
出栈: data = *sp, sp--;
向上增长空栈IE
入栈: *sp = data, sp++;
出栈: sp--, data = *sp;
向下增长满栈DF
向下增长空栈DE
内存中的栈空间 -- 内存区域的一个分类
数据结构中的栈:
栈的存储结构: 顺序存储(顺序栈)、链式存储(链栈)
栈的定义:
表示栈顶位置的指针或者序号top
表示栈中存储的内容的data
表示栈中元素个数size
栈的容量capacity
栈的操作:
判栈空，判栈满，入栈push，出栈pop
n个元素通过栈以后可能的出栈序列有: (2n)!/(n+1)!/n!
比如: 5个元素通过栈的出栈序列有: 10!/6!/5! = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 / (6 * 5 * 4 * 3 * 2 * 1) / (5 * 4 * 3 * 2 * 1) = 10 * 9 * 8 * 7 / (5 * 4 * 3 * 2 * 1) = 2 * 3 * 2 * 7 / 2 = 42
栈的应用:
a. 编译器在处理算术表达式的时候使用栈
34 + 13 * 9 + 44 - 12 / 3
编译器使用两个栈，一个栈中放数据，另外一个栈中放运算符；从左到右遍历表达式，当遇到数字的时候，将数字直接压入栈中；当遇到运算符的时候，将当前运算符和栈顶的运算符进行比较，如果遇到的运算符比栈顶的运算符优先级高，要将该运算符压栈，如果遇到的运算符比栈顶的运算符优先级低或者相等，就从数据栈中取出两个操作数，从运算符栈中取出栈顶的运算符然后进行运算，再把运算结果压入数据栈中
b. 进制转换栈
进制转换采用除留余数法
队列:队列是限定只能在表的一端进行插入，在表的另一端进行删除的线性表 -- 先进先出的数据结构FIFO
队尾(rear)——允许插入的一端
队头(front)——允许删除的一端
队列的存储结构: 顺序存储和链式存储
顺序队列存在问题
设数组维数为M，则：
当front=-1,rear=M-1时，再有元素入队发生溢出——真溢出
当front?-1,rear=M-1时，再有元素入队发生溢出——假溢出
解决方案
队首固定，每次出队剩余元素向下移动——浪费时间
循环队列
基本思想：把队列设想成环形，让sq[0]接在sq[M-1]之后，若rear+1==M,则令rear=0;
实现：利用“模”运算
入队： rear=(rear+1)%M; sq[rear]=x;
出队： front=(front+1)%M; x=sq[front];
队满、队空判定条件都是front == rear
解决方案：
1.另外设一个标志以区别队空、队满
2.少用一个元素空间：
队空：front==rear
队满：(rear+1)%M==front
树和二叉树
树是一类重要的非线性数据结构，是以分支关系定义的层次结构
定义：树(tree)是n(n>=0)个结点的有限集T，其中：
有且仅有一个特定的结点，称为树的根(root)
当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1,T2,……Tm，其中每一个集合本身又是一棵树，称为根的子树(subtree)
术语:
结点(node)——表示树中的元素，包括数据项及若干指向其子树的分支
结点的度(degree)——结点拥有的子树数
叶子(leaf)——度为0的结点
孩子(child)——结点子树的根称为该结点的孩子
双亲(parents)——孩子结点的上层结点叫该结点的~
兄弟(sibling)——同一双亲的孩子
树的度——一棵树中最大的结点度数
结点的层次(level)——从根结点算起，根为第一层，它的孩子为第二层……
深度(depth)——树中结点的最大层次数
高度(high)——树的高度在数值上等于树的深度，但是深度的概念是从根节点到叶子节点，而高度的概念是从叶子节点到根节点
二叉树:
二叉树是n(n?0)个结点的有限集，它或为空树(n=0)，或由一个根结点和两棵分别称为左子树和右子树的互不相交的二叉树构成
特点:
每个结点至多有二棵子树(即不存在度大于2的结点)
二叉树的子树有左、右之分，且其次序不能任意颠倒
性质1：
在二叉树的第i层上至多有2^(i-1)个节点
性质2：
深度为k的二叉树至多有2^k-1个结点(k>=1)
性质3：
对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1
特殊的二叉树
a. 满二叉树: k层的二叉树具有2^k - 1个节点
b. 完全二叉树: 深度为k，有n个结点的二叉树当且仅当其每一个结点都与深度为k的满二叉树中编号从1至n的结点一一对应时
性质4：
具有n个节点的完全二叉树的深度为logn + 1
性质5：如果对一棵有n个结点的完全二叉树的结点按层序编号，则对任一结点i(1<=i<=n)，有：
(1) 如果i=1，则结点i是二叉树的根，无双亲；如果i>1，则其双亲是i/2?
(2) 如果2i>n，则结点i无左孩子；如果2i<=n，则其左孩子是2i
(3) 如果2i+1>n，则结点i无右孩子；如果2i+1<=n，则其右孩子是2i+1
在一棵二叉树中，对于编号为i的节点，其双亲的编号是i/2, 其左孩子的编号是2i，其右孩子的编号是2i+1
数的存储:
1. 双亲表示法
实现：定义结构数组存放树的结点，每个结点含两个域：
数据域：存放结点本身信息
双亲域：指示本结点的双亲结点在数组中位置
typedef struct node
{
datatype data;
int parent;
}JD;
JD t[M];
特点: 找双亲容易，找孩子难
2. 孩子表示法
a. 多重链表：每个结点有多个指针域，分别指向其子树的根
结点同构：结点的指针个数相等，为树的度D
结点不同构：结点指针个数不等，为该结点的度d
b. 孩子链表：每个结点的孩子结点用单链表存储，再用含n个元素的结构数组指向每个孩子链表
孩子结点：
typedef struct node
{
int child; //该结点在表头数组中下标
struct node *next; //指向下一孩子结点
}JD;
表头结点：
typedef struct tnode
{
datatype data; //数据域
struct node *fc; //指向第一个孩子结点
}TD;
TD t[M]; //t[0]不用
特点: 找孩子简单但是找双亲难
c. 带双亲的孩子链表
结合双亲表示法和孩子链表存储方式
表头结点：
typedef struct tnode
{
datatype data; //数据域
int parent;
struct node *fc; //指向第一个孩子结点
}TD;
TD t[M]; //t[0]不用
d. 孩子兄弟表示法（二叉链表表示法）
实现：用二叉链表作树的存储结构，链表中每个结点的两个指针域分别指向其第一个孩子结点和下一个兄弟结点
typedef struct node
{
datatype data;
struct node *fch, *nsib; //一个指针指向第一个孩子，另外一个指针指向节点的下一个兄弟
}JD;
二叉树的存储结构:
1. 顺序存储
实现：按满二叉树的结点层次编号，依次存放二叉树中的数据元素
特点：
结点间关系蕴含在其存储位置中
浪费空间，适于存满二叉树和完全二叉树
2. 链式存储
2.1 二叉链表
typedef struct node
{
datatype data;
struct node *lchild, *rchild;
}JD;
在n个结点的二叉链表中，有n+1个空指针域
2.2 三叉链表
typedef struct node
{
datatype data;
struct node *lchild, *rchild, *parent;
}JD;
树和二叉树之间的转换
将树转换成二叉树
加线：在兄弟之间加一连线
抹线：对每个结点，除了其左孩子外，去除其与其余孩子之间的关系
旋转：以树的根结点为轴心，将整树顺时针转45°
将二叉树转换成树
加线：若p结点是双亲结点的左孩子，则将p的右孩子，右孩子的右孩子，……沿分支找到的所有右孩子，都与p的双亲用线连起来
抹线：抹掉原二叉树中双亲与右孩子之间的连线
调整：将结点按层次排列，形成树结构
森林转换成二叉树
将各棵树分别转换成二叉树
将每棵树的根结点用线相连
以第一棵树根结点为二叉树的根，再以根结点为轴心，顺时针旋转，构成二叉树型结构
二叉树转换成森林
抹线：将二叉树中根结点与其右孩子连线，及沿右分支搜索到的所有右孩子间连线全部抹掉，使之变成孤立的二叉树
还原：将孤立的二叉树还原成树
二叉树的遍历
遍历——按一定规律走遍树的各个顶点，且使每一顶点仅被访问一次，即找一个完整而有规律的走法，以得到树中所有结点的一个线性排列
树的常用遍历方法:
先根（序）遍历：先访问树的根结点，然后依次先根遍历根的每棵子树
后根（序）遍历：先依次后根遍历每棵子树，然后访问根结点
按层次遍历：先访问第一层上的结点，然后依次遍历第二层，……第n层的结点
二叉树的遍历
方法
先序遍历：先访问根结点,然后分别先序遍历左子树、右子树 -- 根左右
中序遍历：先中序遍历左子树，然后访问根结点，最后中序遍历右子树--左根右
后序遍历：先后序遍历左、右子树，然后访问根结点 -- 左右根
按层次遍历：从上到下、从左到右访问各结点
一般情况下如果给定义一棵二叉树的中序遍历序列，结合先序或者后序就可以唯一的确定一棵二叉树。
已知一棵二叉树的先序遍历序列: AEFBGCDHIKJ, 中序遍历序列为EFAGBCHKIJD，画出此二叉树
二叉树遍历的实现:
递归: 一个函数中调用这个函数自己
求阶乘 n! = n * (n - 1)! 1！= 1 0！= 1
f(n) = n * f(n - 1)
求最大公约数
求斐波那契数列: f(n) = f(n - 1) + f(n - 2)
f(0) = 1 f(1) = 1
递归必须要满足的三个条件:
a. 待求解的问题的解可以分解为几个子问题的解(子问题是数据规模更小的问题)
b. 待求解的问题与分解滞后的子问题，只是问题规模不同，求解的思路是完全相同的
c. 存在递归终止的条件
在实现递归算法的时候：
a. 确定递推公式
b. 确定递归的出口
int f(int n)
{
if(n == 1) //定义的递归的出口
{
return 1;
}
return f(n - 1) + 1; //递推公式
}
在实现递归的过程中一定要注意避免出现堆栈溢出
在每一次函数调用的时候，都会需要使用栈来保存临时变量(现场的保护); 每调用一个新的函数，都会需要将临时变量封装成栈帧压入内存栈，等函数执行完成以后，再将栈帧弹出栈(现场的恢复)
如果递归求解的问题规模很大，调用的层次很深，就可能导致栈溢出；一般可以通过定义递归深度来解决
int depth = 0; //表示递归深度的全局变量
int f(int n)
{
++depth;
if(depth > 999) throw exception; //C++
if(depth > 999) return 1; //C中
if(n == 1) //定义的递归的出口
{
return 1;
}
return f(n - 1) + 1; //递推公式
}
但是因为允许递归的深度是和当前线程所剩下的栈空间的大小有关，事先无法预估，要计算允许的递归深度比较麻烦。
#include <stdio.h>
#include <stdlib.h>
typedef int NodeDataType;
//二叉树的节点：采用二叉链表的存储方式
typedef struct node
{
NodeDataType data;
struct node *lchild, *rchild; //两个指针域分别指向节点的左子树和右子树的根节点
}Node;
//创建节点
Node *newNode(NodeDataType data)
{
Node *node = (Node *)malloc(sizeof(Node));
if(NULL == node)
{
return NULL;
}
//填充节点信息
node->data = data;
node->lchild = NULL;
node->rchild = NULL;
return node;
}
//释放二叉树的节点资源
void freeNode(Node *node)
{
if(NULL == node)
{
return;
}
//采用后序遍历的方式遍历二叉树的每一个节点(根节点最后访问)，然后释放该节点资源
freeNode(node->lchild);
freeNode(node->rchild);
free(node);
}
//后序遍历
void printPostOrder(Node *node)
{
if(NULL == node) //递归出口
{
return;
}
//先后序遍历左子树
printPostOrder(node->lchild);
//再后序遍历右子树
printPostOrder(node->rchild);
//访问根节点
printf("%4d", node->data);
}
int main()
{
//定义一棵二叉树
Node *root = newNode(1);
root->lchild = newNode(2);
root->rchild = newNode(3);
root->lchild->lchild = newNode(4);
root->lchild->rchild = newNode(5);
root->rchild->lchild = newNode(6);
root->rchild->rchild = newNode(7);
root->lchild->lchild->rchild = newNode(8);
root->lchild->rchild->lchild = newNode(9);
root->rchild->rchild->lchild = newNode(10);
printf("后序遍历: ");
printPostOrder(root);
printf("\n");
return 0;
}
运行结果：
后序遍历: 8 4 9 5 2 6 10 7 3 1
完整代码:
#include <stdio.h>
#include <stdlib.h>
typedef int NodeDataType;
//二叉树的节点：采用二叉链表的存储方式
typedef struct node
{
NodeDataType data;
struct node *lchild, *rchild; //两个指针域分别指向节点的左子树和右子树的根节点
}Node;
//创建节点
Node *newNode(NodeDataType data)
{
Node *node = (Node *)malloc(sizeof(Node));
if(NULL == node)
{
return NULL;
}
//填充节点信息
node->data = data;
node->lchild = NULL;
node->rchild = NULL;
return node;
}
//释放二叉树的节点资源
void freeNode(Node *node)
{
if(NULL == node)
{
return;
}
//采用后序遍历的方式遍历二叉树的每一个节点(根节点最后访问)，然后释放该节点资源
freeNode(node->lchild);
freeNode(node->rchild);
free(node);
}
//后序遍历
void printPostOrder(Node *node)
{
if(NULL == node) //递归出口
{
return;
}
//先后序遍历左子树
printPostOrder(node->lchild);
//再后序遍历右子树
printPostOrder(node->rchild);
//访问根节点
printf("%4d", node->data);
}
//先序遍历
void printPreOrder(Node *node)
{
if(NULL == node)
{
return;
}
//访问根节点
printf("%4d", node->data);
//先序遍历左子树
printPreOrder(node->lchild);
//先序遍历右子树
printPreOrder(node->rchild);
}
//中序遍历
void printMidOrder(Node *node)
{
if(NULL == node)
{
return;
}
//中序遍历左子树
printMidOrder(node->lchild);
//访问根节点
printf("%4d", node->data);
//中序遍历右子树
printMidOrder(node->rchild);
}
int main()
{
//定义一棵二叉树
Node *root = newNode(1);
root->lchild = newNode(2);
root->rchild = newNode(3);
root->lchild->lchild = newNode(4);
root->lchild->rchild = newNode(5);
root->rchild->lchild = newNode(6);
root->rchild->rchild = newNode(7);
root->lchild->lchild->rchild = newNode(8);
root->lchild->rchild->lchild = newNode(9);
root->rchild->rchild->lchild = newNode(10);
printf("后序遍历: ");
printPostOrder(root);
printf("\n");
printf("中序遍历: ");
printMidOrder(root);
printf("\n");
printf("先序遍历: ");
printPreOrder(root);
printf("\n");
return 0;
}
运行结果：
后序遍历: 8 4 9 5 2 6 10 7 3 1
中序遍历: 4 8 2 9 5 1 6 3 10 7
先序遍历: 1 2 4 8 5 9 3 6 7 1
扫一扫
427
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
