子產品依賴關系分析-Java實作

題目描述：

1.一個系統的若幹子產品間存在互相依賴的關系，如果A子產品調用了B子產品的接口，那麼成為A依賴B，記為A->B

如果A->B,B->A，那麼稱A和B子產品都存在循環依賴。

如果A->B,B->C,C->D,D->B,那麼BCD存在循環依賴，A不存在循環依賴，依次類推。

先輸入若幹子產品之間的關系，判斷某子產品是存在循環依賴。

輸入：
       {0x00, 0x01},
       {0x02, 0x03},
       {0x03, 0x04}
 輸出：
       {0x00, false},
       {0x01, false},
       {0x02, false},
       {0x03, false},
       {0x04, false}
           

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Set;

public class Main {
    static ArrayList<LinkedList<String>> arrayList = new ArrayList<LinkedList<String>>();//存儲子產品間依賴關系的資料結構
    static HashSet<String> hashSet = new HashSet<String>(); //存儲具有循環依賴的點
    static Set<String> set = new LinkedHashSet<String>();//用來保證按輸入順序輸出
    //static Set<String> set = new HashSet<String>(); //如果不需要保證輸出順序用HashSet
    public static void main(String[] args){
        Boolean isCrileNode = false;
        Scanner s = new Scanner(System.in);
        while(s.hasNext()){
            //輸入=====
            String temp;
            do{
                String ss = s.nextLine();
                temp = ss;
                ss = ss.replace("{", "");
                ss = ss.replaceAll("[^a-z^0-9]", " ");
                String[] strings = ss.split("\\s+");
                for(int i=; i< strings.length; i++){
                    set.add(strings[i]);
                }
                AddDependency(strings[], strings[]);
            }while(temp.charAt(temp.length()-) == ',');

            CricleNode();

            //輸出=====
            int count = ;
            for(String str : set){
                isCrileNode = MouduleIsCycularDependency(str);
                count++;
                if(count != set.size()){
                    System.out.println("{"+str+", "+isCrileNode+"},");
                }else {
                    System.out.println("{"+str+", "+isCrileNode+"}");
                }   
            }
            clear();
        }
    }
    //添加依賴關系
    public static void AddDependency(String Modeled, String DependModuled){
        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add(Modeled);
        linkedList.add(DependModuled);
        arrayList.add(linkedList);
        Boolean change = true;
        while(change){
            change = ConnectList();
        }

    }
    //判斷其中的連結清單是否有可以相連的
    public static Boolean ConnectList(){
        if(arrayList.size() > ){
            for(int i = ; i < arrayList.size()-; i++){
                for(int j= i+; j < arrayList.size(); j++){
                    if(arrayList.get(i).getFirst().equals(arrayList.get(j).getLast())){
                        LinkedList<String> link1 = arrayList.get(j);
                        link1.removeLast();
                        link1.addAll(arrayList.get(i));
                        arrayList.remove(j);
                        arrayList.remove(i);
                        arrayList.add(link1);
                        return true;
                    }else if(arrayList.get(i).getLast().equals(arrayList.get(j).getFirst())){
                        LinkedList<String> link1 = arrayList.get(i);
                        link1.removeLast();
                        link1.addAll(arrayList.get(j));
                        arrayList.remove(j);
                        arrayList.remove(i);
                        arrayList.add(link1);
                        return true;
                    }
                }
            }
        }
        return false;
    }
    //擷取依賴點集合
    public static void CricleNode(){

        for(int i = ; i < arrayList.size(); i++){
            int start = arrayList.get(i).indexOf(arrayList.get(i).getLast());
            int end = arrayList.get(i).lastIndexOf(arrayList.get(i).getLast());
            if(start != end){
                for(int j = start; j < end; j++){
                    hashSet.add(arrayList.get(i).get(j));
                }
            }
            int start1 = arrayList.get(i).indexOf(arrayList.get(i).getFirst());
            int end1 = arrayList.get(i).lastIndexOf(arrayList.get(i).getFirst());
            if(start1 != end1){
                for(int j = start1; j < end1; j++){
                    hashSet.add(arrayList.get(i).get(j));
                }
            }
        }
    }
    //判斷子產品是否存在依賴關系
    public static boolean MouduleIsCycularDependency(String ModuleId){
        if(hashSet.contains(ModuleId))
            return true;
        return false;
    }
    //清空子產品資料
    public static void clear(){
        arrayList.clear();
        hashSet.clear();
        set.clear();
    }
}