Question

所以我有一个比较插入的两个字符数组的方法（s和t，其中s是字符数组，如果它更小则应该返回true），目的是找出一个是否小于另一个（在字典顺序）前n个字符。

public boolean lessCheck(char[] s, char[] t, int n) {
            int q = 0;
            if (t.length < n || s.length < n) {
                if (s.length != t.length) {
                    if (t.length < s.length) {
                        q = t.length;
                    } else {
                        q = s.length;
                    }
                } else {
                    q = t.length;
                }
            } else {
                q = n;
            }

            for (int i = 0; i < q; i++) {
                if (t[i] != s[i]) {
                    if (t[i] > s[i]) {
                        return true;
                    } else {
                        return false;
                    }
                }
            }

            if (equal(s, t, n)) {
                return false;
            } else {
                return true;
            }
        }

我遇到的问题是，无论何时我

s = bind，t = bin，n = 7 我明白了。

这应该返回false，因为bind在字典顺序中小于bin ...

任何帮助？

Answer 1

s = bind，t = bin和n = 7我得到了。

当调用q = 3

时

正确？

for 循环比较3个字符 b，i，n 。

正确？

最终 if 语句使用相等方法。绑定和 bin 的长度不同且低于n。

等于返回false，对吧？

您获得的最终结果是真实的，来自最后的其他块。

正确？

String 类定义了一个符合您要求的 compareTo 方法：

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#compareTo(java.lang.String)

new String("bind").compareTo("bin")>0
new String("bin").compareTo("zoo")<0
new String("bin").compareTo("bin")==0

Answer 2

问题似乎与这段代码有关：

        for (int i = 0; i < q; i++) {
            if (t[i] != s[i]) {
                if (t[i] > s[i]) {
                    return true;
                } else {
                    return false;
                }
            }
        }

应该是

        for (int i = 0; i < q; i++) {
            if (t[i] != s[i]) {
                if (t[i] > s[i]) {
                    return true;
                } else if (t[i] < s[i]) {
                    return false;
                }
            }
        }

实际上，如果条件为t [i]> s [i]不是真的，你还需要检查t [i]＆lt; s [i]以便返回虚假。

我认为你的算法的更紧凑版本是：

public static boolean lessThan(char[] s, char[] t, int n) {

    int minLength = Math.min(Math.min(s.length, t.length), n);

    for (int i = 0; i < minLength; i++) {
        if (s[i] < t[i]) {
            return true;
        } else if (s[i] > t[i]) {
            return false;
        }
    }

    return (minLength < n && s.length < t.length) ? true : false;
}

我希望有所帮助！

Answer 3

您的equals方法返回false，因为数组长度不同，因为equals返回false，您的lessThan方法返回{{ 1}}。

在比较几乎所有角色后，调用true方法毫无意义。不要调用equals方法，只需检查s是否短于t：

equals

如果子阵列相等且一个比另一个短，则意味着它将被放置在字典中较长的数组之前。

Answer 4

抱歉无法抗拒找到q的逻辑。没有必要找到这个q。

试试这个：

public boolean lessThan(char[] s, char[] t, int n) {
    int i = 0, j = 0, q = 0;
    while (i < s.length && i < t.length && (i < n)) {
        if (s[i] > t[i])
            return false;
        i++;
    }
    if (s.length > t.length)
        return false;
    else if (n < i)
        return true;
    return true;
}

比较字符串

4 个答案: