4.5周题解及笔记

Leetcode

1.买卖股票的最佳时机II

题目描述

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]
输出: 7

解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:

输入: [1,2,3,4,5]
输出: 4

解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: [7,6,4,3,1]
输出: 0

解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

第一次代码

int maxProfit(int* prices, int pricesSize){
    if(pricesSize == 0)
        return 0;
    int point = 0;
    int profit = 0;
    while (point != pricesSize - 1){
        int a = point;
        int b = point + 1;
        int tem = 0;
        while (prices[b] > prices[a]){
            if(b == pricesSize - 1){
                tem = 0;
                break;
            }
            a++;
            b++;
            tem = 1;
        }
        if(tem == 1)
            b--;
        if(prices[b] - prices[point] >= 0)
            profit += (prices[b] - prices[point]);
        point = b;
    }
    return profit;
}

维护一个变量从头至尾不断寻找高低落差（用两个块变量和循环结构实现），并将其相加。
缺点是不够简洁，运算时间较长。

第二次代码（贪心）

int maxProfit(int* prices, int pricesSize){
    if(pricesSize == 0)
        return 0;
    int point = 0;
    int profit = 0;
    while (point != pricesSize - 1){
        int b = point + 1;
        if (prices[b] > prices[point])
            profit += (prices[b] - prices[point]);
        point++;
    }
    return profit;
}

贪心算法，只要第二天比前一天价格高就买入卖出，在整个时间段重复。
代码十分简洁，但是时间上并不占优势。

2.二叉树的最大深度

题目描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]
返回它的最大深度 3 。

我的代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int maxDepth(struct TreeNode* root){
    if (root == 0) 
        return 0;
    int heightLeft = 1, heightRight = 1;
    if (root->left)
        heightLeft += maxDepth(root->left);
    if (root->right)
        heightRight += maxDepth(root->right);
    return heightLeft>heightRight?heightLeft:heightRight;
}

递归算法，返回深度较大的值即可。