剑指offer——day6【二叉树的回溯算法】

最新推荐文章于 2024-10-16 00:00:43 发布

影中人lx

最新推荐文章于 2024-10-16 00:00:43 发布

阅读量1.5k

点赞数

分类专栏：数据结构笔记文章标签：算法数据结构 leetcode

本文链接：https://blog.csdn.net/qq_53893431/article/details/124090918

版权

数据结构笔记专栏收录该内容

18 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何利用队列实现二叉树的层次遍历，分别给出了三种不同情况的解决方案：常规层次遍历、按层次返回二维数组以及在返回的二维数组中交替反转每一层。这些算法都以广度优先搜索为基础，并通过动态分配内存来存储中间结果。

摘要由CSDN通过智能技术生成

在这里插入图片描述
题目1

题目链接

//借助队列实现BFS
#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;
}

题目二
在这里插入图片描述
题目链接

#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;
}