玳瑁的嵌入式日记D23-08022（数据结构）-CSDN博客

队列

队列是只允许在一段进行插入，而在另一端进行删除操作的线性表

允许插入的称谓队尾，允许删除的一端队头
顺序队列
循环队列

数组实现的队列通常采用循环队列的形式，以充分利用空间

链表实现的队列可以动态分配内存，没有固定大小限制
常用操作，入队，出队
先进先出，FIFO

作用：缓冲，速度不匹配

typedef struct queue {
DATATYPE *array;
int tlen;
int head;
int tail;
}SeqQue;

SeqQue* CreateSeqQue(int len)
{
SeqQue* sq = malloc(sizeof(SeqQue));
if(NULL == sq)
{
perror("CreateSeqQue malloc");
return NULL;
}

sq->array = malloc(sizeof(DATATYPE)*len);
if(NULL == sq->array)
{
perror("CreateSeqQue malloc2");
return NULL;
}
sq->head = 0 ;
sq->tail = 0;
sq->tlen = len;

return sq;

}
int EnterSeqQue(SeqQue*sq,DATATYPE*data)
{
if(IsFullSeqQue(sq))
{
printf("queue is full\n");
return 1;
}
memcpy(&sq->array[sq->tail],data,sizeof(DATATYPE));
//sq->tail++;
sq->tail = (sq->tail+1 )%sq->tlen;
return 0;
}
int QuitSeqQue(SeqQue* sq)
{
if(IsEmptySeqQue(sq))
{
printf("queue is empty\n");
return 1;
}
sq->head = (sq->head+1)%sq->tlen;
return 0;
}
DATATYPE* GetHeadSeqQue(SeqQue* sq)
{
return &sq->array[sq->head];
}
int IsEmptySeqQue(SeqQue* sq)
{
return sq->head == sq->tail; //重点利用% 循环储存
}
int IsFullSeqQue(SeqQue* sq)
{
return (sq->tail+1)%sq->tlen == sq->head; // 预留位置判断Full
}
int DestroySeqQue(SeqQue* sq)
{
free(sq->array);
free(sq);
return 0;

}

树

树：n（n>=0）个结点的有限集合。n = 0 ,空树。
在任意一个非空树中，
1，有且仅有一个特定的根结点
2，当 n>1 时，其余结点可分为m个互不相交的有限集合T1,T2,T3.。。。。Tm，其中每一个
集合又是一个树，并且称谓子树。

结点拥有子树的个数称谓结点的度。度为0的结点称谓叶结点。度不为0，称谓分支结点。

树的度数是指，这棵树中，最大的结点的度数，称谓树的度数。
树的深度或高度，从根开始，根为第一层，根的孩子为第二层。

树的存储，顺序结构，链式结构。

二叉树，binary tree
n个结点的有限集合，集合要么为空树，要么由一个根结点和两棵互不相交，分别称谓根结点的左子树和右子树的二叉树组成。。

特点
1，每个结点最多两个子树。
2，左子树和右子树是有顺序的，次序不能颠倒。
3，如果某个结点只有一个子树，也要区分左，右子树。

特殊的二叉树
1，斜树，所有的结点都只有左子树，左斜树，所有结点都只有右子树，右树。
2，满二叉树，所有的分支结点都存在左右子树，并且叶子都在同一层上。
3，完全二叉树，对于一颗有n个结点的二叉树按层序编号，如果编号i（1<=i<=n）的结点于同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这可树为完全二叉树。

特性（选择考）
1，在二叉树的第i层上最多有 2^(i-1) 个结点 i>=1
2, 深度为 k 的二叉树至多有 2^k -1 个结点 k>=1
3,任意一个二叉树T，如果其叶子结点的个数是n0,度数为2的结点数为 n2， n0 = n2 +1;
4,有n个结点的完全二叉树深度为(logn/log 2) +1;

广度遍历BFS

深度遍历DFS

前序，根左右，先访问根，然访问左，访问右。
中序，左根右，先从根开始（不是先访问根），从左开始访问，在访问根，在访问右结点。
后序，左右根，先从根开始（不是先访问根），先访问左，在访问右。在访问根。

时间复杂度相同（O (n)）

typedef char DATATYPE;

typedef struct _treenode
{
DATATYPE data;
struct _treenode* left;
struct _treenode* right;
}TreeNode;

char data[]="abd##eh###cf#i##g##";
int idx=0;
void CreateTree(TreeNode**root)
{
char c = data[idx++];
if('#'== c)
{
*root = NULL;
}
else
{
*root = malloc(sizeof(TreeNode));
if(NULL == *root)
{
perror("CreateTree malloc error\n");
return ;
}
(*root)->data = c;
CreateTree(&(*root)->left);
CreateTree(&(*root)->right);

}
}
//根左右
void PreOrderTravel(TreeNode* root)
{
if(NULL == root)
{
return;
}
else
{
printf("%c",root->data);
PreOrderTravel(root->left);
PreOrderTravel(root->right); ///递归思想
}
}
//中左右
void InOrderTravel(TreeNode* root)
{
if(NULL == root)
{
return;
}
else
{
InOrderTravel(root->left);
printf("%c",root->data);
InOrderTravel(root->right);
}
}
//左右中
void PostOrderTravel(TreeNode* root)
{
if(NULL == root)
{
return;
}
else
{
PostOrderTravel(root->left);
PostOrderTravel(root->right);
printf("%c",root->data);
}
}

void DestroyTree(TreeNode* root)
{
if(NULL == root)
{
return;
}
else
{
DestroyTree(root->left);
DestroyTree(root->right);
free(root);
}
}
int main(int argc, char **argv)
{

TreeNode* root;
CreateTree(&root);
PreOrderTravel(root);
printf("\n");
InOrderTravel(root);
printf("\n");
PostOrderTravel(root);
printf("\n");