初级算法探索——数组篇（二）

问题：买卖股票的最佳时机 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。

js解决办法：

testCallFunc2: function() {
    var niushi = [7,1,5,3,6,4];
    var totalValue = this.findMostValuableOrderFromNiushi(niushi);
    cc.log("total:" + totalValue);
},

// 思路：找出所有波谷和波峰，等于左右两边为平原，大于等于左右两边为波峰，小于等于左右两边为波谷
// 找到第一个波谷和向右临近的第一个波峰取差值形成一笔交易，以此类推
// 交易次数最少，且同一天不能同时卖出和买入，适用于有交易手续费的时候
findMostValuableOrderFromNiushi: function(niushi) {
    if (niushi.length == 1) {
        return 0;
    }
    var boTable = [];
    for (var i = 0; i < niushi.length; i++) {
        if (i == 0) {
            if (niushi[0] != niushi[1]) {
                boTable.push(niushi[0]);
            }
        } else if (i == niushi.length-1) {
            if (niushi[niushi.length-1] != niushi[niushi.length-2]) {
                boTable.push(niushi[niushi.length-1]);
            }
        } else {
            var add1 = niushi[i] - niushi[i-1];
            var add2 = niushi[i] - niushi[i+1];
            if (add1 == 0 && add2 == 0) {

            } else if ((add1 <= 0 && add2 <= 0) || (add1 >= 0 && add2 >= 0)) {
                boTable.push(niushi[i]);
            }
        }
    }

    var totalValue = 0;
    for (var i = 0; i < boTable.length-1; i++) {
        if (boTable[i+1] > boTable[i]) {
            totalValue += (boTable[i+1] - boTable[i]);
        }
    }
    return totalValue;
},

// 思路：只要第二天比第一天高就买入，同一天可以卖出再买入，短炒，交易次数高，适用于没有手续费的时候
findMostValuableOrderFromNiushi2: function(niushi) {
    var totalValue = 0;
    for (var i = 0; i < niushi.length-1; i++) {
        if (niushi[i+1] > niushi[i]) {
            totalValue += (niushi[i+1] - niushi[i]);
        }
    }
    return totalValue;
},

运行结果截图：

执行耗时：