二叉树顺序储存创建二叉树c语言

以下是C语言中二叉树顺序存储的创建方法：

#include <stdio.h>
#include <stdlib.h>

#define MAX_TREE_SIZE 100 // 二叉树的最大节点数

typedef char ElemType; // 假设二叉树节点的元素类型为字符型

// 二叉树的顺序存储结构体
typedef struct {
    ElemType data[MAX_TREE_SIZE]; // 存储节点元素的数组
    int length; // 二叉树的节点数
} SqBiTree;

// 创建二叉树的顺序存储结构
void CreateBiTree(SqBiTree *T) {
    printf("请输入二叉树的节点数：");
    scanf("%d", &(T->length));
    printf("请输入二叉树的节点元素（按照层序遍历顺序输入，空节点用#表示）：");
    for (int i = 0; i < T->length; i++) {
        scanf(" %c", &(T->data[i]));
    }
}

int main() {
    SqBiTree T;
    CreateBiTree(&T);
    return 0;
}

相关问题

c语言完全二叉树顺序存储代码

在C语言中，我们可以使用数组来表示完全二叉树，因为完全二叉树的特点是除了最后一层外，每一层都是满的，且最后一个节点都尽可能地靠左。以下是创建一个完全二叉树并按照顺序存储的简单代码示例：

#include <stdio.h>
#define MAX_SIZE 50  // 定义最大节点数

typedef struct TreeNode {
    int data;        // 节点值
    struct TreeNode* left;
    struct TreeNode* right;
} Node;

// 创建一个空的二叉树节点
Node* createNode(int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        printf("Memory allocation failed.\n");
        return NULL;
    }
    newNode->data = value;
    newNode->left = newNode->right = NULL;
    return newNode;
}

// 插入节点到完全二叉树
void insertIntoCompleteTree(Node** root, int value, int size) {
    if (*root == NULL || size == 0) {
        *root = createNode(value);
        return;
    }

    int index = size - 1;
    Node* current = *root;
    while (current != NULL && index >= 0) {
        if (value <= current->data) {
            if (index == 0) {
                if (value < current->data) {  // 如果新值小于当前值，插入左子树
                    current->left = createNode(value);
                    break;
                } else {
                    current->left = NULL;  // 否则将新值设为左孩子
                    break;
                }
            } else {
                current = current->left;
                index--;
            }
        } else {
            if (index == 0) {
                if (value > current->data) {  // 如果新值大于当前值，插入右子树
                    current->right = createNode(value);
                    break;
                } else {
                    current->right = NULL;  // 否则将新值设为右孩子
                    break;
                }
            } else {
                current = current->right;
                index--;
            }
        }
    }
}

// 打印完全二叉树
void printCompleteBST(Node* root) {
    if (root == NULL) {
        return;
    }
    printCompleteBST(root->left);
    printf("%d ", root->data);  // 先打印左子树，然后根节点，最后右子树
    printCompleteBST(root->right);
}

int main() {
    Node* root = NULL;
    int nodes[] = {4, 2, 6, 1, 3, 5, 7};
    int n = sizeof(nodes) / sizeof(nodes[0]);

    for (int i = 0; i < n; i++) {
        insertIntoCompleteTree(&root, nodes[i], n);
    }

    printf("Complete Binary Tree in order:\n");
    printCompleteBST(root);

    return 0;
}

这段代码首先定义了一个二叉树结构体`TreeNode`，接着实现了创建节点、插入节点和打印完整二叉树的函数。在`main`函数中，我们创建了一个完全二叉树，并按照顺序存储了给定的节点。

c语言实现二叉树顺序存储以及基本操作

二叉树的顺序存储是将二叉树的节点按照从上到下、从左到右的顺序依次存放在一个数组中，这样可以方便地进行节点的访问和操作。其中，对于第 i 个节点，它的左子节点和右子节点分别存放在数组中的第 2*i 和 2*i+1 个位置上。

下面是c语言实现二叉树顺序存储以及基本操作的代码：

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100

// 定义二叉树节点结构体
typedef struct TreeNode {
    char data;  // 节点数据
} TreeNode;

// 定义二叉树结构体
typedef struct BinaryTree {
    TreeNode nodes[MAXSIZE];  // 存储节点的数组
    int size;  // 当前节点数
} BinaryTree;

// 初始化二叉树
void init(BinaryTree *tree) {
    tree->size = 0;
}

// 生成新节点
TreeNode* newNode(char data) {
    TreeNode *node = (TreeNode*)malloc(sizeof(TreeNode));
    node->data = data;
    return node;
}

// 在二叉树中插入新节点
void insert(BinaryTree *tree, char data) {
    if (tree->size >= MAXSIZE) {
        printf("Error: the binary tree is full!\n");
        return;
    }
    TreeNode *node = newNode(data);
    tree->nodes[++tree->size] = *node;
}

// 获取指定节点的左子节点
TreeNode* getLeftChild(BinaryTree *tree, int index) {
    int leftChildIndex = 2 * index;
    if (leftChildIndex > tree->size) {
        printf("Error: the node does not have left child!\n");
        return NULL;
    }
    return &tree->nodes[leftChildIndex];
}

// 获取指定节点的右子节点
TreeNode* getRightChild(BinaryTree *tree, int index) {
    int rightChildIndex = 2 * index + 1;
    if (rightChildIndex > tree->size) {
        printf("Error: the node does not have right child!\n");
        return NULL;
    }
    return &tree->nodes[rightChildIndex];
}

// 获取指定节点的父节点
TreeNode* getParent(BinaryTree *tree, int index) {
    if (index <= 1 || index > tree->size) {
        printf("Error: the node does not have parent!\n");
        return NULL;
    }
    return &tree->nodes[index/2];
}

// 打印节点的数据
void printNode(TreeNode *node) {
    printf("%c ", node->data);
}

// 先序遍历二叉树
void preOrderTraversal(BinaryTree *tree, int index) {
    if (index > tree->size) {
        return;
    }
    printNode(&tree->nodes[index]);
    preOrderTraversal(tree, 2*index);
    preOrderTraversal(tree, 2*index+1);
}

// 中序遍历二叉树
void inOrderTraversal(BinaryTree *tree, int index) {
    if (index > tree->size) {
        return;
    }
    inOrderTraversal(tree, 2*index);
    printNode(&tree->nodes[index]);
    inOrderTraversal(tree, 2*index+1);
}

// 后序遍历二叉树
void postOrderTraversal(BinaryTree *tree, int index) {
    if (index > tree->size) {
        return;
    }
    postOrderTraversal(tree, 2*index);
    postOrderTraversal(tree, 2*index+1);
    printNode(&tree->nodes[index]);
}

int main() {
    BinaryTree tree;
    init(&tree);

    insert(&tree, 'A');
    insert(&tree, 'B');
    insert(&tree, 'C');
    insert(&tree, 'D');
    insert(&tree, 'E');

    printf("preOrderTraversal: ");
    preOrderTraversal(&tree, 1);
    printf("\n");

    printf("inOrderTraversal: ");
    inOrderTraversal(&tree, 1);
    printf("\n");

    printf("postOrderTraversal: ");
    postOrderTraversal(&tree, 1);
    printf("\n");

    return 0;
}

在上面的代码中，我们定义了一个 `BinaryTree` 结构体，其中包含了一个 `TreeNode` 类型的数组 `nodes` 来存储节点，还有一个 `size` 变量来记录当前节点数。同时，我们还定义了几个函数来实现二叉树的基本操作，例如插入新节点、获取子节点和父节点、遍历等等。最后，在 `main` 函数中，我们向二叉树中插入了 5 个节点，并分别进行了先序、中序和后序遍历。