LeetCode刷题|896单调数列

前言

从今天开始，我打算在这里记录下每一次的刷题。边做边学边总结，到目前为止我都还是只能解决简单难度的题目，希望我能坚持下来，能看到我的提高。

题目

LeetCode每日一题：单调数列

我的解法

拿到题目，我的第一反应是先用前两个数判断整个数列可能的升降趋势。但是仔细一想这种方法是行不通的，因为前面两个数可能是相等的，而且可能还会出现前面n个数都是相等的，所以这种想法pass掉。
于是我就想到，既然前两个数判断不了整个数列可能的趋势，那么第一个数和最后一个数用来比较不就可以判断整个数列的趋势了吗。因此，将数列分三种情况：
A[0]==A[n-1]:此时只需要判断每一个数都和第一个数相等即可。
A[0]<A[n-1]:此时只需要判断后面每一个数都大于或者等于前面的数。
A[0]>A[n-1]:与上面一种情况相反。

class Solution:
    def isMonotonic(self, A: List[int]) -> bool:
        n = len(A)
        if n==0:
            return True
        t = A[0]
        if A[0] == A[n-1]:
            for i in A:
                if i != A[0]:return False
            return True
        elif A[0]>A[n-1]:
            for i in range(1,len(A)):
                if A[i]>t:
                    return False
                else:
                    t = A[i]
            return True
        else:
            for i in range(1,len(A)):
                if A[i]<t:
                    return False
                else:
                    t = A[i]
            return True

官方解法一

解法一的主要思路是遍历数列两次，分别判断是增还是减，返回布尔值。然后将两次返回的结果进行或运算，如果两次都返回FALSE，说明既不是增也不是减。

class Solution {
    public boolean isMonotonic(int[] A) {
        return isSorted(A, true) || isSorted(A, false);
    }

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

官方解法二

其实这一思路与解法一思路类似。这里是只用了一次遍历，若一次遍历即出现前一个大于后一个的情况，又出现前一个小于后一个的情况，那么说明不是单调数列。

class Solution {
    public boolean isMonotonic(int[] A) {
        boolean inc = true, dec = true;
        int n = A.length;
        for (int i = 0; i < n - 1; ++i) {
            if (A[i] > A[i + 1]) {
                inc = false;
            }
            if (A[i] < A[i + 1]) {
                dec = false;
            }
        }
        return inc || dec;
    }
}

这里主要要学习的一点是布尔值变量的应用。