二叉树刷题专练（三）

---

前言

---

继承前面的写作思路，此篇文章继续二叉树的oj题

一、二叉树的最小深度

1.题目介绍

题目在力扣 二叉树的最小深度

2.思路

最小深度是从根节点到最近叶子节点的最短路径上的节点数量，叶子节点是没有子节点的节点，那么叶子节点的是不是只可能出现在一个字数遍历完才会出现，所以这题我们就可以转化成一个遍历到叶子的最短路径，那么们就会出现下面这种情况，这种情况数出5，即返回右子树的最小深度

所以我们可以总结成以下几点

1.如果root为空，则返回0；
2.如果左节点为空，那么直接返回右节点的最小深度+1即可
3.如果左节点为空，那么直接返回右节点的最小深度+1即可
4.如果两者都不为空，我们就返回左节点和右节点中小的那个节点+1

3.代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int minDepth(struct TreeNode* root){
    
    
    if(root==NULL)
    return 0;
    if(root->left==NULL)
    return minDepth(root->right)+1;
    else if(root->right==NULL)
    return minDepth(root->left)+1;
    int left=minDepth(root->left);
    int right=minDepth(root->right);
    if(left<right)
    {
    
    
        return left+1;
    }
    else
    {
    
    
        return right+1;
    }

}

二、完全二叉树的节点个数

1.题目介绍

题目在力扣完全二叉树的节点个数

2.思路

本题考的就是层序遍历，将这课二叉树层序遍历一遍就行了，层序就是建立一个队列，利用队列的先进先出的性质，每pop一个节点，就依次带入其非NULL节点的左节点和右节点，如下图

你可以用数组模拟队列，也可以直接拿队列的代码来弄

3.代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
typedef struct TreeNode* QDatatype;
typedef struct QueueNode
{
    
    
	struct QueueNode* next;
	QDatatype Data;
}QNode;

typedef struct Queue
{
    
    
	QNode* head;
	QNode* tail;
	int size;
}Queue;

void QueueInit(Queue* pq)
{
    
    
    assert(pq);
    pq->head = pq->tail = NULL;
    pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
    
    
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
    
    
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    pq->head = pq->tail = NULL;
    pq->size = 0;

}

void QueuePush(Queue* pq, QDatatype x)
{
    
    
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    assert(newnode);
    newnode->Data = x;
    newnode->next=NULL;
    if (pq->size == 0)
    {
    
    
        pq->head =pq->tail= newnode;
    }
    else
    {
    
    
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
    pq->size++;

}

void QueuePop(Queue* pq)
{
    
    
    assert(pq);
    assert(pq->size);
    if (pq->head->next==NULL)
    {
    
    
        free(pq->head);
        pq->head =pq->tail= NULL;
    }
    else
    {
    
    
        QNode* next = pq->head->next;
        free(pq->head);
        pq->head = next;
    }
    pq->size--;
}

int QueueSize(Queue* pq)
{
    
    
    assert(pq);
    return pq->size;
}

bool QueueEmpty(Queue* pq)
{
    
    
    assert(pq);
    return pq->size==0;
}

QDatatype QueueFront(Queue* pq)
{
    
    
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->head->Data;
}

QDatatype QueueBack(Queue* pq)
{
    
    
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->tail->Data;
}




int countNodes(struct TreeNode* root){
    
    
    if(root==NULL)
    return 0;
	Queue tree;
	Queue* pt = &tree;
	QueueInit(pt);
	QueuePush(pt,root);
    int count=0;
	while (!QueueEmpty(pt))
	{
    
    
		struct TreeNode* front = QueueFront(pt);
        count ++;
		QueuePop(pt);
		if (front->left)
		{
    
    
			QueuePush(pt, front->left);
		}
		if (front->right)
		{
    
    
			QueuePush(pt, front->right);
		}
	}
	QueueDestroy(pt);
    return count;
}