[数组][简单]896.单调数列

---

tags:

• 简单
• 完成
• 数组
  flag: green
  style: summer
  date: ‘2019-6-23’

---

896.单调数列

一、题目

如果数组是单调递增或单调递减的，那么它是单调的。

如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。

当给定的数组 A 是单调数组时返回 true，否则返回 false。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/monotonic-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解答

• 官方题解

• 方法一：两次遍历

思路

如果数组单调递增或单调递减，那么该数组是单调的。由于 a <= b 和 b <= c 暗示着 a <= c，我们只需要检查相邻元素以确定数组是单调递增（或是递减）。我们可以在一次遍历中检查每个属性。

算法

要检查数组 A 是否单调递增，我们将检查每个 i 是否对应有 A[i] <= A[i+1]。对单调检查是类似的。

class Solution {
    public boolean isMonotonic(int[] A) {
        return increasing(A) || decreasing(A);
    }

    public boolean increasing(int[] A) {
        for (int i = 0; i < A.length - 1; ++i)
            if (A[i] > A[i+1]) return false;
        return true;
    }

    public boolean decreasing(int[] A) {
        for (int i = 0; i < A.length - 1; ++i)
            if (A[i] < A[i+1]) return false;
        return true;
    }
}

• 复杂度分析
  • 时间复杂度：O(N)，其中 N是 A 的长度。
  • 空间复杂度：O(1)。

• 方法二：一次遍历

思路

要在一次遍历中执行该检查，我们将会处理由 {-1, 0, 1} 组成的比较流，分别对应 <，==，或 >。例如，对于数组 [1, 2, 2, 3, 0]，我们将会看到数据流 (-1, 0, -1, 1)。

算法

跟踪 store，它的值等于所看到的第一个非零比较值（如果存在）。一旦我们看到与之相反的比较值，那么答案就变成了 False。

否则，每次比较值都必定在集合 {-1, 0}{−1,0} 中或是在 {0, 1}{0,1} 中，此时数组是单调的。

class Solution {
    public boolean isMonotonic(int[] A) {
        int store = 0;
        for (int i = 0; i < A.length - 1; ++i) {
            int c = Integer.compare(A[i], A[i+1]);
            if (c != 0) {
                if (c != store && store != 0)
                    return false;
                store = c;
            }
        }

        return true;
    }
}

• 复杂度分析
  • 时间复杂度：O(N)，其中 N 是 A 的长度。
  • 空间复杂度：O(1)。

作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/dan-diao-shu-lie-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

• 解法：先判断递增递减，再判断是否正确

class Solution {
    public boolean isMonotonic(int[] A) {
        int length = A.length;
        if (length == 1){
            return true;
        }
        int pre = A[0];
        int cur = A[1];
        int index = 1;
        //从头开始依次比较两个元素，直到找到两个不一样的元素；
        while (index < length) {
            pre = A[index - 1];
            cur = A[index];
            if (pre == cur) {
                index++;
            } else {
                break;
            }
        }
        //将这两个元素比较，判断整体数组的递增还是递减
        boolean flg = pre - cur > 0;
        //从index之后的元素逐个做差，验证判断的正确性
        for (; index < length; index++) {
            int i = A[index - 1] - A[index];
            if (flg) {
                if (i < 0) {
                    return false;
                }
            } else {
                if (i > 0) {
                    return false;
                }
            }
        }
        return true;
    }
}

执行用时 :5 ms, 在所有 Java 提交中击败了95.15%的用户

• 个人解答：

//判断数组是否单调
class Solution {
    public boolean isMonotonic(int[] A) {
        //输入合法性判断
        if (A == null) {
            return true;
        }

        int ans1 = 0;
        int ans2 = 0;
        for (int i = 0; i < A.length - 1; i++) {
            //等于0的时候两个都加，不能归于上面两个判断中，都在判断递增数列会出问题；
                if (A[i + 1] - A[i]  < 0 ) {
                    ans1++;
                }else if (A[i + 1] - A[i]  > 0) {
                    ans2++;
                }else if (A[i + 1] - A[i] == 0) {
                   ans1++;
                   ans2++; 
                }                       

             }
        if (ans1 == A.length - 1 || ans2 == A.length - 1) {
            return true;  
        }

      return false;   
    }                
}   

• 复杂度分析：
  • 执行用时 :9 ms, 在所有 Java 提交中击败了27.02%的用户
  • 内存消耗 :59 MB, 在所有 Java 提交中击败了34.19%的用户