icoding 复习5
1. 先序遍历
已知二叉树按照二叉链表方式存储，利用栈的基本操作写出先序遍历非递归形式的算法：
void pre_order(BiTree root);
二叉树的相关定义如下：
typedef int DataType;
typedef struct Node{
DataType data;
struct Node* left;
struct Node* right;
}BiTNode, *BiTree;
遍历所使用栈的相关操作如下：
#define Stack_Size 50
typedef BiTNode* ElemType;
typedef struct{
ElemType elem[Stack_Size];
//BiTNode* elem[Stack_Size]
int top;
}Stack;
void init_stack(Stack *S); // 初始化栈
bool push(Stack* S, ElemType x); //x 入栈
bool pop(Stack* S, ElemType *px); //出栈，元素保存到px所指的单元，函数返回true,栈为空时返回 false
bool top(Stack* S, ElemType *px); //获取栈顶元素，将其保存到px所指的单元，函数返回true，栈满时返回 false
bool is_empty(Stack* S); // 栈为空时返回 true，否则返回 false
在遍历过程中，pre_order函数需要调用 visit_node 函数来实现对结点的访问，该函数声明如下：
void visit_node(BiTNode *node);
#include
#include
#include "bitree.h" //请不要删除，否则检查不通过
大概率考原题和改编!!!!!!
void pre_order(BiTree root){
if(!root) return;
Stack *S;
BiTNode *p;
init_stack(S);
push(S, root->data);
while(!is_empty(S)){
pop(S, &p);
visit_node(p);
if(p->left)
push(S, p->left);
if(p->right){
push(S, p->right);
}
}
}
//解法2, 声明为Stack S;
void pre_order(BiTree root)
{
Stack S;
BiTNode *p, *q;
// S.top = -1; 初始化应该会赋值
p = root;
init_stack(&S);
if (p == NULL)
return;
do {
if (p) {
visit_node(p);//先序遍历的核心,先访问根节点
push(&S, p);
p = p->left;
} else {
pop(&S, &p);
p = p->right;
}
} while (p || !(is_empty(&S)));
}
//中序遍历
void InOrder(BiTNode *root){
Stack *S; BiTNode *p;
init_stack(S);
if(!root ) return;
while(p || !is_empty(S)){
while(p){
push(S, p);
p = p->left;
}
if(!is_empty(S)){
pop(S, &p);
visit_node(p);
p = p->right;
}
}
}
//后序遍历非递归 难
void PostOrder(BiTNode *root){
Stack *S; BiTNode *p, *r; bool flag;
init_stack(S);
p = root;
do{
while(p){
push(S, p);
p = p->left;
}
r = NULL;
flag = true;
while(!is_empty(S) && flag){
top(S, &p);
if(p->right == r){
visit_node(p);
pop(S, &p);
r = p;
}
else{
p = p->right;
flag = false;
}
}
}while(!is_empty(S));
}
2. 路径
假设二叉树采用二叉链表方式存储， root指向根结点，node 指向二叉树中的一个结点，
编写函数 path，计算root到 node 之间的路径，（该路径包括root结点和 node 结点）。path 函数声明如下：
bool path(BiTNode* root, BiTNode* node, Stack* s);
其中，root指向二叉树的根结点，node指向二叉树中的另一结点，s 为已经初始化好的栈，
该栈用来保存函数所计算的路径，如正确找出路径，则函数返回 true，此时root在栈底，node在栈顶；
#include "bitree.h" //请不要删除，否则检查不通过
#include
#include
bool path(BiTNode* root, BiTNode* node, Stack* s){
BiTNode *p, *q;
if(!root || !node) return false;
p = root;
if(p == node){
push(s, p);
return true;
}
while(p || !is_empty(s)){
while(p){//先压入再判断
push(s, p);
if(p == node)
return true;
p = p->left;
}
top(s, &p);
if(p->right == q || p->right == NULL){
q = p;
top(s, &p);
p = NULL;
}
else
p = p->right;
}
return true;
}
3. 共同祖先
假设二叉树采用二叉链表方式存储， root指向根结点，p所指结点和q所指结点为二叉树中的两个结点，
编写一个计算它们的最近的共同祖先，函数定义如下：
BiTNode * nearest_ancestor(BiTree root, BiTNode *p, BiTNode *q);
其中 root 指向二叉树的根结点，p 和 q 分别指向二叉树中的两个结点。
提示：在完成本题时，可利用 path 函数获取p和q两个结点到根结点之间的路径，
之后再计算两条公共路径得出最近的共同祖先。path函数及栈相关定义如下：
#include
#include
#include "bitree.h" //请不要删除，否则检查不通过
BiTNode * nearest_ancestor(BiTree root, BiTNode *p, BiTNode *q){
if(!root || !p || !q) return NULL;
Stack *s1, *s2;
init_stack(s1); init_stack(s2);
path(root, p, s1);
path(root, q, s2);
for(int i = 0; s1->elem[i] == s2->elem[i]; i++)
;
return s1->elem[i-1];
}
4. 树转二叉树
使用队列，编写transfrom函数，将普通树转换成对应的二叉树。二叉树的相关定义如下：
typedef int DataType;
typedef struct Node{
DataType data;
struct Node* left;
struct Node* right;
}BiTNode, *BiTree;
普通树节点 的定义如下：
#define MAX_CHILDREN_NUM 5
struct _CSNode
{
DataType data;
struct _CSNode *children[MAX_CHILDREN_NUM];
};
typedef struct _CSNode CSNode;
其中，子树的根节点的指针存放在children数组的前k个元素中，即如果children[i]的值为NULL，
而children[i-1]不为NULL，则表明该结点只有i棵子树，子树根结点分别保存在children[0]至children[i-1]中。
队列相关定义及操作如下：
struct __Queue
{
int i, j; //指向数组内元素的游标
void **array;//这个就是提示!!!!!!!!!!!!!!!!!!!!!!!!!!!
};
typedef struct __Queue Queue;
Queue* create_queue(); //创建队列
bool is_empty_queue(Queue *tree); //队为空返回true,不为空时返回false
void* del_queue(Queue *tree); //结点指针出队
void add_queue(Queue *tree, void *node); //结点指针入队
void free_queue(Queue *tree); //释放队列
transform函数定义如下：
BiTNode* transform(CSNode *root);
其中 root 为普通树的根结点，函数返回该树对应二叉树的根结点。
#include
#include
#include "bitree.h" //请不要删除，否则检查不通过
BiTNode* transform(CSNode *root){
if(!root) return NULL;
Queue *que, *bque;
BiTNode *p;
//二叉树根结点创立
//小心点, 记得分配空间
//为什么想到建立二叉树结点?
//普通树结点和二叉树结点无法强制类型转换
p = (BiTNode *)malloc(sizeof(struct Node));
p->data = root->data;
p->left = p->right = NULL;
que = create_queue();
bque = create_queue();
//建立双队目的在于建立有序二叉结点序列
add_queue(que, root);
add_queue(bque, p);
//注意这个while怎么处理好孩子与孙子关系的, 没用递归!!!
while(!is_empty_queue(que)){
BiTree bq;//创建二叉树队列头结点(根结点)
bq = del_queue(bque);
CSNode *q;
q = del_queue(que);
//第一次执行该操作就相当于建立了二叉树的根
int i = 0;
BiTNode *former = NULL;
for(i = 0; i < MAX_CHILDREN_NUM; i++){
if(q->children[i]){//判存在
BiTNode *bnode = (BiTNode *)malloc(sizeof(struct Node));
bnode->data = q->children[i]->data;
bnode->left = bnode->right = NULL;
//放置结点位置
if(i == 0){
bq->left = bnode;
}
else{//兄弟变为孩子了可怜
former->right = bnode;
}
former= bnode;
add_queue(bque, bnode);
add_queue(que, q->children[i]);
}
}
}
free(que->array);
free(que);
free(bque->array);
free(bque);
return p;
}
与any())
)
