二叉树的链式结构和遍历

普通二叉树增删查改没有价值，如果是为了单纯的存储数据，不如用线性表
只是为了更好的控制他的结构，为后续学习更复杂的搜索二叉树打基础

typedef int BTDatatype;
typedef struct BinaryTreeNode
{
    BTDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* left;
}BTNode;
BTNode* BuyNode(BTDatatype x)
{
    BTNode* node=(BTNode*)malloc(sizeof(BTNode));
    if(node==NULL)
    {
        printf("malloc fail");
        exit(-1);
    }
    node->left=node->right=NULL;
    node->data=x;
    return node;
}
//创建树
BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	node1->_left = node2;
	node1->_right = node4;
	node2->_left = node3;
	node4->_left = node5;
	node4->_right = node6;
	return node1;
}

1.树的遍历

以下面的这棵树为例子

1.1.前序遍历(先根遍历)

根 左子树 右子树

1 2 3 NULL NULL NULL 4 5 NULL NULL 6 NULL NULL

void PreOrder(BTNode* root)
{
    if(root==NULL)
    {
        printf("NULL ");
		return ;
    }
    printf("%d ",root->data);
    PreOrder(root->letf);
    PreOrder(root->right);
}

1.2.中序遍历(中根遍历)

左子树 根 右子树

NULL 3 NULL 2 NULL 1 NULL 5 NULL 4 NULL 6 NULL

void InOrder(BTNode* root)
{
    if(root==NULL)
    {
        printf("NULL ");
        return ;
    }
    InOrder(root->letf);
    printf("%d ",root->data);
    InOrder(root->right); 
}

1.3.后序遍历(后根遍历)

左子树 右子树 根

NULL NULL 3 NULL 2 NULL NULL 5 NULL NULL 6 4 1

void PostOrder(BTNode* root)
{
    if(root==NULL)
    {
        printf("NULL ");
        return ;
    }
    PostOrder(root->letf);
    PostOrder(root->right); 
    Postprintf("%d ",root->data);
}

1.4.层序遍历

1 2 4 3 NULL 5 6 NULL NULL NULL NULL

//层序遍历，使用队列实现，把节点依次放入队列中
void BinaryTreeLevelOrder(BTNode* root)
{
    //创建一个队列
	Queue qu;
    //初始化
	QueueInit(&q);
    if(root)
    {
        QueuePush(&q,root);
    }
    while(!QueueEmpty(&q))
    {
        BTNode*front=QueueFront(&q);
        QueuePop(&q);
        printf("%d ",front->data);
        if(root->left)
        {
            QueuePush(&q,front->left);
        }
        if(root->right)
        {
            QueuePush(&q,front->right);
        }
    }
    printf("\n");
    QueueDestory(&q);
}

1.5.二叉树的常见问题

树中的结点个数

//方法一
int BTreeSize(NTNode* root)
{
    //三目操作符
    return root==NULL?0:Prenum(root->left)+Prenum(root->right)+1
}
//方法二
void BTreeSize(BTNode* root,int*count)
{
    if(root==NULL)
        return 0;
    *count++; 
    BTreeSize(root->left,count);
    BTreeSize(root->right,count);
}
int num=0;
int*count=#
BTreeSize(root,count);

二叉树叶子节点个数

int BTreeleafSize(BTNode* root)
{
    //首先不是空
    if(root==NULL)
    {
        return 0;
    }
    //而且左子树是空和右子树是空
	if(root->left==NULL&&root->right==NULL)
    {
        return 1;
    }
    return BTreeleafSize(root->left)+BTreeleafSize(root->right);
}

二叉树第k层节点个数

int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL || k < 0)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

求二叉树的高度

int BTreeDepth(BTNode*root)
{
    if(root==NULL)
        return 0;
    int leftDepth=BTreeDepth(root->left);
    int rightDepth=BTreeDepth(root->right);
    return leftDepth>rightDepth?leftDepth+1:rightDepth+1;
}

二叉树查找值为x的节点

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    if(root==NULL)
        return NULL;
    if(x==root->data)
    {
        return root;
    }
    else
    {   
        //先去找左边的子树
        BTNode*tmp=NULL;
    	tmp=BinaryTreeFind(root->left,x);
        //如果没有在左子树
    	if(tmp==NULL)
        {
           //找右子树
            return BinaryTreeFind(root->right,x);
        }
        //如果有，就返回
        return tmp;
    }
    //如果找不到，返回NULL
    return NULL;
}

找祖先节点

int putRootfx(BTNode* root, BTDataType x)
{
    if(root==NULL)
        return 0;
    if(root->data==x)
    {	
        printf("%d ",root->data);
        return 1;
    }
    if(root)
    {
        if(putRootfx(root->left,x)||putRootfx(root->right,x))
        {
            printf("%d ",root->data);
            return 1;
        }
    }
    return 0;
}

判断二叉树是否是完全二叉树*[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UW8YFvqy-1650035166002)(C:/Users/%E5%88%98%E9%91%AB/AppData/Roaming/Typora/typora-user-images/image-20220415201641493.png)]

int BinaryTreeComplete(BTNode* root)
{
    //创建一个队列
	Queue q;
    QueueInit(&q,root);
    if(root)
        QueuePush(&q,root);
    while(!QueueEmpty(&q))
    {
        BTNode* front = QueueFront(&q);
		QueuePop(&q);
        //如果是空，跳出循环，判断后面的是不是空
		if (front == NULL)
			break;
		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
    }
    while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		// 空后面出到非空，那么说明不是完全二叉树
		if (front)
		{
			QueueDestory(&q);
			return false;
		}
	}

	QueueDestory(&q);
	return true;
}

2.二叉树的练习题

​ 题目一

#define MAX_NUM 1001
int* levelOrder(struct TreeNode* root, int* returnSize){
    *returnSize=0;
    if(root==NULL)
        return NULL;
    int*ans=(int*)malloc(sizeof(int)*MAX_NUM);
    //队列
    struct TreeNode*tree[MAX_NUM];
    memset(tree,0,sizeof(struct TreeNode*));
    int head=0;
    int tail=0;
    tree[tail++]=root;//存入根结点
    while(head<tail)
    {
        //开始遍历
        struct TreeNode*tmp=tree[head++];
        ans[(*returnSize)++] = tmp->val;
        if(tmp->left!=NULL)
        {
            tree[tail++]=tmp->left;
        }
        if(tmp->right!=NULL)
        {
            tree[tail++]=tmp->right;
        }
    }
    return ans;
}

题目二

//用一个队列来输出每一层的节点，在用一个二维数组来记录每一层的节点
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    if(root == NULL){
        (*returnSize)= 0;
        return root;
    }

    struct TreeNode* queue[1010];
    int front = 0, rear = 0, i = 0, j = 0, count = 0, k = 1;
    struct TreeNode* p = NULL;
    int** array = (int**)malloc(sizeof(int*)*1010);//申请一个指针数组(二维数组)
    *returnColumnSizes = (int*)malloc(sizeof(int)*1010);//申请一个int型数组
    queue[rear++] = root;//入队列
    array[i] = (int*)malloc(sizeof(int)*k);//用指针数组的第一个指针指向树第一层的数组
    (*returnColumnSizes)[i] = k;//第一层数组的长度
    while(front < rear){
        p = queue[front++];//出队列并用指针p指向该节点
        array[i][j++] = p->val;//二维数组第i层第j个元素记录该节点的值
        if(p->left){//查看左孩子，有则入队
            queue[rear++] = p->left;
            count++;//记录下一层节点数
        }
        if(p->right){//查看右孩子，有则入队
            queue[rear++] = p->right;
            count++;
        }
        k--;//改层已经记录一个节点值，若k==0,则说明该层的节点已经记录完，用k=count,来更新下一层节点数
        if(k == 0){
            k = count;
            count = 0;
            j = 0;//从当前i层第一个节点开始，所以对应当前二维数组第i行第一个元素
            i++;//到下一层，也到下一行
            array[i] = (int*)malloc(sizeof(int)*k);//重新分配下一层对应节点的数组大小
            (*returnColumnSizes)[i] = k;//返回下一层节点个数
        }
    }
        *returnSize = i;
    return array;
}
///
///

 #define N 1010
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    if(root==NULL)
    {
        *returnSize=0;
        return NULL;
    }   
    struct TreeNode* queue[N];
    //开二维数组存放一维数组的指针
    int**array=(int**)malloc(sizeof(int*)*N);
    *returnColumnSizes=(int*)malloc(sizeof(int*)*N);
    //k用来记录存放了多少个数据
    int head=0,tail=0,i=0,j=0,k=1,count=0;
    queue[tail++]=root;
    //第一层的结点数为1个
    (*returnColumnSizes)[i]=k;
    //开辟存放数据数组
    array[i]=(int*)malloc(sizeof(int)*k);
    while(head<tail)
    {
        struct TreeNode*tmp=queue[head++];
        array[i][j++]=tmp->val;
        if(tmp->left)
        {
            queue[tail++]=tmp->left;
            //记录下一层需要遍历的个数
            count++;
        }
        if(tmp->right)
        {
            queue[tail++]=tmp->right;
            //记录下一场需要遍历的个数
            count++;
        }
        //如果该层的结点全部被遍历一遍，就进行下一步
        k--;
        if(k==0)
        {
            //下一层需要遍历的结点数；
            k=count;
            j=0;
            count=0;
            i++;
            (*returnColumnSizes)[i]=k;
            array[i]=(int*)malloc(sizeof(int)*k);
        }
    }
    //返回多少层
    *returnSize=i;
    return array;
}

题目三

 //反转数组 
#define N 1010
void reverse(int**arr,int k,int len)
{
    int left=0;
    int right=len-1;
    while(left<right)
    {
        int tmp=arr[k][left];
        arr[k][left]=arr[k][right];
        arr[k][right]=tmp;
        left++;
        right--;
    }
}  
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    if(root==NULL)
    {
        *returnSize=0;
        return NULL;
    }
   //开辟存放一级指针的数组
    int**array=(int**)malloc(sizeof(int*)*N);
    //开辟存放数组长度的数组
    *returnColumnSizes=(int*)malloc(sizeof(int)*N);
    //创建一个队列
    struct TreeNode* queue[N];
    memset(queue,0,sizeof(struct TreeNode*));
    int head=0,tail=0,i=0,j=0,count=0,k=1;
    (*returnColumnSizes)[i]=k;
    queue[tail++]=root;
    array[i]=(int*)malloc(sizeof(int)*k);
    while(head<tail)
    {
        struct TreeNode*tmp=queue[head++];
        array[i][j++]=tmp->val;
        if(tmp->left)
        {
            queue[tail++]=tmp->left;
            count++;
        }
        if(tmp->right)
        {
            queue[tail++]=tmp->right;
            count++;
        }
        //记录剩下还没有打印的结点
        k--;
        if(k==0)
        {
            j=0;
            i++;
            k=count;
            count=0;
            array[i]=(int*)malloc(sizeof(int)*k);
            (*returnColumnSizes)[i]=k;
            if(i%2==0)
            {
                reverse(array,i-1,(*returnColumnSizes)[i-1]);
            }
        }

    }
    *returnSize=i;
    return array;
}