单词接龙

一、要求

　　大家经常玩成语接龙游戏，我们试一试英语的接龙吧：一个文本文件中有N 个不同的英语单词， 我们能否写一个程序，快速找出最长的能首尾相连的英语单词链，每个单词最多只能用一次。最长的定义是：最多单词数量，和单词中字母的数量无关。

例如， 文件里有：

Apple

Zoo

Elephant

Under

Fox

Dog

Moon

Leaf

Tree

Pseudopseudohypoparathyroidism

最长的相连英语单词串为：  apple - elephant – tree,  输出到文件里面，是这样的：

Apple

Elephant

Tree

二、分析

　　遍历查找，每次找到一个链后，删去最后链里最后一个单词，重新向后查找，这样可以找出所有链，然后再找最长链。

三、txt文件

apple earth zoo element text turn monkey rabbit hand table tag good hour

四、源代码

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class FindLongestChain {

    public static void main(String[] args) throws IOException {
        String inputfilename ="F:\\Study\\Code\\Java\\单词接龙\\input1.txt";
        String outputfilename ="F:\\Study\\Code\\Java\\单词接龙\\output.txt";
        File input = judgeFile(inputfilename);
        File output = judgeFile(outputfilename);
        if(input != null) {
            ArrayList<String> list = findLongChain(readFile(input));
            if(output != null)
                output(list,output);
        }else {
            System.out.println("程序无法运行，请检查文件！");
        }
      }
    
    
    private static File judgeFile(String s) {
        try {
            File file = new File(s);
            if (file.exists()) {
                if (file.isDirectory()) {
                    System.out.println("当前路径存在同名文件夹！");
                    return null;
                } else {
                    return file;
                }
            } else {
                System.out.println("文件" + file + "不存在，正在创建该文件！");
                if(!file.getParentFile().exists()) {
                    if(file.getParentFile().mkdirs()) {
                        System.out.println("创建文件夹" + file.getParentFile() + "成功！");
                    } else {
                        System.out.println("创建文件夹" + file.getParentFile() + "失败！");
                        return null;
                    }
                }
                if(file.createNewFile()) {
                    System.out.println("创建文件 " + file + " 成功！");
                    return file;
                }else {
                    System.out.println("创建文件"+ file +"失败！");
                    return null;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    private static ArrayList<String> readFile(File file){
        ArrayList<String> list = new ArrayList<String>();
        try {
            BufferedReader br = new BufferedReader(new FileReader(file));
            int c;
            String s = "";
            while((c = br.read()) != -1) {
                if(c<65 || (c>90&&c<96) || c>122) {
                    if(s != "" && !list.contains(s))
                        list.add(s);
                    s = "";
                } else {
                    s += (char)c;
                    s.toLowerCase();   //转成小写，便于比较
                }
            }
            if(s != "" && !list.contains(s))  //如果最后读取到的不是分隔符就说明并未将s存进list中
                list.add(s);
            br.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
        return list;
    }
    
    private static ArrayList<String> findLongChain(ArrayList<String> l) {
        ArrayList<ArrayList<String>> chains = new ArrayList<ArrayList<String>>();
        ArrayList<String> list;
        do {
            list = new ArrayList<String>();
            list.add(l.get(0));
            int location = 0;  //字符串列表当前查到的索引位置
            String head,tail;  //单词首字母和尾字母
            while(location < l.size()) {
                tail = list.get(list.size()-1).substring(list.get(list.size()-1).length()-1,list.get(list.size()-1).length());
                head = l.get(location).substring(0,1);
                if(head.compareTo(tail) == 0)
                    list.add(l.get(location));
                location++;
            }
            chains.add(list);
            for(int i=0;i<l.size();i++)          //找到单词链的最后一个单词，下次遍历跳过该词
                if(l.get(i) == list.get(list.size()-1))
                    l.set(i,"/" + l.get(i));
        }while(list.size() != 1);     //当单词链只有一个单词时，停止查找
        int max = 0;
        for(ArrayList<String> c:chains) {    //遍历查找单词链列表中最长单词链
            if(max < c.size()) {
                max = c.size();
                list = c;
            }
            /*for(String str:c)
                System.out.println(str);
            System.out.println();*/
        }
        /*for(String str:list)
            System.out.println(str);*/
        return list;
    }
    
    private static void output(ArrayList<String> list, File file) {
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            for(String str:list) {
                bw.write(str);
                bw.newLine();
            }
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}