539. 最小时间差

539. 最小时间差
     给定一个 24 小时制（小时:分钟 “HH:MM”）的时间列表，找出列表中任意两个时间的最小时间差并以分钟数表示。

示例 1：

输入：timePoints = ["23:59","00:00"]
输出：1

示例 2：

输入：timePoints = ["00:00","23:59","00:00"]
输出：0

提示：

• 2 <= timePoints <= 2 * 104
• timePoints[i] 格式为 “HH:MM”

解题思路：
排序模拟
将所有的时间进行字典排序，然后对应的求出所有时间对应的分钟数然后进行计算时间差即可，其中24小时代表1440分钟，说明只有1440个组合，当字符串数组长度大于1440，可直接返回0，因为必有相同，不要忘记首时间与末尾时间的时间差计算！

代码：
c++

class Solution {
public:
    int findMinDifference(vector<string>& timePoints) {
        int size = timePoints.size();
        if(size > 1440)
            return 0;
        sort(timePoints.begin(),timePoints.end());
        int m = INT_MAX;
        int a = (timePoints[0][0] - '0') * 10 * 60 + (timePoints[0][1] - '0') * 60 + (timePoints[0][3] - '0') * 10 + (timePoints[0][4] - '0');
        int temp =0;
        int temp1= a;
        for(int i =1; i < size;i++)
        {
            temp = (timePoints[i][0] - '0') * 10 * 60 + (timePoints[i][1] - '0') * 60 + (timePoints[i][3] - '0') * 10 + (timePoints[i][4] - '0');
            m = min(m, temp - temp1);
            temp1 = temp;
            if(m == 0)
                return 0;
        }
        m = min (m, a + 1440 - temp);
        return m;

    }
};

py3

class Solution:
    def findMinDifference(self, timePoints: List[str]) -> int:
            if len(timePoints) > 1440:
                return 0
            timePoints.sort()
            m = sys.maxsize
            a = (ord(timePoints[0][0]) - ord('0')) * 10 * 60 + (ord(timePoints[0][1]) - ord('0')) * 60 + (ord(timePoints[0][3]) - ord('0')) * 10 + (ord(timePoints[0][4]) - ord('0'))
            temp1 = a
            for i in range(1, len(timePoints)):
                temp = (ord(timePoints[i][0]) - ord('0')) * 10 * 60 + (ord(timePoints[i][1]) - ord('0')) * 60 + (ord(timePoints[i][3]) - ord('0')) * 10 + (ord(timePoints[i][4]) - ord('0'))
                m = min(m, temp - temp1)
                temp1 = temp
                if m == 0:
                    return 0
            m = min(m, a + 1440 - temp)
            return m

总结：

时间复杂度： O(nlogn)
空间复杂度： O(1)