java面试题,给一组域名排序

Question

google.cn
linggui.gov.cn
baidu.com
google.com.hk
zhidao.baidu.com
google.com
sina.com
tw.msn.com
给上面一组域名排序：
1.     从每个域名的最后一组开始比较（好像要先把域名从. 的地方分开）， 按域名的字母先后顺序 （a,b,c,...,z），如果相同依次往前比较。
      例如google.com和baidu.com比较，   先比较com和com,两个com相同，往前比较google与baidu,b在g前，
     因此顺序为：
         baidu.com
         google.com2. 如果首字目相同，比较下一个字母依次类推
         例如linggui.gov.cn和google.com比较
           先比较cn和com, c相同，比较第二个n与o，n在o前，
          因此顺序为：
          linggui.gov.cn
          google.com3. 比较如遇到空格放到字母前面，例如zhidao.baidu.com与baidu.com比较，
        顺序为：          baidu.com
                   zhidao.baidu.com
4.     不考虑？+ 、/等特殊字符请给出思路及代码，谢谢！(好像用到递归）

Answer 1

Arrays类有排序功能，然后自己定义一个排序规则就行了
import java.util.*;public class Test
{
public static void main(String[] args)
{
String[] strs = new String[] {"google.cn",
"linggui.gov.cn",
"baidu.com",
"google.com.hk",
"zhidao.baidu.com",
"google.com",
"sina.com",
"tw.msn.com"};

Arrays.sort(strs, new Comparator<String>()
{
public int compare(String str1, String str2) 
{
String[] strs1 = str1.split("\\.");
String[] strs2 = str2.split("\\.");
reverse(strs1);
reverse(strs2);
int length = strs1.length < strs2.length ? strs1.length : strs2.length;
for (int i = 0; i < length; i++)
{
int cmp = strs1[i].compareTo(strs2[i]);
if (cmp != 0)
{
return cmp;
}
}
return strs1.length - strs2.length;
}

private void reverse(String[] strs)
{
for (int i = 0; i < (strs.length + 1) / 2; i++)
{
String tmp = strs[i];
strs[i] = strs[strs.length - i - 1];
strs[strs.length - i - 1] = tmp;
}
}
});

for (int i = 0; i < strs.length; i++)
{
System.out.println(strs[i]);
}
}
}

Answer 2

简单
String name="zhidao.baidu.com"; 
String[] splitnames=name.split('.');//用.拆成数组
splitnames=splitnames.reverse(); //反转数组的顺序
这样就反过来了
然后再排序就行了

Answer 3

我做了一个 不说了上代码 简单易懂 
package test;import java.util.Arrays;import org.junit.Test;import serivce.Servce;import dao.LogDao;
import dao.LogDaoIml;
import entity.Log;public class LogDaoImltest { @Test
public void test() {
//new Servce().and();
 
YuMing[] yms = {new YuMing("", "google", "cn"),new YuMing("zhidao", "baidu", "com"),new YuMing("", "baidu", "com")};
Arrays.sort(yms);
for(int i=yms.length-1;i>=0;i--) {
System.out.println(yms[i]);
}
}

static private class YuMing implements Comparable<YuMing> {
public String head;
public String center;
public String end;
public YuMing(String head, String center, String end) {
super();
this.head = head;
this.center = center;
this.end = end;
}
@Override
public int compareTo(YuMing ym) {
if(end.compareTo(ym.end) != 0) {
return end.compareTo(ym.end);
}
if(center.compareTo(ym.center) != 0) {
return center.compareTo(ym.center);
}

if(head.compareTo(ym.head) != 0) {
head.compareTo(ym.head);
}
return 0;
}
@Override
public String toString() {
if(head.equals("")) {

return center+"."+end;
}
 return head+"."+center+"."+end;
}

 



}}
 

Answer 4

刚测试了下 有点小问题 下面是改好的package test;import java.util.Arrays;import org.junit.Test;import serivce.Servce;import dao.LogDao;
import dao.LogDaoIml;
import entity.Log;public class LogDaoImltest { @Test
public void test() {
//new Servce().and();
 
YuMing[] yms = {new YuMing("", "google", "cn"),new YuMing("zhidao", "baidu", "com"),new YuMing("", "baidu", "com")};
Arrays.sort(yms);
for(int i=yms.length-1;i>=0;i--) {
System.out.println(yms[i]);
}
}

static private class YuMing implements Comparable<YuMing> {
public String head;
public String center;
public String end;
public YuMing(String head, String center, String end) {
super();
this.head = head;
this.center = center;
this.end = end;
}
@Override
public int compareTo(YuMing ym) {
if(end.compareTo(ym.end) != 0) {
return end.compareTo(ym.end);
}
if(center.compareTo(ym.center) != 0) {
return center.compareTo(ym.center);
}

if(head.compareTo(ym.head) != 0) {
if(head.equals("")) return 1;
if(ym.head.equals("")) return -1;
return head.compareTo(ym.head);
}
return 0;
}
@Override
public String toString() {
if(head.equals("")) {

return center+"."+end;
}
 return head+"."+center+"."+end;
}

 



}}
 

Answer 5

 不好意思我写的还有Bug 这位兄弟写的不错 顶下

Answer 6

package com.wikimore;public class SortTest { private String[] domains = new String[] { "google.cn", "linggui.gov.cn", "baidu.com",
"google.com.hk", "zhidao.baidu.com", "google.com", "sina.com", "tw.msn.com", "google.com.jp", "taobao.om" }; private String[] sort(String[] array) {
String temp = null;
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++) {
int m = array[i].length() - 1;
int n = array[j].length() - 1;
while (m >= 0 && n >= 0) {
if (array[i].charAt(m) < array[j].charAt(n))
break;
else if (array[i].charAt(m) > array[j].charAt(n)) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
break;
}
m--;
n--;
if (n < 0) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
break;
}
}
}
}
return array;
} private String[] getDomains() {
return domains;
} /**
 * <p>
 * 2011-11-18
 * 
 * @author wikimore
 * @param args
 */
public static void main(String[] args) {
SortTest st = new SortTest();
String[] strs = st.getDomains();
System.out.println("======排序前======");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
System.out.println("======排序后======");
long start = System.currentTimeMillis();
String[] afterSortStrs = st.sort(strs);
long end = System.currentTimeMillis();
System.out.println(start);
System.out.println(end);
System.out.println("执行时间:"+(end-start)+"ms");
for (int i = 0; i < afterSortStrs.length; i++) {
System.out.println(afterSortStrs[i]);
}
}
}

Answer 7

代码贴了这么多我就不贴了其实时间充足的话，可以设计一个 域名类实现 compareble 接口，方便自定义排序规则以后也可以当工具类用，当然，尽可能扩展性写好些体现面向对象思想嘛

Answer 8

我也写了一个import java.util.Vector;//网址排序
//网址以dot为分隔符，不用网址之间从最后的一部分进行排序。
public class SortWebsites
{
private Vector<String> [] arrWebsites ;

//将储存网址字符串的数组初始化向量数组。向量的元素是被dot分隔的部分。
public SortWebsites(String [] websites)
{
arrWebsites = new Vector[websites.length];
for (int i=0; i<websites.length; i++)
{
arrWebsites[i] = new Vector<String>();
int startIndex = 0;
for (int j=0; j<websites[i].length(); j++)
if (websites[i].charAt(j) == '.')
{
arrWebsites[i].add(websites[i].substring(startIndex, j));
startIndex = j + 1;
}
arrWebsites[i].add(websites[i].substring(startIndex, websites[i].length()));
}
}

//比较两个网址向量，s1<s2则返回-1；s1>s2则返回1，s1=s2则返回0
//从两个向量的最后一个元素进行比较。字符串相同以角度字符串长度的那个字符串为小
//如果一个网址的字符串是另个网址的字符串。则字符串的那个网址为小
private int compare(Vector<String> s1, Vector<String> s2)
{
int s1Index = s1.size() - 1;
int s2Index = s2.size() - 1;
for (;s1Index>=0 && s2Index>=0 ;s1Index--, s2Index--)
{
if (s1.get(s1Index).compareTo(s2.get(s2Index)) < 0)
return -1;
else if (s1.get(s1Index).compareTo(s2.get(s2Index)) > 0)
return 1;
}
if (s1Index < 0 && s2Index >= 0)
return -1;
if (s2Index < 0 && s1Index >= 0)
return 1;
return 0;
}

//交换
private void swap(int i, int j)
{
Vector<String> temp;
temp = arrWebsites[i];
arrWebsites[i] = arrWebsites[j];
arrWebsites[j] = temp;
}

//选出最小元素的方法进行排序，从小到大排序
private void sort()
{
for (int i=0; i<arrWebsites.length-1; i++)
{
int minWebsiteIndex = i;
for (int j=i+1; j<arrWebsites.length; j++)
if (compare(arrWebsites[minWebsiteIndex], arrWebsites[j]) >0)
minWebsiteIndex = j;
if (minWebsiteIndex != i)
swap(i, minWebsiteIndex);
}
}

//测试初始化
private void test_init_arrWebsites()
{
for (int i=0; i<arrWebsites.length; i++)
{
System.out.println("第" + (i+1) + "条网址分解为：");
for (int j=0; j<arrWebsites[i].size(); j++)
System.out.println(arrWebsites[i].get(j));
}
}

//打印结果
private void printInfo()
{
for (int i=0; i<arrWebsites.length; i++)
{
for (int j=0; j<arrWebsites[i].size()-1; j++)
System.out.print(arrWebsites[i].get(j) + ".");
System.out.println(arrWebsites[i].get(arrWebsites[i].size()-1));
}
}

public static void main(String [] args)
{
String [] websites = {"linggui.gov.cn", "baidu.com", "google.com.hk", "zhidao.baidu.com", 
  "google.com", "google.cn", "sina.com", "tw.msn.com"};

SortWebsites sw = new SortWebsites(websites);
//sw.test_init_arrWebsites();
sw.sort();
System.out.println("从小到大排序后的结果:");
sw.printInfo();
}
}