【每日刷题】Day63

🥕个人主页：开敲🍉

🔥所属专栏：每日刷题🍍

🌼文章目录🌼

1. 414. 第三大的数 - 力扣（LeetCode）

2. 2265. 统计值等于子树平均值的节点数 - 力扣（LeetCode）

3. 1302. 层数最深叶子节点的和 - 力扣（LeetCode）

1. 414. 第三大的数 - 力扣（LeetCode）

//思路：排序+遍历。将数组排为升序后进行双指针遍历，使用一个flag遍历判断是否遍历到第三大数或是否有第三大数，两个指针指向元素不相同flag++，当flag==3时说明遍历到了第三大数，break；当走出循环后flag!=3，说明没有第三大数，返回最大的数

//插入排序

void InsertSort(int* arr,int size)

{

    for (int i = 0; i < size-1; i++)

    {

        int end = i + 1;

        int tmp = arr[end];

        while (end - 1 >= 0)

        {

            if (tmp > arr[end - 1])

            {

                arr[end] = arr[end - 1];

            }

            else

            {

                break;

            }

            end--;

        }

        arr[end] = tmp;

    }

}

 

//希尔排序

void ShellSort(int* arr, int size)

{

    int gap = size;

    while (gap > 1)

    {

        gap = gap / 3 + 1;

        for (int i = 0; i < size - gap; i++)

        {

            int end = i + gap;

            int tmp = arr[end];

            while (end - gap >= 0)

            {

                if (tmp > arr[end - gap])

                {

                    arr[end] = arr[end - gap];

                }

                else

                {

                    break;

                }

                end -= gap;

            }

            arr[end] = tmp;

        }

    }

    InsertSort(arr, size);

}

int thirdMax(int* nums, int numsSize)

{

    ShellSort(nums,numsSize);//排序

    int flag = 1;

    double ans = 0;

    for(int i = 0;i<numsSize-1;i++)

    {

        if(nums[i]!=nums[i+1])//遇到不相同的数

            flag++;

        if(flag==3)

        {

            ans = nums[i+1];

            break;

        }

    }

    if(flag!=3)

        ans = nums[0];

    return (int)ans;

}

2. 2265. 统计值等于子树平均值的节点数 - 力扣（LeetCode）

//思路：深度优先遍历。把每一个根节点看为一棵树，求出该根节点左右子树节点个数以及左右子树结点值的和，计算平均值，判断是否为当前结点的值。

//求树的节点个数

int BinaryTreeTreeSize(struct TreeNode* root)

{

    if (root == NULL)

        return 0;

    return 1 + BinaryTreeTreeSize(root->left) + BinaryTreeTreeSize(root->right);

}

int _averageOfSubtree(struct TreeNode* root,int* ans)

{

    if(!root)

        return 0;

    int left = _averageOfSubtree(root->left,ans);//左子树结点值的和

    int right = _averageOfSubtree(root->right,ans);//右子树结点值的和

    int num = BinaryTreeTreeSize(root);//求出该树节点个数

    if((left+right+root->val)/num==root->val)//判断平均值是否＝root->val

        (*ans)++;

    return left+right+root->val;//返回当前子树结点值的和

}

 

int averageOfSubtree(struct TreeNode* root)

{

    int ans = 0;

    _averageOfSubtree(root,&ans);

    return ans;

}

3. 1302. 层数最深叶子节点的和 - 力扣（LeetCode）

//思路：深度优先遍历。求出二叉树最大深度，遍历二叉树，当遇到叶子结点时判断其是否是最深的叶子节点。是，则让结果+=root->val；不是，则直接返回，如果遍历到空，也返回。

//二叉树最大深度

int BinaryTreeHigh(struct TreeNode* root)

{

    if(!root)

        return 0;

    int left = BinaryTreeHigh(root->left);

    int right = BinaryTreeHigh(root->right);

    return 1+(left>right?left:right);

}

//判断是否为叶子节点

bool IsLeafNode(struct TreeNode* root)

{

    return !root->left&&!root->right;

}

void _deepestLeavesSum(struct TreeNode* root,int high,int* ans)

{

    if(!root||(IsLeafNode(root)&&high!=1))//如果遍历到NULL或不是最深的叶子结点，直接返回

        return;

    if(IsLeafNode(root)&&high==1)//是最深的叶子节点，结果+=root->val

        (*ans)+=root->val;

    _deepestLeavesSum(root->left,high-1,ans);

    _deepestLeavesSum(root->right,high-1,ans);

}

int deepestLeavesSum(struct TreeNode* root)

{

    int high = BinaryTreeHigh(root);

    int ans = 0;

    _deepestLeavesSum(root,high,&ans);

    return ans;

}