c语言建立二叉树的算法代码
时间: 2023-12-04 20:39:35 浏览: 53
以下是C语言建立二叉树的算法代码:
```c
#include <stdio.h>
#include <stdlib.h>
typedef char tree_datatype;
typedef struct tree_t {
tree_datatype data; // 数据域
struct tree_t *lchild; // 指向左子树的结构体指针
struct tree_t *rchild; // 指向右子树的结构体指针
} bitree_t;
// 创建二叉树
bitree_t *create_bitree() {
bitree_t *root = NULL;
tree_datatype ch;
scanf("%c", &ch);
if (ch == '#') {
root = NULL;
} else {
root = (bitree_t *) malloc(sizeof(bitree_t));
root->data = ch;
root->lchild = create_bitree();
root->rchild = create_bitree();
}
return root;
}
```
相关问题
C语言建立二叉树,并实现二叉树的遍历,先序遍历采用递归算法实现,层次遍历用非递归算法来实现。
以下是 C 语言实现建立二叉树和二叉树遍历的代码示例:
```c
#include <stdio.h>
#include <stdlib.h>
// 定义二叉树节点结构体
typedef struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
} TreeNode;
// 建立二叉树
TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize) {
if (preorderSize == 0) {
return NULL;
}
// 前序遍历的第一个节点是根节点
int root_val = preorder[0];
TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
root->val = root_val;
// 在中序遍历中找到根节点的位置
int idx = 0;
while (inorder[idx] != root_val) {
idx++;
}
// 递归构建左右子树
root->left = buildTree(preorder+1, idx, inorder, idx);
root->right = buildTree(preorder+idx+1, preorderSize-idx-1, inorder+idx+1, inorderSize-idx-1);
return root;
}
// 先序遍历(递归实现)
void preorderTraversal(TreeNode* root) {
if (!root) {
return;
}
printf("%d ", root->val);
preorderTraversal(root->left);
preorderTraversal(root->right);
}
// 层次遍历(非递归实现)
void levelOrder(TreeNode* root) {
if (!root) {
return;
}
TreeNode* queue[1000];
int front = 0, rear = 0;
queue[rear++] = root;
while (front < rear) {
TreeNode* node = queue[front++];
printf("%d ", node->val);
if (node->left) {
queue[rear++] = node->left;
}
if (node->right) {
queue[rear++] = node->right;
}
}
}
// 测试代码
int main() {
int preorder[] = {1, 2, 4, 5, 3, 6, 7};
int inorder[] = {4, 2, 5, 1, 6, 3, 7};
int n = sizeof(preorder) / sizeof(preorder[0]);
TreeNode* root = buildTree(preorder, n, inorder, n);
preorderTraversal(root);
printf("\n");
levelOrder(root);
return 0;
}
```
以上代码中,`buildTree` 函数通过递归方式构建二叉树,`preorderTraversal` 函数通过递归方式实现先序遍历,`levelOrder` 函数通过队列实现二叉树的层次遍历。注意在 C 语言中,需要手动分配和释放内存空间。
c++ 在内存中建立二叉树的代码
以下是C语言代码示例,可以在内存中建立二叉树:
```c
#include <stdio.h>
#include <stdlib.h>
// 定义二叉树结构体
typedef struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
} TreeNode;
// 创建新节点
TreeNode* createNode(int val) {
TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
newNode->val = val;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
// 在二叉树中插入节点
void insert(TreeNode** root, int val) {
if (*root == NULL) {
*root = createNode(val);
return;
}
if (val < (*root)->val) {
insert(&(*root)->left, val);
} else {
insert(&(*root)->right, val);
}
}
// 前序遍历二叉树
void preOrder(TreeNode* root) {
if (root != NULL) {
printf("%d ", root->val);
preOrder(root->left);
preOrder(root->right);
}
}
int main() {
TreeNode* root = NULL;
insert(&root, 5);
insert(&root, 3);
insert(&root, 7);
insert(&root, 1);
insert(&root, 4);
insert(&root, 6);
insert(&root, 8);
printf("前序遍历结果:");
preOrder(root);
return 0;
}
```
在上述示例中,首先我们定义了二叉树的结构体 `TreeNode`,包括节点的值 `val`,以及左右子树的指针 `left` 和 `right`。
接着,我们定义了一个 `createNode` 函数,用于创建新节点,该函数接收一个整数参数 `val`,并返回一个新节点的指针。
然后,我们定义了一个 `insert` 函数,用于在二叉树中插入节点。该函数接收二叉树的根节点指针 `root` 和要插入的节点的值 `val`,并通过递归算法,在正确的位置插入新节点。
最后,我们定义了一个 `preOrder` 函数,用于前序遍历二叉树。
在 `main` 函数中,我们首先将根节点指针 `root` 初始化为 `NULL`,然后插入一些节点,并使用前序遍历函数输出二叉树的节点值。