目录
一、代码:
先上代码,后说废话
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#include<stdbool.h>
#define QUEUE_SIZE 5
/*
* Binary tree node.
*/
typedef struct BTNode {
char element;
struct BTNode* left;
struct BTNode* right;
}BTNode, * BTNodePtr;
/*
* A queue with a number of pointers.
*/
typedef struct BTNodePtrQueue {
BTNodePtr* nodePtrs;
int front;
int rear;
}BTNodePtrQueue,*QueuePtr;
/*
* Initialize the queue.
*/
QueuePtr initQueue() {
QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(BTNodePtrQueue));//BTNodePtrQueue就已经包括关键字struct了
resultQueuePtr->nodePtrs = (BTNodePtr*)malloc(QUEUE_SIZE * sizeof(BTNodePtr));
resultQueuePtr->front = 0;
resultQueuePtr->rear = 1;
return resultQueuePtr;
}
/*
* Is the queue empty?
*/
bool isQueueEmpty(QueuePtr paraQueuePtr) {
if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear) {
return true;
}
return false;
}
/*
* add a pointer to the queue.
*/
void enqueue(QueuePtr paraQueuePtr, BTNodePtr paraBTNodePtr) {
printf("front = %d, rear = %d\n", paraQueuePtr->front, paraQueuePtr->rear);
if ((paraQueuePtr->rear + 1) % QUEUE_SIZE == paraQueuePtr->front % QUEUE_SIZE) {
printf("Error,trying to enqueue %c. queue full.", paraBTNodePtr->element);
return;
}
paraQueuePtr->nodePtrs[paraQueuePtr->rear] = paraBTNodePtr;
paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
printf("enqueue %c ends.\n", paraBTNodePtr->element);
}
/*
* remove an element from the queue and return.
*/
BTNodePtr dequeue(QueuePtr paraQueuePtr) {
if (isQueueEmpty(paraQueuePtr)) {
printf("Error,empty queue\n");
return NULL;
}
paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
printf("dequeue %c ends.\n", paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}
/*
* construct a BTNode using the given char.
*/
BTNodePtr constructBTNode(char paraChar) {
BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
resultPtr->element = paraChar;
resultPtr->left = NULL;
resultPtr->right = NULL;
return resultPtr;
}//Of constructBTNode
/*
* construct a binary tree using the given string.
*/
BTNodePtr stringToTree(char* paraString) {
int i;
char ch;
//Use a queue to manage the pointers
QueuePtr tempQueuePtr = initQueue();
BTNodePtr resultHeader;
BTNodePtr tempParent, tempLeftChild, tempRightChild;
i = 0;
ch = paraString[i];
resultHeader = constructBTNode(ch);
enqueue(tempQueuePtr, resultHeader);
while (!isQueueEmpty(tempQueuePtr)) {
tempParent = dequeue(tempQueuePtr);
//the left child
i++;
ch = paraString[i];
if (ch == '#') {
tempParent->left = NULL;
}
else {
tempLeftChild = constructBTNode(ch);
enqueue(tempQueuePtr, tempLeftChild);
tempParent->left = tempLeftChild;
}//of if
//the right child
i++;
ch = paraString[i];
if (ch == '#') {
tempParent->right == NULL;
}
else {
tempRightChild = constructBTNode(ch);
enqueue(tempQueuePtr, tempRightChild);
tempParent->right = tempRightChild;
}//of if
}//of while
return resultHeader;
}
/*
* Levelwise.(深度优先)
*/
void levelwise(BTNodePtr paraTreePtr) {
//Use a queue to manage the pointers
char tempString[100];
int i = 0;
QueuePtr tempQueuePtr = initQueue();
BTNodePtr tempNodePtr;
enqueue(tempQueuePtr, paraTreePtr);
while (!isQueueEmpty(tempQueuePtr)) {
tempNodePtr = dequeue(tempQueuePtr);
//for output
tempString[i] = tempNodePtr->element;
i++;
//left
if (tempNodePtr->left != NULL) {
enqueue(tempQueuePtr, tempNodePtr->left);
}//of left
//right
if (tempNodePtr->right != NULL) {
enqueue(tempQueuePtr, tempNodePtr->right);
}//of right
}//of while
tempString[i] = '\0';//结束时给数组一个终止符
printf("Levelwise: %s\n", tempString);
}//of levelwise
/*
* preorder
*/
void preorder(BTNodePtr tempPtr) {
if (tempPtr == NULL) {
return;
}
printf("%c", tempPtr->element);
preorder(tempPtr->left);
preorder(tempPtr->right);
}
/*
* inorder
*/
void inorder(BTNodePtr tempPtr) {
if (tempPtr == NULL) {
return;
}
preorder(tempPtr->left);
printf("%c", tempPtr->element);
preorder(tempPtr->right);
}
/*
* postorder
*/
void postorder(BTNodePtr tempPtr) {
if (tempPtr == NULL) {
return;
}
preorder(tempPtr->left);
preorder(tempPtr->right);
printf("%c", tempPtr->element);
}
/**
* The entrance.
*/
int main() {
BTNodePtr tempHeader;
tempHeader = constructBTNode('c');
printf("There is only one node. Preorder visit: ");
preorder(tempHeader);
printf("\r\n");
char* tempString = "acde#bf######";
tempHeader = stringToTree(tempString);
printf("Preorder: ");
preorder(tempHeader);
printf("\r\n");
printf("Inorder: ");
inorder(tempHeader);
printf("\r\n");
printf("Postorder: ");
postorder(tempHeader);
printf("\r\n");
printf("Levelwise: ");
levelwise(tempHeader);
printf("\r\n");
return 1;
}//Of main
二、运行结果
There is only one node. Preorder visit: c
front = 0, rear = 1
enqueue a ends.
dequeue a ends.
front = 1, rear = 2
enqueue c ends.
front = 1, rear = 3
enqueue d ends.
dequeue c ends.
front = 2, rear = 4
enqueue e ends.
dequeue d ends.
front = 3, rear = 0
enqueue b ends.
front = 3, rear = 1
enqueue f ends.
dequeue e ends.
dequeue b ends.
dequeue f ends.
Preorder: acedbf
Inorder: ceadbf
Postorder: cedbfa
Levelwise: front = 0, rear = 1
enqueue a ends.
dequeue a ends.
front = 1, rear = 2
enqueue c ends.
front = 1, rear = 3
enqueue d ends.
dequeue c ends.
front = 2, rear = 4
enqueue e ends.
dequeue d ends.
front = 3, rear = 0
enqueue b ends.
front = 3, rear = 1
enqueue f ends.
dequeue e ends.
dequeue b ends.
dequeue f ends.
Levelwise: acdebf
D:\visual studio\binary tree\x64\Debug\binary tree.exe (进程 13492)已退出,代码为 1。
要在调试停止时自动关闭控制台,请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
按任意键关闭此窗口. . .
三、老师代码的一些错误
1.我们在使用bool函数时要记得引头文件,否则会报错。
2.在这个结构体中
BTNode已经包含关键字struct了,所以在后续申请空间时,直接用sizeof(BTNode)即可。
四、一些个人理解
二叉树是一种基本的数据结构,它具有递归的性质。它的基本特征是每个节点最多有两个子节点,通常被称为左子节点和右子节点。在这两种情况下,子节点都被称为二叉树的子树。
1. 二叉树的创建
- 递归方式:使用递归方式创建二叉树非常直观,它能够解决大多数问题。例如,使用先序遍历(preorder traversal)来创建二叉树,这份代码用的就是先序遍历创建二叉树的方法。
- 非递归方式:除了递归方式,也可以使用堆栈或队列来创建二叉树。在这种情况下,你通常需要使用一个额外的数据结构来跟踪当前处理的节点,比较麻烦。
2. 二叉树的遍历
- 前序遍历:前序遍历是按照 "根节点 -> 左子树 -> 右子树" 的顺序进行的。
- 中序遍历:中序遍历是按照 "左子树 -> 根节点 -> 右子树" 的顺序进行的。
- 后序遍历:后序遍历是按照 "左子树 -> 右子树 -> 根节点" 的顺序进行的。
- 层次遍历:对于二叉树,层次遍历通常是按照 "从上到下,从左到右" 的顺序进行的。
在实现这些算法时,要注意维护每个节点的状态,例如是否已被访问,以及其子树的状态等。
以上就是创建和遍历二叉树的一些基本方法。对于更复杂的问题,可能需要使用更复杂的算法,例如二叉树的线索化(Threading),以及图论中的一些方法,如深度优先搜索(DFS)或广度优先搜索(BFS)。