华为OD机考算法题：日志排序

题目部分

题目	日志排序
难度	易
题目说明	运维工程师采集到某产品现网运行一天产生的日志 N 条，现需根据日志时间按时间先后顺序对日志进行排序。 日志时间格式为： H:M:S.N H表示小时 (0-23)，M表示分钟 (0-59)，S表示秒 (0-59)，N表示毫秒 (0-999)。 时间可能并没有补齐，也就是说 01:01:01.001，也可能表示为 1:1:1.1。
输入描述	第一行输入一个整数 N，表示日志条数，1 <= N <= 100000。 接下来 N 行输入 N 个时间。
输出描述	按时间升序排序之后的时间，如果有两个时间表示的时间相同，则保持原有顺序。
补充说明	无
------------------------------------------------------
示例
示例1
输入	2 01:41:8.9 1:1:09.211
输出	1:1:09.211 01:41:8.9
说明	无
示例2
输入	3 23:41:08.023 1:1:09.211 08:01:22.0
输出	1:1:09.211 08:01:22.0 23:41:08.023
说明	无
示例3
输入	2 22:41:08.023 22:41:08.23
输出	22:41:08.023 22:41:08.23
说明	两个时间表示的时间相同，保持其原有输出顺序。

---

解读与分析

题目解读：

给出一组时间，按照既定规则，对时间进行排序，如果两个时间相等，保持原有顺序。

分析与思路：

比较时间时，分 3 段比较，先比较小时，再比较分，最后比较秒。
比较小时和分的时候，注意数字可能有前导 0。当比较分时，不能直接比较小数的大小，它可能包含两部分：秒和毫秒，通过 “.” 将他们分隔开，然后采用比较小时的方式分别比较秒和毫秒。 

时间复杂度取决于排序算法，为 O(nlogn)，空间复杂度为 O(n)。

---

代码实现

Java代码

import java.util.Arrays;
import java.util.Scanner;
import java.util.Comparator;

/**
 * 日志排序
 * 
 * @since 2023.11.01
 * @version 0.1
 * @author Frank
 *
 */
public class LogSort {

    public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	while (sc.hasNext()) {
	    String input = sc.nextLine();
	    int count = Integer.parseInt(input);

	    String[] timeArr = new String[count];
	    for (int i = 0; i < count; i++) {
		input = sc.nextLine();
		timeArr[i] = input;
	    }
	    processLogSort(timeArr);
	}

    }

    private static void processLogSort(String[] timeArr) {
	Comparator comp = new Comparator() {
	    @Override
	    public int compare(String o1, String o2) {
		String[] o1Arr = o1.split(":");
		String[] o2Arr = o2.split(":");
		int[] o1Int = new int[4];
		int[] o2Int = new int[4];
		for (int i = 0; i < 2; i++) {
		    o1Int[i] = Integer.parseInt(o1Arr[i]);
		    o2Int[i] = Integer.parseInt(o2Arr[i]);
		}
        
        // 此处是正则表达式
		String[] second1Arr = o1Arr[2].split("\\.");
		String[] second2Arr = o2Arr[2].split("\\.");

		o1Int[2] = Integer.parseInt(second1Arr[0]);
		o2Int[2] = Integer.parseInt(second2Arr[0]);

		if (second1Arr.length == 2) {
		    o1Int[3] = Integer.parseInt(second1Arr[1]);
		}
		if (second2Arr.length == 2) {
		    o2Int[3] = Integer.parseInt(second2Arr[1]);
		}

		for (int i = 0; i < o1Int.length; i++) {
		    if (o1Int[i] == o2Int[i]) {
			continue;
		    }
		    return o1Int[i] - o2Int[i];
		}

		return 0;
	    }
	};
	Arrays.sort(timeArr, comp);
	for (int i = 0; i < timeArr.length; i++) {
	    System.out.println(timeArr[i]);
	}

    }

}

JavaScript代码

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;
void async function() {
    while (line = await readline()) {
        var count = parseInt(line);

        var timeArr = new Array();
        for (var i = 0; i < count; i++) {
            line = await readline();
            timeArr[i] = line;
        }
        processLogSort(timeArr);
    }
}();

function processLogSort(timeArr) {
    var comp = function(o1, o2) {
        var o1Arr = o1.split(":");
        var o2Arr = o2.split(":");
        var o1Int = new Array();
        var o2Int = new Array();
        for (var i = 0; i < 2; i++) {
            o1Int[i] = parseInt(o1Arr[i]);
            o2Int[i] = parseInt(o2Arr[i]);
        }

        // 此处不是正则表达式
        var second1Arr = o1Arr[2].split(".");
        var second2Arr = o2Arr[2].split(".");

        o1Int[2] = parseInt(second1Arr[0]);
        o2Int[2] = parseInt(second2Arr[0]);

        if (second1Arr.length == 2) {
            o1Int[3] = parseInt(second1Arr[1]);
        } else {
            o1Int[3] = 0;
        }

        if (second2Arr.length == 2) {
            o2Int[3] = parseInt(second2Arr[1]);
        } else {
            o2Int[3] = 0;
        }

        for (var i = 0; i < o1Int.length; i++) {
            if (o1Int[i] == o2Int[i]) {
                continue;
            }
            return o1Int[i] - o2Int[i];
        }

        return 0;
    };
    timeArr.sort(comp);
    for (var i = 0; i < timeArr.length; i++) {
        console.log(timeArr[i]);
    }
}

(完)