如何用java程序写出已知排序字符串数组的字典顺序

Question

有个已经排序好的随机数组，例如String[] sortedArray = {"guest","guard","guy","gym","goat","goal","east"};从中可以推断出某些字母的规律，例如， 字母g排在字母e的前面，字母 e在 字母 a的 前面。有些 字母例如d无法推断，可以单独输出提示。如何用java程序写出当前的字典顺序

Answer 1

Arrays.sort()

Answer 2

遍历字符串数组，我记得字符串里有个方法叫compareTo惊醒比较，大于返回1，小于返回0；你可以随意写两个字符串比较下，然后按自己的想法惊醒排序

Answer 3

嗯、如果你知道楼上说的compareTo方法的话，那么你想解决的问题是：用什么算法思维解决你当前问题，对不对？我写了一个，楼主看下是不是你想要的（我能说我边想编写整了一个小时么  Orz  ）事先说明：得到的结果是多组规则的集合，比如a>b>c  和 x>y>z，这样并不能证明，abc与xyz的大小关系。
结果是用字符串表示排序规则的比如abc、xyz上代码 （main函数、直接拿去运行就可以验证）：
import java.util.ArrayList;
import java.util.List;public class Test { public static void main(String[] args) {
String[] sortedArray = { "guest", "guestsc", "guard", "guy", "gym", "goat", "goal", "east" };
Test test = new Test();
test.getSortRule(sortedArray);
} public void getSortRule(String[] pars) {
List<String> rules = new ArrayList<String>();
String tempStr = null; int arrayLength = pars.length;
for (int i = 0; i < arrayLength; i++) {
String str = pars[i];
if (tempStr != null) {
if (str.compareTo(tempStr) != 0) {
int len1 = str.length();
int len2 = tempStr.length();
char[] stringArr1 = str.toCharArray();
char[] stringArr2 = tempStr.toCharArray();
int n = Math.min(len1, len2); for (int j = 0; j < n; j++) {
if (stringArr1[j] != stringArr2[j]) {
rules.add(String.valueOf(stringArr1[j]) + String.valueOf(stringArr2[j]));
break;
}
} }
}
tempStr = str;
} int rulesLength = rules.size();
if (rulesLength > 1) {
boolean isGetNewRule = false;
for (int i = 0; i < rulesLength - 1; i++) {
isGetNewRule = false;
for (int j = i + 1; j < rulesLength; j++) {
String str1 = rules.get(i);
String str2 = rules.get(j);
if (str1.substring(0, 1).equals(str2.subSequence(str2.length() - 1, str2.length()))) {
rules.set(j, str2 + str1.substring(1));
isGetNewRule = true;
} else if (str2.substring(0, 1).equals(str1.subSequence(str1.length() - 1, str1.length()))) {
rules.set(j, str1 + str2.substring(1));
isGetNewRule = true;
} }
if (isGetNewRule) {
rules.set(i, null);
}
}
} for (String s : rules) {
if (s != null) {
System.out.println(s);
}
}
return;
}
}

Answer 4

昨天写的有缺陷（1、二元排序规则遍历不完全，改为：增加一重循环，达到完全遍历；2、排序规则集整合时只支持首尾一个字母相同的才拼接，改为：支持多字母相同也拼接），修改了一下，并加上注释
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;/**
 * @描述 获取已知序列的排序规则
 * 
 * @思路 1、将序列双重遍历，找出两两之间的x>y的二元排序规则，并存入set，去重；
 *     2、遍历所有二元规则，将首与尾相同的两个二元规则拼接（包含首尾多个字母相同的，
 *     3、比如ayo,yos）,被引用拼接过的子二元抛弃（设置为null），比如ayo,yos，现在就变为null，ayos;
 *     4、将所有拼接过滤后的规则序列集输出（null的就pass掉）。
 * 
 * @算法说明 本人采用的最暴力的算法来实现，如果你更好的实现方式，共同探讨。
 * 
 * @author joker
 * 
 */
public class Test { public static void main(String[] args) {
String[] sortedArray = { "guest", "guestsc", "guard", "guy", "gym", "goat", "goal", "east" };
Test test = new Test();
test.getSortRule(sortedArray);
} public void getSortRule(String[] pars) { Set<String> rulesSet = new HashSet<String>();
int arrayLength = pars.length; // 双重遍历，获取所有二元排序规则
for (int i = 0; i < arrayLength - 1; i++) {
String str1 = pars[i];
for (int j = i + 1; j < arrayLength; j++) {
String str2 = pars[j];
if (str1.compareTo(str2) != 0) {
int len1 = str1.length();
int len2 = str2.length();
char[] stringArr1 = str1.toCharArray();
char[] stringArr2 = str2.toCharArray(); int n = Math.min(len1, len2);
for (int k = 0; k < n; k++) {
if (stringArr1[k] != stringArr2[k]) {
rulesSet.add(String.valueOf(stringArr1[k]) + String.valueOf(stringArr2[k]));
break;
}
}
} }
} List<String> rules = new LinkedList<String>(rulesSet);
int rulesLength = rules.size(); // 双重遍历二元规则集，将例如ae,ef合并为aef,将adf,dfn合并为adfn
if (rulesLength > 1) {
boolean isGetNewRule = false;
for (int i = 0; i < rulesLength - 1; i++) {
isGetNewRule = false;
for (int j = i + 1; j < rulesLength; j++) {
String str1 = rules.get(i);
String str2 = rules.get(j);
int n = Math.min(str1.length(), str2.length());
for (int k = 1; k <= n; k++) {
if (str1.substring(0, k).equals(str2.subSequence(str2.length() - k, str2.length()))) {
rules.set(j, str2 + str1.substring(k));
isGetNewRule = true;
} else if (str2.substring(0, k).equals(str1.subSequence(str1.length() - k, str1.length()))) {
rules.set(j, str1 + str2.substring(k));
isGetNewRule = true;
}
}
}
if (isGetNewRule) {
rules.set(i, null);
}
}
} // 输出排序规则集
Set<String> set = new HashSet<String>(rules);
for (String s : set) {
if (s != null) {
System.out.println(s);
}
} return;
}
}

Answer 5

把已经排好序的和未排序的进行for嵌套排序，当未排序中有已经排序的放到一个数组中，不存在的放到一个数组中，把两个数组for循环去除空放到两个list中
，使用list.addALL(),相加，就是完整的已经排序的了（可以实现，我测试过了，不过感觉很烂）