算法

      http://blog.csdn.net/qq_26122557/article/details/77104961

http://blog.csdn.net/qq_26122557/article/details/77104961

1. //消费节点，定义为一个链表的头  
2. public class consumptionNode {  
3.     private int consumptionNodeId;//消费节点id,用于确定哪一个消费节点  
4.     private LinkNode nextLinkNodeId;//链路节点id，用于确定哪一个链路节点  
5.     private int bandwidthRequirement;//定义一个参数保存贷款需求  
6.     public consumptionNode(int consumptionNodeId,LinkNode nextLinkNodeId,int bandwidthRequirement){  
7.         this.consumptionNodeId=consumptionNodeId;  
8.         this.nextLinkNodeId=nextLinkNodeId;  
9.         this.bandwidthRequirement=bandwidthRequirement;  
10.     }  
11.       
12.       
13.       
14.       
15.       
16.       
17.       
18.     public int getConsumptionNodeId() {  
19.         return consumptionNodeId;  
20.     }  
21.     public void setConsumptionNodeId(int consumptionNodeId) {  
22.         this.consumptionNodeId = consumptionNodeId;  
23.     }  
24.     public LinkNode getNextLinkNodeId() {  
25.         return nextLinkNodeId;  
26.     }  
27.     public void setNextLinkNodeId(LinkNode nextLinkNodeId) {  
28.         this.nextLinkNodeId = nextLinkNodeId;  
29.     }  
30.     public int getBandwidthRequirement() {  
31.         return bandwidthRequirement;  
32.     }  
33.     public void setBandwidthRequirement(int bandwidthRequirement) {  
34.         this.bandwidthRequirement = bandwidthRequirement;  
35.     }  
36.       
37.   
38. }  

39. //消费节点，定义为一个链表的头
    public class consumptionNode {
    	private int consumptionNodeId;//消费节点id,用于确定哪一个消费节点
    	private LinkNode nextLinkNodeId;//链路节点id，用于确定哪一个链路节点
    	private int bandwidthRequirement;//定义一个参数保存贷款需求
    	public consumptionNode(int consumptionNodeId,LinkNode nextLinkNodeId,int bandwidthRequirement){
    		this.consumptionNodeId=consumptionNodeId;
    		this.nextLinkNodeId=nextLinkNodeId;
    		this.bandwidthRequirement=bandwidthRequirement;
    	}
    	
    	
    	
    	
    	
    	
    	
    	public int getConsumptionNodeId() {
    		return consumptionNodeId;
    	}
    	public void setConsumptionNodeId(int consumptionNodeId) {
    		this.consumptionNodeId = consumptionNodeId;
    	}
    	public LinkNode getNextLinkNodeId() {
    		return nextLinkNodeId;
    	}
    	public void setNextLinkNodeId(LinkNode nextLinkNodeId) {
    		this.nextLinkNodeId = nextLinkNodeId;
    	}
    	public int getBandwidthRequirement() {
    		return bandwidthRequirement;
    	}
    	public void setBandwidthRequirement(int bandwidthRequirement) {
    		this.bandwidthRequirement = bandwidthRequirement;
    	}
    	
    
    }
    

[java] view plain copy print ?

1. public class EmptyQueueException extends Exception {  
2.   
3.     public EmptyQueueException(String string) {  
4.         // TODO Auto-generated constructor stub  
5.     }  
6.   
7. }  

public class EmptyQueueException extends Exception {

	public EmptyQueueException(String string) {
		// TODO Auto-generated constructor stub
	}

}

[java] view plain copy print ?

1. import java.io.BufferedReader;  
2. import java.io.BufferedWriter;  
3. import java.io.Closeable;  
4. import java.io.File;  
5. import java.io.FileReader;  
6. import java.io.FileWriter;  
7. import java.io.IOException;  
8. import java.util.LinkedList;  
9. import java.util.List;  
10.   
11. public final class FileUtil//util利用  
12. {  
13.     /**  
14.      * read file and output 
15.      * @param filePath 
16.      * @param spec//spec规格  
17.      * @return 
18.      * @author 
19.      * @since 2016-3-1 
20.      */  
21.     public static String[] read(final String filePath, final Integer spec)  
22.     {  
23.         File file = new File(filePath);//获取文件eg. File file = new File("D:/hust/file.txt");  
24.         // file check  
25.         if ((!isFileExists(file)) ||   
26.                 (!file.canRead()))  
27.         {  
28.             System.out.println("file [" + filePath + "] is not exist or cannot read!!!");  
29.             return null;  
30.         }  
31.           
32.         List<String> lines = new LinkedList<String>();  
33.         BufferedReader br = null;  
34.         FileReader fb = null;  
35.         try  
36.         {  
37.             fb = new FileReader(file);//使用带有指定文件的String参数的构造方法。创建该输入流对象。并关联源文件。  
38.             br = new BufferedReader(fb);  
39.   
40.             String str = null;  
41.             int index = 0;  
42.             while (((spec ==  null) || index++ < spec) && (str = br.readLine()) != null)  
43. //readline表示该方法读取一行文本，当遇到换行符"\n",回车符"\r"或者回车符后面紧跟着换行符时，该行结束并返回。  
44. //没有数据时，将会一直处于等待状态。(这里的一行不是物理的一行，而是以分隔号界定的一行)  
45.             {  
46.                 lines.add(str);  
47.             }  
48.         }  
49.         catch (IOException e)  
50.         {  
51.             e.printStackTrace();  
52.         }  
53.         finally  
54.         {  
55.             closeQuietly(br);  
56.             closeQuietly(fb);  
57.         }  
58.   
59.         return lines.toArray(new String[lines.size()]);  
60.     }  
61.     /**  
62.      * write file 
63.      * @param filePath  
64.      * @param content  
65.      * @param append true or false 
66.      * @return 
67.      * @author s00274007 
68.      * @since 2016-3-1 
69.      */                       
70.     public static int write (final String filePath, final String[] contents, final boolean append)  
71.     {  
72.         File file = new File(filePath);  
73.         if (contents == null)  
74.         {  
75.             System.out.println("file [" + filePath + "] invalid!!!");//invalid无效  
76.             return 0;  
77.         }  
78.   
79.         if (isFileExists(file) && (!file.canRead()))  
80.         {  
81.             return 0;  
82.         }  
83.   
84.         FileWriter fw = null;  
85.         BufferedWriter bw = null;  
86.         try  
87.         {  
88.             if (!isFileExists(file))  
89.             {  
90.                 file.createNewFile();  
91.             }  
92.   
93.             fw = new FileWriter(file, append);  
94.             bw = new BufferedWriter(fw);  
95.             for (String content : contents)//遍历contents  
96.             {  
97.                 if (content == null)  
98.                 {  
99.                     continue;  
100.                 }  
101.                 bw.write(content);  
102.                 bw.newLine();  
103.             }  
104.         }  
105.         catch (IOException e)  
106.         {  
107.             e.printStackTrace();  
108.             return 0;  
109.         }  
110.         finally  
111.         {  
112.             closeQuietly(bw);  
113.             closeQuietly(fw);  
114.         }  
115.   
116.         return 1;  
117.     }  
118.   
119.     private static void closeQuietly(Closeable closeable)  
120.     {  
121.         try  
122.         {  
123.             if (closeable != null)  
124.             {  
125.                 closeable.close();  
126.             }  
127.         }  
128.         catch (IOException e)  
129.         {  
130.         }  
131.     }  
132.   
133.     private static boolean isFileExists(final File file)  
134.     {  
135.         if (file.exists() && file.isFile())  
136.         {  
137.             return true;  
138.         }  
139.   
140.         return false;  
141.     }  
142.   
143. }  

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

public final class FileUtil//util利用
{
    /** 
     * read file and output
     * @param filePath
     * @param spec//spec规格 
     * @return
     * @author
     * @since 2016-3-1
     */
    public static String[] read(final String filePath, final Integer spec)
    {
        File file = new File(filePath);//获取文件eg. File file = new File("D:/hust/file.txt");
        // file check
        if ((!isFileExists(file)) || 
        		(!file.canRead()))
        {
            System.out.println("file [" + filePath + "] is not exist or cannot read!!!");
            return null;
        }
        
        List<String> lines = new LinkedList<String>();
        BufferedReader br = null;
        FileReader fb = null;
        try
        {
            fb = new FileReader(file);//使用带有指定文件的String参数的构造方法。创建该输入流对象。并关联源文件。
            br = new BufferedReader(fb);

            String str = null;
            int index = 0;
            while (((spec ==  null) || index++ < spec) && (str = br.readLine()) != null)
//readline表示该方法读取一行文本，当遇到换行符"\n",回车符"\r"或者回车符后面紧跟着换行符时，该行结束并返回。
//没有数据时，将会一直处于等待状态。(这里的一行不是物理的一行，而是以分隔号界定的一行)
            {
                lines.add(str);
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            closeQuietly(br);
            closeQuietly(fb);
        }

        return lines.toArray(new String[lines.size()]);
    }
    /** 
     * write file
     * @param filePath 
     * @param content 
     * @param append true or false
     * @return
     * @author s00274007
     * @since 2016-3-1
     */                     
    public static int write (final String filePath, final String[] contents, final boolean append)
    {
        File file = new File(filePath);
        if (contents == null)
        {
            System.out.println("file [" + filePath + "] invalid!!!");//invalid无效
            return 0;
        }

        if (isFileExists(file) && (!file.canRead()))
        {
            return 0;
        }

        FileWriter fw = null;
        BufferedWriter bw = null;
        try
        {
            if (!isFileExists(file))
            {
                file.createNewFile();
            }

            fw = new FileWriter(file, append);
            bw = new BufferedWriter(fw);
            for (String content : contents)//遍历contents
            {
                if (content == null)
                {
                    continue;
                }
                bw.write(content);
                bw.newLine();
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
            return 0;
        }
        finally
        {
            closeQuietly(bw);
            closeQuietly(fw);
        }

        return 1;
    }

    private static void closeQuietly(Closeable closeable)
    {
        try
        {
            if (closeable != null)
            {
                closeable.close();
            }
        }
        catch (IOException e)
        {
        }
    }

    private static boolean isFileExists(final File file)
    {
        if (file.exists() && file.isFile())
        {
            return true;
        }

        return false;
    }

}

[java] view plain copy print ?

1. import java.util.LinkedList;  
2. import java.util.List;  
3.   
4. public class Graphs {  
5.       
6.     List<consumptionNode> root=new LinkedList<>();  
7.     List<rootLinkNode> LinkRoot=new LinkedList<>();  
8.     private int consumptionNodeId;//消费节点id,用于确定哪一个消费节点  
9.     private LinkNode nextLinkNodeId;//链路节点id，用于确定哪一个链路节点  
10.     private int bandwidthRequirement;//定义一个参数保存贷款需求  
11.   
12.       
13.       
14.     //text测试用例  
15.     //public void getinfo(){  
16.     //  int num=5;  
17.     //  for(int i=0;i<num;i++){  
18.     //      consumptionNodeId=i;  
19.     //      nextLinkNodeId=null;  
20.     //      bandwidthRequirement=i;  
21.     //      addNode( consumptionNodeId, nextLinkNodeId, bandwidthRequirement);  
22.     //  }  
23.     //  for(int i=0;i<num;i++){  
24.     //      int m=root.get(i).getConsumptionNodeId();  
25.     //      System.out.println();  
26.     //        
27.     //  }  
28.     //    
29.     //}  
30.       
31.       
32.       
33.       
34.     //text2  
35.     public void getInfo2(){  
36.         int size=5;  
37.         buildLinkRootList(size);  
38.         for(int i=0;i<size;i++){  
39.             int preNodeId=i;  
40.                     setNextLinkNodeId(null);  
41.                     int localNodeId=i;  
42.                     int totalBandwidth=i;  
43.                     addLinkNode( i, i+1,i,i,i);  
44.         }  
45.           
46.         for(int i=0;i<size;i++){  
47.             System.out.println(LinkRoot.get(i).getLocalNodeId()+"其临接链表是"+LinkRoot.get(i).getNextLinkNode().getLocalNodeId());  
48.         }  
49.     }  
50.       
51.       
52.       
53.       
54.       
55.       
56.     //这个方法是添加根节点的方法  
57.     public void addNode(int total,int consumptionNodeId,LinkNode nextLinkNodeId,int bandwidthRequirement){  
58.         int totalConsumptionNode = 0;  
59.           
60.         for(int i=0;i<totalConsumptionNode;i++){  
61.             consumptionNode e=new consumptionNode(consumptionNodeId, nextLinkNodeId, bandwidthRequirement);  
62.             root.add(e);  
63.         }  
64.               
65.     }  
66.     public void addNode(int consumptionNodeId,LinkNode nextLinkNodeId,int bandwidthRequirement){  
67.             consumptionNode e=new consumptionNode(consumptionNodeId, nextLinkNodeId, bandwidthRequirement);  
68.             root.add(e);  
69.                   
70.     }  
71.     //返回root的制定元素  
72.     public consumptionNode returnNode(int i){   
73.         return this.root.get(i);  
74.           
75.     }  
76.       
77.       
78.       
79.     //添加网络节点根节点的方法  
80.     public void addRootLinkNode(int i){  
81.         rootLinkNode e=new rootLinkNode(i,null);  
82.         LinkRoot.add(e);  
83.     }  
84.       
85.   
86.       
87.       
88.       
89.       
90.     //这个方法用于创建临接表表头节点  
91.     public void buildLinkRootList(int size){  
92.         for(int i=0;i<size;i++){  
93.             rootLinkNode rln=new rootLinkNode(i,null);  
94.             LinkRoot.add(rln);  
95.               
96.         }  
97.           
98.     }  
99.       
100.       
101.       
102.       
103.       
104.       
105.       
106.     //这个方法是添加临接点的方法  
107.     public void addLinkNode(int preNodeId,int localNodeId,int totalBandwidth,int nextNodeId,int unitRentalCost){  
108.         int addPreId=localNodeId;  
109.         LinkNode nextLinkNode=new LinkNode(addPreId,nextNodeId,1000,null,1);//  
110.         LinkNode LN=new LinkNode( preNodeId,localNodeId,totalBandwidth,nextLinkNode,unitRentalCost);  
111.         LinkRoot.get(preNodeId).setNextLinkNodeForRoot(LN);  
112.           
113.     }  
114.   
115.   
116.   
117.   
118.   
119.   
120.     public int getConsumptionNodeId() {  
121.         return consumptionNodeId;  
122.     }  
123.   
124.   
125.   
126.   
127.   
128.   
129.     public void setConsumptionNodeId(int consumptionNodeId) {  
130.         this.consumptionNodeId = consumptionNodeId;  
131.     }  
132.   
133.   
134.   
135.   
136.   
137.   
138.     public LinkNode getNextLinkNodeId() {  
139.         return nextLinkNodeId;  
140.     }  
141.   
142.   
143.   
144.   
145.   
146.   
147.     public void setNextLinkNodeId(LinkNode nextLinkNodeId) {  
148.         this.nextLinkNodeId = nextLinkNodeId;  
149.     }  
150.   
151.   
152.   
153.   
154.   
155.   
156.     public int getBandwidthRequirement() {  
157.         return bandwidthRequirement;  
158.     }  
159.   
160.   
161.   
162.   
163.   
164.   
165.     public void setBandwidthRequirement(int bandwidthRequirement) {  
166.         this.bandwidthRequirement = bandwidthRequirement;  
167.     }  
168.       
169.       
170.       
171.       
172.       
173.     public List<consumptionNode> getroot() {  
174.         return this.root;  
175.     }  
176.   
177.   
178.   
179.   
180.   
181.   
182.       
183.   
184.   
185. }  

import java.util.LinkedList;
import java.util.List;

public class Graphs {
	
	List<consumptionNode> root=new LinkedList<>();
	List<rootLinkNode> LinkRoot=new LinkedList<>();
	private int consumptionNodeId;//消费节点id,用于确定哪一个消费节点
	private LinkNode nextLinkNodeId;//链路节点id，用于确定哪一个链路节点
	private int bandwidthRequirement;//定义一个参数保存贷款需求

	
	
	//text测试用例
	//public void getinfo(){
	//	int num=5;
	//	for(int i=0;i<num;i++){
	//		consumptionNodeId=i;
	//		nextLinkNodeId=null;
	//		bandwidthRequirement=i;
	//		addNode( consumptionNodeId, nextLinkNodeId, bandwidthRequirement);
	//	}
	//	for(int i=0;i<num;i++){
	//		int m=root.get(i).getConsumptionNodeId();
	//		System.out.println();
	//		
	//	}
	//	
	//}
	
	
	
	
	//text2
	public void getInfo2(){
		int size=5;
		buildLinkRootList(size);
		for(int i=0;i<size;i++){
			int preNodeId=i;
					setNextLinkNodeId(null);
					int localNodeId=i;
					int totalBandwidth=i;
					addLinkNode( i, i+1,i,i,i);
		}
		
		for(int i=0;i<size;i++){
			System.out.println(LinkRoot.get(i).getLocalNodeId()+"其临接链表是"+LinkRoot.get(i).getNextLinkNode().getLocalNodeId());
		}
	}
	
	
	
	
	
	
	//这个方法是添加根节点的方法
	public void addNode(int total,int consumptionNodeId,LinkNode nextLinkNodeId,int bandwidthRequirement){
		int totalConsumptionNode = 0;
		
		for(int i=0;i<totalConsumptionNode;i++){
			consumptionNode e=new consumptionNode(consumptionNodeId, nextLinkNodeId, bandwidthRequirement);
			root.add(e);
		}
			
	}
	public void addNode(int consumptionNodeId,LinkNode nextLinkNodeId,int bandwidthRequirement){
			consumptionNode e=new consumptionNode(consumptionNodeId, nextLinkNodeId, bandwidthRequirement);
			root.add(e);
				
	}
	//返回root的制定元素
	public consumptionNode returnNode(int i){ 
		return this.root.get(i);
		
	}
	
	
	
	//添加网络节点根节点的方法
	public void addRootLinkNode(int i){
		rootLinkNode e=new rootLinkNode(i,null);
		LinkRoot.add(e);
	}
	

	
	
	
	
	//这个方法用于创建临接表表头节点
	public void buildLinkRootList(int size){
		for(int i=0;i<size;i++){
			rootLinkNode rln=new rootLinkNode(i,null);
			LinkRoot.add(rln);
			
		}
		
	}
	
	
	
	
	
	
	
	//这个方法是添加临接点的方法
	public void addLinkNode(int preNodeId,int localNodeId,int totalBandwidth,int nextNodeId,int unitRentalCost){
		int addPreId=localNodeId;
		LinkNode nextLinkNode=new LinkNode(addPreId,nextNodeId,1000,null,1);//
		LinkNode LN=new LinkNode( preNodeId,localNodeId,totalBandwidth,nextLinkNode,unitRentalCost);
		LinkRoot.get(preNodeId).setNextLinkNodeForRoot(LN);
		
	}






	public int getConsumptionNodeId() {
		return consumptionNodeId;
	}






	public void setConsumptionNodeId(int consumptionNodeId) {
		this.consumptionNodeId = consumptionNodeId;
	}






	public LinkNode getNextLinkNodeId() {
		return nextLinkNodeId;
	}






	public void setNextLinkNodeId(LinkNode nextLinkNodeId) {
		this.nextLinkNodeId = nextLinkNodeId;
	}






	public int getBandwidthRequirement() {
		return bandwidthRequirement;
	}






	public void setBandwidthRequirement(int bandwidthRequirement) {
		this.bandwidthRequirement = bandwidthRequirement;
	}
	
	
	
	
	
	public List<consumptionNode> getroot() {
		return this.root;
	}






	


}

[java] view plain copy print ?

1. public class LinkNode {  
2.     private int localNodeId;  
3.     private int totalBandwidth;  
4.     private int upBandwidth;  
5.     private int downBandwidth;  
6.     private LinkNode nextLinkNode;  
7.     private int preNodeId;  
8.     private int unitRentalCost;  
9.     //所有链路节点的preNodeId保存为链路根节点  
10.     public LinkNode(int preNodeId,int localNodeId,int totalBandwidth,LinkNode nextLinkNode,int unitRentalCost){  
11.         this.localNodeId=localNodeId;  
12.         this.preNodeId=preNodeId;  
13.         this.totalBandwidth=totalBandwidth;  
14.         this.upBandwidth=totalBandwidth;  
15.         this.downBandwidth=totalBandwidth;  
16.         this.setNextLinkNode(nextLinkNode);  
17.         this.unitRentalCost=unitRentalCost;  
18.           
19.     }  
20.       
21.       
22.       
23.       
24.       
25.       
26.     public int getLocalNodeId() {  
27.         return localNodeId;  
28.     }  
29.     public void setLocalNodeId(int localNodeId) {  
30.         this.localNodeId = localNodeId;  
31.     }  
32.     public int getTotalBandwidth() {  
33.         return totalBandwidth;  
34.     }  
35.     public void setTotalBandwidth(int totalBandwidth) {  
36.         this.totalBandwidth = totalBandwidth;  
37.     }  
38.     public int getUpBandwidth() {  
39.         return upBandwidth;  
40.     }  
41.     public void setUpBandwidth(int upBandwidth) {  
42.         this.upBandwidth = upBandwidth;  
43.     }  
44.     public int getDownBandwidth() {  
45.         return downBandwidth;  
46.     }  
47.     public void setDownBandwidth(int downBandwidth) {  
48.         this.downBandwidth = downBandwidth;  
49.     }  
50.     public LinkNode getNextLinkNode() {  
51.         return nextLinkNode;  
52.     }  
53.     public void setNextLinkNode(LinkNode nextLinkNode) {  
54.         this.nextLinkNode = nextLinkNode;  
55.     }  
56.   
57.   
58.   
59.   
60.   
61.   
62.     public int getPreNodeId() {  
63.         return preNodeId;  
64.     }  
65.   
66.   
67.   
68.   
69.   
70.   
71.     public void setPreNodeId(int preNodeId) {  
72.         this.preNodeId = preNodeId;  
73.     }  
74.   
75. }  

public class LinkNode {
	private int localNodeId;
	private int totalBandwidth;
	private int upBandwidth;
	private int downBandwidth;
	private LinkNode nextLinkNode;
	private int preNodeId;
	private int unitRentalCost;
	//所有链路节点的preNodeId保存为链路根节点
	public LinkNode(int preNodeId,int localNodeId,int totalBandwidth,LinkNode nextLinkNode,int unitRentalCost){
		this.localNodeId=localNodeId;
		this.preNodeId=preNodeId;
		this.totalBandwidth=totalBandwidth;
		this.upBandwidth=totalBandwidth;
		this.downBandwidth=totalBandwidth;
		this.setNextLinkNode(nextLinkNode);
		this.unitRentalCost=unitRentalCost;
		
	}
	
	
	
	
	
	
	public int getLocalNodeId() {
		return localNodeId;
	}
	public void setLocalNodeId(int localNodeId) {
		this.localNodeId = localNodeId;
	}
	public int getTotalBandwidth() {
		return totalBandwidth;
	}
	public void setTotalBandwidth(int totalBandwidth) {
		this.totalBandwidth = totalBandwidth;
	}
	public int getUpBandwidth() {
		return upBandwidth;
	}
	public void setUpBandwidth(int upBandwidth) {
		this.upBandwidth = upBandwidth;
	}
	public int getDownBandwidth() {
		return downBandwidth;
	}
	public void setDownBandwidth(int downBandwidth) {
		this.downBandwidth = downBandwidth;
	}
	public LinkNode getNextLinkNode() {
		return nextLinkNode;
	}
	public void setNextLinkNode(LinkNode nextLinkNode) {
		this.nextLinkNode = nextLinkNode;
	}






	public int getPreNodeId() {
		return preNodeId;
	}






	public void setPreNodeId(int preNodeId) {
		this.preNodeId = preNodeId;
	}

}

[java] view plain copy print ?

1. public class LLNode {  
2.     private int data;  
3.     private LLNode nextNode;  
4.     public LLNode(int data,LLNode nextNode){  
5.         this.setDataForLLNode(data);  
6.         this.setNextNodeForLLNode(nextNode);          
7.     }  
8.     public LLNode(int data){  
9.         this.data=data;  
10.         this.nextNode=null;  
11.           
12.     }  
13.     public int getDataForLLNode() {  
14.         return data;  
15.     }  
16.     public void setDataForLLNode(int data) {  
17.         this.data = data;  
18.     }  
19.     public LLNode getNextNodeForLLNode() {  
20.         return nextNode;  
21.     }  
22.     public void setNextNodeForLLNode(LLNode nextNode) {  
23.         this.nextNode = nextNode;  
24.     }  
25. }  

public class LLNode {
	private int data;
	private LLNode nextNode;
	public LLNode(int data,LLNode nextNode){
		this.setDataForLLNode(data);
		this.setNextNodeForLLNode(nextNode);		
	}
	public LLNode(int data){
		this.data=data;
		this.nextNode=null;
		
	}
	public int getDataForLLNode() {
		return data;
	}
	public void setDataForLLNode(int data) {
		this.data = data;
	}
	public LLNode getNextNodeForLLNode() {
		return nextNode;
	}
	public void setNextNodeForLLNode(LLNode nextNode) {
		this.nextNode = nextNode;
	}
}

[java] view plain copy print ?

1. public class LLQueue {  
2.     private LLNode frontNode;  
3.     private LLNode rearNode;  
4.     public LLQueue(){  
5.         this.setFrontNode(null);  
6.         this.setRearNode(null);  
7.     }  
8.     private LLQueue(LLNode frontNode,LLNode rearNode){  
9.         this.setFrontNode(frontNode);  
10.         this.setRearNode(rearNode);  
11.           
12.     }  
13.     public LLNode getFrontNode() {  
14.         return frontNode;  
15.     }  
16.     public void setFrontNode(LLNode frontNode) {  
17.         this.frontNode = frontNode;  
18.     }  
19.     public LLNode getRearNode() {  
20.         return rearNode;  
21.     }  
22.     public void setRearNode(LLNode rearNode) {  
23.         this.rearNode = rearNode;  
24.     }  
25.     public static LLQueue createQueue(){  
26.         return new LLQueue();  
27.     }  
28.     public boolean isEmpty(){  
29.         return (frontNode==null);  
30.         //为空则返回1，不为空返回0  
31.     }  
32.     public void enQueue(int data){  
33.         LLNode newNode=new LLNode(data);  
34.         if(rearNode!=null){  
35.             rearNode.setNextNodeForLLNode(newNode);  
36.         }  
37.         rearNode=newNode;  
38.         if(frontNode==null){  
39.             frontNode=newNode;  
40.         }  
41.     }  
42.     public int deQueue(){  
43.         int data;//int 类型不能赋值为null  
44.         if(isEmpty()){  
45.             System.out.println("这个队列是空的");    
46.             return -1;  
47.         }else{  
48.             data=frontNode.getDataForLLNode();  
49.             frontNode=frontNode.getNextNodeForLLNode();  
50.         }  
51.         return data;  
52.     }  
53. }  

public class LLQueue {
	private LLNode frontNode;
	private LLNode rearNode;
	public LLQueue(){
		this.setFrontNode(null);
		this.setRearNode(null);
	}
	private LLQueue(LLNode frontNode,LLNode rearNode){
		this.setFrontNode(frontNode);
		this.setRearNode(rearNode);
		
	}
	public LLNode getFrontNode() {
		return frontNode;
	}
	public void setFrontNode(LLNode frontNode) {
		this.frontNode = frontNode;
	}
	public LLNode getRearNode() {
		return rearNode;
	}
	public void setRearNode(LLNode rearNode) {
		this.rearNode = rearNode;
	}
	public static LLQueue createQueue(){
		return new LLQueue();
	}
	public boolean isEmpty(){
		return (frontNode==null);
		//为空则返回1，不为空返回0
	}
	public void enQueue(int data){
		LLNode newNode=new LLNode(data);
		if(rearNode!=null){
			rearNode.setNextNodeForLLNode(newNode);
		}
		rearNode=newNode;
		if(frontNode==null){
			frontNode=newNode;
		}
	}
	public int deQueue(){
		int data;//int 类型不能赋值为null
		if(isEmpty()){
			System.out.println("这个队列是空的");	
			return -1;
		}else{
			data=frontNode.getDataForLLNode();
			frontNode=frontNode.getNextNodeForLLNode();
		}
		return data;
	}
}

[java] view plain copy print ?

1. //public class Miracle2 {  
2.   
3. //}  
4. import java.util.Collection;  
5. import java.util.LinkedHashMap;  
6. import java.util.LinkedList;  
7. import java.util.List;  
8. import java.util.Map;  
9. import java.util.Queue;  
10.   
11.  /* 
12.   * 求解无向图的单源最短路径 
13.   */  
14.  public class Miracle2 {  
15.        
16.        
17.       
18.        
19.        
20.       
21.      public class Vertex{//这个方法定义顶点的基本属性  
22.            
23.            
24.            
25.            
26.            
27.            
28.          private String vertexLabel;//顶点标识  
29.          private List<Edge> adjEdges;//与该顶点邻接的边(点)，每一个Vertex里都有一个链表存储其边  
30.          private int dist;//顶点距离(该顶点到起始顶点的距离)  
31.          private Vertex preNode;//顶点的前顶点  
32.          //构造一个实例  
33.          public Vertex(String vertexLabel) {  
34.              this.vertexLabel = vertexLabel;  
35.              adjEdges = new LinkedList<>();  
36.             dist = Integer.MAX_VALUE;//为距离设置为最大值  
37.              preNode = null;  
38.          }  
39.      }  
40.      private class Edge{//边由顶点决定  
41.          private Vertex endVertex;  
42.          //构造实例  
43.          public Edge(Vertex endVertex) {  
44.              this.endVertex = endVertex;  
45.          }  
46.      }  
47.        
48.      private Map<String, Vertex> nonDirectedGraph;//保存了图中所有的顶点，边的关系以List形式保存在Vertex类中，通  
49.     // 过键值对保存未处理顶点  
50.      private Vertex startVertex;//图的起始顶点  
51.        
52.      public Miracle2(String graphContent) {//定义一个构造方法  
53.          nonDirectedGraph = new LinkedHashMap<>();  
54.          buildGraph(graphContent);  
55.      }  
56.        
57.      private  void buildGraph(String graphContent){//通过传进来的内容构造图  
58.          String[] lines = graphContent.split("\n");  
59.            
60.          String startNodeLabel, endNodeLabel;  
61.          Vertex startNode, endNode;  
62.            
63.   
64.                    
65.          //以上是变量的定义  
66.          for(int i = 0; i < lines.length; i++){  
67.              String[] nodesInfo = lines[i].split(",");  
68.              startNodeLabel = nodesInfo[1];  
69.              endNodeLabel = nodesInfo[2];  
70.                
71.              endNode = nonDirectedGraph.get(endNodeLabel);  
72.              if(endNode == null){  
73.                  endNode = new Vertex(endNodeLabel);  
74.                  nonDirectedGraph.put(endNodeLabel, endNode);  
75.              }  
76.                
77.              startNode = nonDirectedGraph.get(startNodeLabel);//从键值对获得标签  
78.              if(startNode == null){  
79.                  startNode = new Vertex(startNodeLabel);  
80.                  nonDirectedGraph.put(startNodeLabel, startNode);  
81.              }  
82.              Edge e = new Edge(endNode);  
83.              //对于无向图而言,起点和终点都要添加边  
84.              endNode.adjEdges.add(e);  
85.              startNode.adjEdges.add(e);  
86.          }  
87.          startVertex = nonDirectedGraph.get(lines[0].split(",")[1]);//总是以文件中第一行第二列的那个标识顶点作为源点  
88.      }  
89.        
90.      public void unweightedShortestPath(){  
91.          unweightedShortestPath(startVertex);  
92.      }  
93.       
94.        
95.      /* 
96.       *  
97.       * 需要一个队列来保存图中的顶点,初始时,源点入队列,然后以广度的形式向外扩散求解其他顶点的最短路径 
98.       */  
99.      private void unweightedShortestPath(Vertex s){//该方法计算原点s到无向图各个顶点的最短路径  
100.          //初始化  
101.          Queue<Vertex> queue = new LinkedList<>();//用队列存储各个点  
102.          s.dist = 0;  
103.          queue.offer(s);//将源点dist设置为0并入队列，offer用于添加元素入数列  
104.            
105.          while(!queue.isEmpty()){  
106.              Vertex v = queue.poll();//检索并删除队列的头  
107.              for (Edge e : v.adjEdges) {//扫描v的邻接边(点)  
108.                  if(e.endVertex.dist == Integer.MAX_VALUE){//如果这个顶点(e.endVertex)未被访问(每个顶点只会入队列一次)  
109.                      e.endVertex.dist = v.dist + 1;//更新该顶点到源点的距离  
110.                      queue.offer(e.endVertex);//将顶点放入队列，准备进行下一次换原电遍历  
111.                      e.endVertex.preNode = v;//设置该顶点的前驱顶点  
112.                  }//end if  
113.              }//end for           
114.              }//end while  
115.      }  
116.        
117.      //打印图中所有顶点到源点的距离及路径  
118.      public  void showDistance(){  
119.          Collection<Vertex> vertexs = nonDirectedGraph.values();//collection是创建一个存储元素的容器  
120.          for (Vertex vertex : vertexs) {  
121.              System.out.print(vertex.vertexLabel + "<--");  
122.              Vertex tmpPreNode = vertex.preNode;  
123.              while(tmpPreNode != null){  
124.                 System.out.print(tmpPreNode.vertexLabel + "<--");  
125.                  tmpPreNode = tmpPreNode.preNode;  
126.              }  
127.              System.out.println("distance=" + vertex.dist);  
128.          }  
129.      }  
130. }  

//public class Miracle2 {

//}
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;

 /*
  * 求解无向图的单源最短路径
  */
 public class Miracle2 {
	 
	 
	
	 
	 
	
     public class Vertex{//这个方法定义顶点的基本属性
    	 
    	 
    	 
    	 
    	 
    	 
         private String vertexLabel;//顶点标识
         private List<Edge> adjEdges;//与该顶点邻接的边(点)，每一个Vertex里都有一个链表存储其边
         private int dist;//顶点距离(该顶点到起始顶点的距离)
         private Vertex preNode;//顶点的前顶点
         //构造一个实例
         public Vertex(String vertexLabel) {
             this.vertexLabel = vertexLabel;
             adjEdges = new LinkedList<>();
            dist = Integer.MAX_VALUE;//为距离设置为最大值
             preNode = null;
         }
     }
     private class Edge{//边由顶点决定
         private Vertex endVertex;
         //构造实例
         public Edge(Vertex endVertex) {
             this.endVertex = endVertex;
         }
     }
     
     private Map<String, Vertex> nonDirectedGraph;//保存了图中所有的顶点，边的关系以List形式保存在Vertex类中，通
    // 过键值对保存未处理顶点
     private Vertex startVertex;//图的起始顶点
     
     public Miracle2(String graphContent) {//定义一个构造方法
         nonDirectedGraph = new LinkedHashMap<>();
         buildGraph(graphContent);
     }
     
     private  void buildGraph(String graphContent){//通过传进来的内容构造图
         String[] lines = graphContent.split("\n");
         
         String startNodeLabel, endNodeLabel;
         Vertex startNode, endNode;
         

        		 
         //以上是变量的定义
         for(int i = 0; i < lines.length; i++){
             String[] nodesInfo = lines[i].split(",");
             startNodeLabel = nodesInfo[1];
             endNodeLabel = nodesInfo[2];
             
             endNode = nonDirectedGraph.get(endNodeLabel);
             if(endNode == null){
                 endNode = new Vertex(endNodeLabel);
                 nonDirectedGraph.put(endNodeLabel, endNode);
             }
             
             startNode = nonDirectedGraph.get(startNodeLabel);//从键值对获得标签
             if(startNode == null){
                 startNode = new Vertex(startNodeLabel);
                 nonDirectedGraph.put(startNodeLabel, startNode);
             }
             Edge e = new Edge(endNode);
             //对于无向图而言,起点和终点都要添加边
             endNode.adjEdges.add(e);
             startNode.adjEdges.add(e);
         }
         startVertex = nonDirectedGraph.get(lines[0].split(",")[1]);//总是以文件中第一行第二列的那个标识顶点作为源点
     }
     
     public void unweightedShortestPath(){
         unweightedShortestPath(startVertex);
     }
    
     
     /*
      * 
      * 需要一个队列来保存图中的顶点,初始时,源点入队列,然后以广度的形式向外扩散求解其他顶点的最短路径
      */
     private void unweightedShortestPath(Vertex s){//该方法计算原点s到无向图各个顶点的最短路径
         //初始化
         Queue<Vertex> queue = new LinkedList<>();//用队列存储各个点
         s.dist = 0;
         queue.offer(s);//将源点dist设置为0并入队列，offer用于添加元素入数列
         
         while(!queue.isEmpty()){
             Vertex v = queue.poll();//检索并删除队列的头
             for (Edge e : v.adjEdges) {//扫描v的邻接边(点)
                 if(e.endVertex.dist == Integer.MAX_VALUE){//如果这个顶点(e.endVertex)未被访问(每个顶点只会入队列一次)
                     e.endVertex.dist = v.dist + 1;//更新该顶点到源点的距离
                     queue.offer(e.endVertex);//将顶点放入队列，准备进行下一次换原电遍历
                     e.endVertex.preNode = v;//设置该顶点的前驱顶点
                 }//end if
             }//end for         
             }//end while
     }
     
     //打印图中所有顶点到源点的距离及路径
     public  void showDistance(){
         Collection<Vertex> vertexs = nonDirectedGraph.values();//collection是创建一个存储元素的容器
         for (Vertex vertex : vertexs) {
             System.out.print(vertex.vertexLabel + "<--");
             Vertex tmpPreNode = vertex.preNode;
             while(tmpPreNode != null){
                System.out.print(tmpPreNode.vertexLabel + "<--");
                 tmpPreNode = tmpPreNode.preNode;
             }
             System.out.println("distance=" + vertex.dist);
         }
     }
}

[java] view plain copy print ?

1. public class rootLinkNode {  
2.     private int localNodeId;  
3.     private LinkNode nextLinkNode;  
4.     public rootLinkNode(int localNodeId,LinkNode nextLinkNode){  
5.         this.setLocalNodeId(localNodeId);  
6.         this.setNextLinkNodeForRoot(nextLinkNode);  
7.           
8.     }  
9. //public addRootLinkNode(i){  
10. //      }  
11.     public LinkNode getNextLinkNode() {  
12.         return nextLinkNode;  
13.     }  
14.     public void setNextLinkNodeForRoot(LinkNode nextLinkNode4) {  
15.         //this.nextLinkNode = nextLinkNode;  
16.         if(this.nextLinkNode==null){  
17.             this.nextLinkNode = nextLinkNode4;  
18.         }else{  
19.         LinkNode temp=this.nextLinkNode;  
20.         while(temp.getNextLinkNode()!=null){  
21.             temp=temp.getNextLinkNode();  
22.               
23.         }  
24.         temp.setNextLinkNode(nextLinkNode4);}  
25.     }  
26.     public int getLocalNodeId() {  
27.         return localNodeId;  
28.     }  
29.     public void setLocalNodeId(int localNodeId) {  
30.         this.localNodeId = localNodeId;  
31.     }  
32. }  

public class rootLinkNode {
	private int localNodeId;
	private LinkNode nextLinkNode;
	public rootLinkNode(int localNodeId,LinkNode nextLinkNode){
		this.setLocalNodeId(localNodeId);
		this.setNextLinkNodeForRoot(nextLinkNode);
		
	}
//public addRootLinkNode(i){
//		}
	public LinkNode getNextLinkNode() {
		return nextLinkNode;
	}
	public void setNextLinkNodeForRoot(LinkNode nextLinkNode4) {
		//this.nextLinkNode = nextLinkNode;
		if(this.nextLinkNode==null){
			this.nextLinkNode = nextLinkNode4;
		}else{
		LinkNode temp=this.nextLinkNode;
		while(temp.getNextLinkNode()!=null){
			temp=temp.getNextLinkNode();
			
		}
		temp.setNextLinkNode(nextLinkNode4);}
	}
	public int getLocalNodeId() {
		return localNodeId;
	}
	public void setLocalNodeId(int localNodeId) {
		this.localNodeId = localNodeId;
	}
}

[java] view plain copy print ?

1. import java.util.HashMap;  
2. import java.util.LinkedList;  
3. import java.util.List;  
4. import java.util.Map;  
5.   
6. public class run {  
7.     public static void main(String[] args){  
8.         FileUtil fu=new FileUtil();  
9.         //String filePath="D:\\info.txt";  
10.     //  final int spec=4;  
11.           
12.         //String[] infos=fu.read(filePath, spec);  
13.           
14.         //int size=infos.length;  
15.         //String info = null;  
16.         //String infoOut=null;  
17.         //for(int i=0;i<size;i++){  
18.         //   info=infos[i];  
19.         //  System.out.println(info);  
20.         //    infoOut=infoOut+info+"\r";  
21.         //    
22.     //  }  
23.           
24.         //Miracle2 mi =new Miracle2(infoOut);  
25.         //mi.showDistance();  
26.           
27.           
28.         //String info3="789\n123";  
29.         //System.out.println(info3);  
30.           
31.           
32.           
33.           
34.         int serverDeploymentCost;//服务器部署成本  
35.         int numOfConsumptionNode;//消费节点数量  
36.         int numOfNetworkLink;//网络链路数量  
37.         int numOfLinkNode;//链路节点数量  
38.           
39.         Graphs g=new Graphs();  
40.         //g.getInfo2();  
41.         String filePath2="D:\\case0.txt";  
42.         int spec =3;  
43.         String[] infos=fu.read(filePath2, spec);  
44. //      for(int i=0;i<spec;i++){  
45. //          System.out.println(infos[i]);  
46. //      }  
47.         String temp=infos[0];  
48.         System.out.println(temp);  
49.           
50.           
51.           
52.           
53.         //text3测试按空格分开是否有误  
54.         String[] splitTemp=temp.split("\\s");  
55. //      for(int i=0;i<3;i++){//当i=3时是0,1,2行被选中  
56. //          System.out.println(splitTemp[i]);  
57. //      }  
58.         numOfConsumptionNode=Integer.parseInt(splitTemp[2]);  
59.         numOfNetworkLink=Integer.parseInt(splitTemp[1]);  
60.         numOfLinkNode=Integer.parseInt(splitTemp[0]);  
61.         serverDeploymentCost=Integer.parseInt(infos[2]);  
62.         //28个网络节点，45条链路，12个消费节点  
63.           
64.           
65.           
66.           
67.         //System.out.println(numOfConsumptionNode);  
68.         //System.out.println(numOfNetworkLink);  
69.         //System.out.println(numOfLinkNode);  
70.           
71.         //计算需要的总共需要的spec  
72.         spec=5+numOfNetworkLink+numOfConsumptionNode;  
73.         String[] finalinfos=fu.read(filePath2, spec);  
74.         //计算读取链路数需要的开始和结束行  
75.         //第几行-1就是所需行号  
76.         int startNumOfLink=4;  
77.         int endNumOfLink=4+numOfNetworkLink-1;  
78.         //计算读取消费节点数需要的开始和结束行  
79.         int startNumOfConsumptionNode=endNumOfLink+2;  
80.         int endNumOfConsumptionNode=startNumOfConsumptionNode+numOfConsumptionNode-1;  
81.           
82.           
83.         System.out.println(endNumOfConsumptionNode);  
84.           
85.         //先存储消费节点，下面是为消费节点赋值并创建的代码  
86.           
87.         for(int i=startNumOfConsumptionNode;i<endNumOfConsumptionNode+1;i++){  
88.             String temp2=finalinfos[i];  
89.         String[]    consumptiontemp=temp2.split("\\s");  
90.         //int i=startNumOfConsumptionNode;    
91.         //consumptiontemp=finalinfos[i].split("\\s");  
92.               
93.               
94.               
95.             int consumptionNodeId=Integer.parseInt(consumptiontemp[0]);//消费节点id,用于确定哪一个消费节点  
96.             LinkNode nextLinkNodeId=new LinkNode(i, Integer.parseInt(consumptiontemp[1]), 1000, null,0);//链路节点id，用于确定哪一个链路节点  
97.             //Integer.parseInt(consumptiontemp[1])  
98.             int bandwidthRequirement=Integer.parseInt(consumptiontemp[2]);//定义一个参数保存贷款需求  
99.               
100.               
101.               
102.             //消费节点0，相连网络节点ID为8，视频带宽消耗需求为40   
103.               
104.               
105.               
106.               
107.             //原打算在这里新建添加消费节点的方法，但是该方  
108.             //法应存在与图中，应直接从图调用  
109.             //List<consumptionNode> runroot=g.getroot();  
110.             //consumptionNode e=new consumptionNode(consumptionNodeId,nextLinkNodeId,bandwidthRequirement);  
111.             //runroot.add<>;  
112.               
113.               
114.               
115.             //从上图获得的参数构建消费节点链表  
116.             g.addNode(consumptionNodeId, nextLinkNodeId, bandwidthRequirement);  
117.         }  
118.           
119.         //test  
120. //      for(int i=0;i<numOfConsumptionNode;i++){  
121. //            
122. //          System.out.println(g.returnNode(i).getConsumptionNodeId());  
123. //          System.out.println(g.returnNode(i).getNextLinkNodeId().getLocalNodeId());  
124. //          System.out.println(g.returnNode(i).getBandwidthRequirement());  
125. //            
126. //      }  
127.           
128.           
129.           
130.           
131.           
132.           
133.         //添加链路头结点的方法  
134.         //numOfLinkNode网络链路节点数量  
135.         int localNodeId;  
136.         LinkNode nextLinkNode;  
137.         for(int i=0;i<numOfLinkNode;i++){  
138.             //rootLinkNode(i,null);  
139.             g.addRootLinkNode(i);  
140.         }  
141.          //System.out.println("下面是测试链路头结点程序");  
142.         //System.out.println(numOfLinkNode);  
143.         //for(int i=0;i<50;i++){  
144.         //  System.out.println(g.LinkRoot.get(i).getLocalNodeId());  
145.         //}  
146.           
147.           
148.           
149.         //添加链路节点的方法  
150.           
151.          //for(int i=startNumOfLink;i<endNumOfConsumptionNode+1;i++){  
152.         for(int i=startNumOfLink;i<endNumOfLink;i++){  
153.             //定义链路节点基本元素  
154.             int lnlocalNodeId;  
155.             int lntotalBandwidth;  
156.             LinkNode lnnextLinkNode;  
157.             int lnpreNodeId;  
158.             int lnunitRentalCost;  
159.             String temp3=finalinfos[i];  
160.             String[] consumptiontemp=temp3.split("\\s");  
161.             lnpreNodeId=Integer.parseInt(consumptiontemp[0]);  
162.             lnlocalNodeId=Integer.parseInt(consumptiontemp[1]);  
163.             lntotalBandwidth=Integer.parseInt(consumptiontemp[2]);  
164.             lnunitRentalCost=Integer.parseInt(consumptiontemp[3]);  
165.             //新建节点之后加进去  
166.             lnnextLinkNode=new LinkNode(lnpreNodeId, lnlocalNodeId, lntotalBandwidth, null, lnunitRentalCost);  
167.             LinkNode reverseLnnextLinkNode;  
168.             reverseLnnextLinkNode=new LinkNode(lnlocalNodeId, lnpreNodeId, lntotalBandwidth, null, lnunitRentalCost);  
169.             if(g.LinkRoot.get(lnpreNodeId).getNextLinkNode()==null){  
170.                 g.LinkRoot.get(lnpreNodeId).setNextLinkNodeForRoot(lnnextLinkNode);  
171.             }else{  
172.                  LinkNode temp4=g.LinkRoot.get(lnpreNodeId).getNextLinkNode();  
173.                  LinkNode temp5=g.LinkRoot.get(lnpreNodeId).getNextLinkNode();  
174.                     while(temp4!=null&&temp4.getLocalNodeId()!=lnlocalNodeId){  
175.                         temp5=temp4;  
176.                         temp4=temp4.getNextLinkNode();  
177.                       
178.                     }  
179.                     //if(temp4==null){if(temp4.getLocalNodeId()!=lnlocalNodeId)  
180.                     if(temp4==null){  
181.                         temp5.setNextLinkNode(lnnextLinkNode);  
182.                         //g.LinkRoot.get(lnpreNodeId).setNextLinkNodeForRoot(lnnextLinkNode);  
183.                     }  
184.                       
185.             }  
186.               
187.               
188.             //反向代码  
189.             if(g.LinkRoot.get(lnlocalNodeId).getNextLinkNode()==null){  
190.                 g.LinkRoot.get(lnlocalNodeId).setNextLinkNodeForRoot(reverseLnnextLinkNode);  
191.             }else{  
192.                  LinkNode temp4=g.LinkRoot.get(lnlocalNodeId).getNextLinkNode();  
193.                  LinkNode temp5=g.LinkRoot.get(lnlocalNodeId).getNextLinkNode();  
194.                     while(temp4!=null&&temp4.getLocalNodeId()!=lnpreNodeId){  
195.                         temp5=temp4;  
196.                         temp4=temp4.getNextLinkNode();  
197.                       
198.                     }  
199.                     if(temp4==null){  
200.                         g.LinkRoot.get(lnlocalNodeId).setNextLinkNodeForRoot(reverseLnnextLinkNode);  
201.                     }  
202.                       
203.             }  
204.              
205.             //g.LinkRoot.get(lnpreNodeId).setNextLinkNodeForRoot(lnnextLinkNode);  
206.             //LinkNode temp4=g.LinkRoot.get(lnpreNodeId).getNextLinkNode();  
207.            // while(){  
208.                   
209.           //  }  
210.           
211.         }  
212.           
213.         //这里起始节点命名为preNodeId  
214.         //链路起始节点为0，链路终止节点为16 ，总带宽为8，单位网络租用费为2  
215.           
216. //      System.out.println("下面是测试数据");  
217. //      for(int i =0;i<numOfLinkNode;i++){  
218. //          LinkNode temp6=g.LinkRoot.get(i).getNextLinkNode();  
219. //          System.out.println(temp6.getLocalNodeId());  
220. //      }  
221. //      System.out.println(g.LinkRoot.get(1).getNextLinkNode().getLocalNodeId());  
222.           
223.           
224.         //总测试用例  
225.         //我们已经得到  
226.         //28个网络节点，45条链路，12个消费节点  
227.         //服务器部署成本为100  
228.         //链路节点信息  
229.         //链路起始节点为0，链路终止节点为16 ，总带宽为8，单位网络租用费为2  
230.         //消费节点信息  
231.         //消费节点0，相连网络节点ID为8，视频带宽消耗需求为40   
232.         System.out.printf("有%d个网络节点，%d个链路，%d个消费节点", numOfLinkNode,numOfNetworkLink,numOfConsumptionNode);  
233.           
234.       
235.           
236.         //从消费结点开始遍历，存储在队列中  
237.         //任取一消费节点，检查其是否满足链路带宽等于其需求，满足则开始配对  
238.     int rootSize=g.root.size();  
239.     //System.out.println(rootSize);  
240.     //定义一个集合保存满足单路的结点  
241.     //list<int> singleWayconsumption=new LinkList<>;  
242.       
243.     int destination;  
244.     int countOfSingleWayConsumption=0;  
245.     int[] nextNodeForConsumptionNode=new int[rootSize];  
246.     for(int i=0;i<rootSize;i++){  
247.         //第一个消费节点的第一个链路节点提供的带宽  
248.         int idFornextNodeofConsumptionNode=g.root.get(i).getNextLinkNodeId().getLocalNodeId();  
249.         //System.out.println(idFornextNodeofConsumptionNode);  
250.         nextNodeForConsumptionNode[i]=idFornextNodeofConsumptionNode;  
251.         int firstConsumptionLinkNodeBandWith=g.LinkRoot.get(idFornextNodeofConsumptionNode).getNextLinkNode().getTotalBandwidth();  
252.         //System.out.println(idFornextNodeofConsumptionNode);  
253.     //  int firstConsumptionLinkNodeBandWith=g.root.get(i).getNextLinkNodeId().getNextLinkNode().getTotalBandwidth();  
254.           
255.         if(g.root.get(i).getBandwidthRequirement()<=firstConsumptionLinkNodeBandWith){  
256.             //singleWayConsumption[countOfSingleWayConsumption]=g.root.get(i).getConsumptionNodeId();  
257.               
258.             countOfSingleWayConsumption++;  
259.         }  
260.           
261.           
262. //      //text  
263. //      for(int d=0;d<countOfSingleWayConsumption;d++){  
264. //          System.out.println(singleWayConsumption[d]);  
265. //          }  
266.         }  
267.     int[] singleWayConsumption=new int[countOfSingleWayConsumption] ;  
268.     int countFor2=0;  
269. //  System.out.println(countOfSingleWayConsumption);  
270.       
271.     for(int i=0;i<rootSize;i++){  
272.         //第一个消费节点的第一个链路节点提供的带宽  
273.         //int firstConsumptionLinkNodeBandWith2=g.root.get(c).getNextLinkNodeId().getNextLinkNode().getTotalBandwidth();  
274.         int idFornextNodeofConsumptionNode2=g.root.get(i).getNextLinkNodeId().getLocalNodeId();  
275.         int firstConsumptionLinkNodeBandWith2=g.LinkRoot .get(idFornextNodeofConsumptionNode2).getNextLinkNode().getTotalBandwidth();  
276.           
277.           
278.         if(g.root.get(i).getBandwidthRequirement()<=firstConsumptionLinkNodeBandWith2){  
279.             singleWayConsumption[countFor2]=g.root.get(i).getConsumptionNodeId();  
280.             countFor2++;  
281.             //countOfSingleWayConsumption++;  
282.         }  
283.       
284. }  
285.       
286.     //map.put(1, 5);  
287.     //System.out.println(map.get(1));  
288.     System.out.println("检验这个数是多少");  
289.     System.out.println(countOfSingleWayConsumption);      
290.     searchMatrix matrixForRun=new searchMatrix();  
291.     int[][] a=matrixForRun.createMatrix(numOfLinkNode,numOfLinkNode);  
292.     matrixForRun.assignment(a, numOfLinkNode, numOfLinkNode);  
293.     //定义一个数组记录链路可使用的最大带宽    //开始遍历并保存路径  
294.     //获得所有消费节点的临界点，保存在数组中，进行比较  //int[][] route=null;  
295.     //int[][] route=new int[1000][10];  
296.     //当一个索引=-1时，表示该行遍历结束    //nextNodeForConsumptionNode  
297.     for(int i=0;i<numOfLinkNode;i++){  
298.         a[i][i]=1;  
299.     }  
300.     LLQueue llqueue=new LLQueue();  
301.     //建立一个hashmap存储邻接点为键值，消费节点为value  
302.             Map map=new HashMap<>();  
303.             for(int i=0;i<rootSize;i++){  
304.                 map.put(g.root.get(i).getNextLinkNodeId().getLocalNodeId(), g.root.get(i).getConsumptionNodeId());        
305.             }  
306.           
307.     for(int i=0;i<countOfSingleWayConsumption;i++){  
308.         int thisConsumptionNode=singleWayConsumption[i];  
309.         System.out.println("这是一次遍历");  
310.           
311.         //route[i][0]=thisConsumptionNode;  
312.         llqueue.enQueue(thisConsumptionNode);  
313.         //route[i][0]=1;        //route[i][1]=nextNodeForConsumptionNode[thisConsumptionNode];  
314.         //llqueue.enQueue(nextNodeForConsumptionNode[thisConsumptionNode]);  
315.         llqueue.enQueue(g.root.get(thisConsumptionNode).getNextLinkNodeId().getLocalNodeId());  
316.         //int temp11=nextNodeForConsumptionNode[thisConsumptionNode];  
317.         int temp11=g.root.get(thisConsumptionNode).getNextLinkNodeId().getLocalNodeId();  
318.         System.out.println(thisConsumptionNode);  
319.         System.out.println(temp11);  
320.         //while(g.LinkRoot.get(temp11).getNextLinkNode().getLocalNodeId()!=null){  
321.         levelSearch(temp11,g,nextNodeForConsumptionNode,llqueue,i,a,map);     
322.         //}     //g.LinkRoot.get(temp11).getNextLinkNode()!=null//判断一个节点下一个指向点不为空的语句        //g.LinkRoot.get(temp11).getNextLinkNode().getLocalNodeId()  
323.         //获得下一个节点的id        //compare(g. inkRoot.get(temp11).getNextLinkNode().getLocalNodeId(),nextNodeForConsumptionNode);        //比较其临界点是否有链路直连的临接点的方法  
324.     }  
325.     //int[] route = null;//route[0]=0;//route[1]=1;//route[2]=2;//  System.out.println("测试链表是否为空");//   rootLinkNode temp13=g.LinkRoot.get(1);  
326. //  LinkNode temp14=temp13.getNextLinkNode();// while(temp14!=null){//      System.out.println(temp14.getLocalNodeId());//      temp14=temp14.getNextLinkNode();  
327. //  }// System.out.println("测试结束");   
328.     }  
329.   
330.     public static void levelSearch(int numOfNode,Graphs g,int[] aggregate,LLQueue llqueue,int i,int[][]iswalk,Map map){  
331.         //每个链路节点的第一个节点是rootlinknode属性  
332.         rootLinkNode temp=g.LinkRoot.get(numOfNode);  
333.         LinkNode temp1=null;  
334.         int maxBandWidth=10000;  
335. //      while(temp.getNextLinkNode()!=null&&compare(temp.getLocalNodeId(),aggregate)){//            temp1=temp.getNextLinkNode();//         j++;//          route[i][j]=temp1.getLocalNodeId();  
336. //          if(maxBandWidth>=temp1.getUpBandwidth()){//              maxBandWidth=temp1.getUpBandwidth();//          }//         //      }  
337.         levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);  
338.     }  
339.     //这个方法遍历子节点  
340.     public static void levelSearchForNode(int numOfNode,Graphs g,int[] aggregate,LLQueue llqueue,int i,rootLinkNode temp,LinkNode temp1,int maxBandWidth,int[][]iswalk,Map map){  
341.         //findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);  
342.         //尝试引入临接矩阵，标签已索引过的边  
343.         //LinkNode temp=g.LinkRoo  
344.             temp=g.LinkRoot.get(numOfNode);  
345. //          System.out.println(numOfNode);t.get(numOfNode);  
346.          //levelSearchForNode(numOfNode,g,aggregate,route,i,j,temp,temp1,maxBandWidth);  
347.         while(temp.getNextLinkNode()!=null&&compare(temp.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()])){  
348.             iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]=1;  
349.             iswalk[temp.getNextLinkNode().getLocalNodeId()][temp.getLocalNodeId()]=1;  
350.             temp1=temp.getNextLinkNode();  
351.             //j++;  
352.             //route[i][j]=temp1.getLocalNodeId();  
353.             llqueue.enQueue(temp1.getLocalNodeId());  
354.             //          System.out.println("下面是135135");//6         System.out.println(temp.getNextLinkNode().getLocalNodeId());//          System.out.println("下面是j");//           System.out.println(j);  
355.             if(maxBandWidth>=temp1.getUpBandwidth()){  
356.                 maxBandWidth=temp1.getUpBandwidth();  
357.             }  
358.             numOfNode=temp1.getLocalNodeId();  
359. //          System.out.println(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]);  
360. //          System.out.println(conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]));  
361.             levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);  
362.         }  
363.         if(temp.getNextLinkNode()==null){  
364.           
365.           
366.         LLNode tempForIf=null;  
367.         tempForIf=llqueue.getFrontNode();  
368.         while(tempForIf.getNextNodeForLLNode()!=llqueue.getRearNode()){  
369.             tempForIf=tempForIf.getNextNodeForLLNode();  
370.         }   
371.         llqueue.setRearNode(tempForIf);  
372.           
373.         numOfNode=tempForIf.getNextNodeForLLNode().getDataForLLNode();  
374.         rootLinkNode temp111=g.LinkRoot.get(numOfNode);  
375.         LinkNode temp112=null;  
376.         //由根节点转为一般节点  
377.         if(temp111.getNextLinkNode()!=null){  
378.             temp112=temp111.getNextLinkNode();  
379.         }  
380.           
381.         findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);}  
382.         else{  
383.             rootLinkNode temp111=null;  
384.             LinkNode temp112=temp.getNextLinkNode();  
385.             System.out.println( temp112.getLocalNodeId());  
386.             System.out.println( temp112.getNextLinkNode().getLocalNodeId());  
387.         findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);  
388.         }  
389. //      if(temp.getNextLinkNode()==null){  
390.               
391.               
392. //          LLNode tempForIf=null;  
393. //          tempForIf=llqueue.getFrontNode();  
394. //          while(tempForIf.getNextNodeForLLNode()!=llqueue.getRearNode()){  
395. //              tempForIf=tempForIf.getNextNodeForLLNode();  
396. //          }   
397. //          llqueue.setRearNode(tempForIf);  
398.               
399. //          numOfNode=tempForIf.getNextNodeForLLNode().getDataForLLNode();  
400. //          rootLinkNode temp111=g.LinkRoot.get(numOfNode);  
401. //          LinkNode temp112=null;  
402.             //由根节点转为一般节点  
403. //          if(temp111.getNextLinkNode()!=null){  
404. //              temp112=temp111.getNextLinkNode();  
405. //          }  
406.             //if(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){  
407.                   
408.             //}  
409.             //获得未访问的节点    
410.             //如果下一个节点又为空了，只能递归调用此函数  
411.  //           while(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){  
412. //              if(temp112.getNextLinkNode()==null){  
413.                       
414. //              }  
415.  //             temp112=temp112.getNextLinkNode();  
416. //          }  
417.             //while(temp111.getNextLinkNode()!=null&&compare(temp.getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()])){            
418.             //}  
419. //            iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()]=1;  
420. //          iswalk[temp112.getNextLinkNode().getLocalNodeId()][temp111.getLocalNodeId()]=1;  
421. //          numOfNode=temp112.getLocalNodeId();  
422. //          temp=g.LinkRoot.get(numOfNode);  
423. //          llqueue.enQueue(numOfNode);  
424. //          temp1=null;  
425. //          levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);  
426. //      }  
427.         //if(compareReverse(temp.getNextLinkNode().getLocalNodeId(),aggregate)){  
428.         //获取未访问的下个节点恰好为消费节点邻接点的点，输入消费节点  
429. //          if(temp.getNextLinkNode()!=null&&compareReverse(temp.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()])){   
430.             //打印路径  
431. //          route[i][j]=-1;  
432. //          llqueue.enQueue(temp.getNextLinkNode().getLocalNodeId());  
433. //          iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]=1;  
434. //          iswalk[temp.getNextLinkNode().getLocalNodeId()][temp.getLocalNodeId()]=1;  
435. //          llqueue.enQueue(Integer.parseInt(String.valueOf(map.get(temp.getNextLinkNode().getLocalNodeId()))));  
436. //            
437. //          System.out.println("下面是打印数据");  
438. //          for(int d=0;d<route[i].length;d++){  
439. //              System.out.println(route[i][d]);  
440. //          }  
441. //          LLNode tempforQueue=llqueue.getFrontNode();  
442. //          while(tempforQueue.getNextNodeForLLNode()!=llqueue.getRearNode()){  
443. //              int data=tempforQueue.getDataForLLNode();  
444. //              System.out.println(data);  
445. //              tempforQueue=tempforQueue.getNextNodeForLLNode();  
446. //          }  
447. //          System.out.println(llqueue.getRearNode().getDataForLLNode());  
448. //          llqueue.setRearNode(tempforQueue);  
449. //          while(llqueue.getFrontNode()!=llqueue.getRearNode()){  
450. //              int data=llqueue.deQueue();  
451. //              System.out.println(data);  
452. //          }  
453. //          System.out.println(llqueue.getFrontNode().getDataForLLNode());  
454. //          llqueue.setFrontNode(null);  
455. //          llqueue.setRearNode(null);  
456. //          System.out.println("结束了");    
457. //          numOfNode=tempforQueue.getDataForLLNode();  
458. //          temp1=g.LinkRoot.get(numOfNode).getNextLinkNode();  
459. //           while(temp1.getNextLinkNode()!=null&&conversionBoolean(iswalk[numOfNode][temp1.getLocalNodeId()])){  
460. //               temp1=temp1.getNextLinkNode();  
461. //           }  
462. //           if(conversionBooleanReverse(iswalk[numOfNode][temp1.getLocalNodeId()])){  
463. //               numOfNode=temp1.getLocalNodeId();  
464. //               temp=g.LinkRoot.get(numOfNode);  
465. ///                 temp1=null;  
466. //           }else{  
467. //               LLNode tempForElse=llqueue.getFrontNode();  
468. //              while(tempForElse.getNextNodeForLLNode()!=llqueue.getRearNode()){  
469. //                  tempForElse=tempForElse.getNextNodeForLLNode();  
470. //              }  
471. //              llqueue.setRearNode(tempForElse);  
472. //              numOfNode=tempForElse.getDataForLLNode();  
473. //              temp=g.LinkRoot.get(numOfNode);  
474. //           }  
475.               
476. //          levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);  
477. //      }  
478.     }  
479.       
480.     //最后返回正确，说明该节点成立  
481.     private static boolean compare(int element,int[] aggregate) {  
482.         // TODO Auto-generated method stub  
483.         int a=aggregate.length;  
484.         //int a=8;      //for(int i=0;i<a;i++){                  //}  
485.         int c=0;  
486.         //while(element!=aggregate[c]&&c<a){  
487.             while(c<a&&element!=aggregate[c]){     
488.             c++;  
489.         }  
490.         if(c==a){  
491.             return true;  
492.         }else{  
493.             return false;  
494.         }  
495.     }  
496.     //没访问过返回1，正向转化值输入-1返回true  
497.     public static boolean conversionBoolean(int a){  
498.         if(a==-1){  
499.             return true;  
500.         }else{  
501.             return false;  
502.         }  
503.     }  
504.     //反向的转化值，未访问由TRUE转为false,输入1返回true  
505.     public static boolean conversionBooleanReverse(int a){  
506.         if(a==-1){  
507.             return false;  
508.         }else{  
509.             return true;  
510.         }  
511.     }  
512.     //aggregate集合//输入待比较的元素和比较元素的集合//比较没有返回1，比较有返回0      
513.       
514.         //定义反向的比较有返回true，没有返回false  
515.     private static boolean compareReverse(int element,int[] aggregate) {  
516.         // TODO Auto-generated method stub  
517.         int a=aggregate.length;  
518.         //int a=8;      //for(int i=0;i<a;i++){                  //}  
519.         int c=0;  
520.         //while(element!=aggregate[c]&&c<a){  
521.             while(c<a&&element!=aggregate[c]){     
522.             c++;  
523.         }  
524.         if(c==a){  
525.             return false;  
526.         }else{  
527.             return true;  
528.         }  
529.     }  
530.     public void replaceRootNode(int numOfNode,Graphs g,LinkNode temp1,rootLinkNode temp,int[][] iswalk,LLNode rearNode){  
531.         temp1=g.LinkRoot.get(numOfNode).getNextLinkNode();  
532.          while(temp1.getNextLinkNode()!=null&&conversionBoolean(iswalk[numOfNode][temp1.getLocalNodeId()])){  
533.              temp1=temp1.getNextLinkNode();  
534.          }  
535.          if(conversionBoolean(iswalk[numOfNode][temp1.getLocalNodeId()])){  
536.              numOfNode=temp1.getLocalNodeId();  
537.              temp=g.LinkRoot.get(numOfNode);  
538.                 temp1=null;  
539.          }else{  
540.              if(rearNode.getDataForLLNode()!=g.LinkRoot.get(numOfNode).getLocalNodeId()){                  
541.              }  
542.          }  
543.           
544.     }  
545.     public static void findNewRootNode(LinkNode temp112,rootLinkNode temp111,int[] aggregate,int[][] iswalk,LLQueue llqueue,int numOfNode,Graphs g,Map map){  
546.           while(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){  
547. //              if(temp112.getNextLinkNode()==null){                      
548. //              }  
549.             temp112=temp112.getNextLinkNode();  
550.             }  
551.           if(temp112.getNextLinkNode()==null){  
552.                 LLNode tempForIf=null;  
553.                 tempForIf=llqueue.getFrontNode();  
554.                 while(tempForIf.getNextNodeForLLNode()!=llqueue.getRearNode()){  
555.                     tempForIf=tempForIf.getNextNodeForLLNode();  
556.                 }   
557.                 llqueue.setRearNode(tempForIf);  
558.                   
559.                 numOfNode=tempForIf.getNextNodeForLLNode().getDataForLLNode();  
560.                  temp111=g.LinkRoot.get(numOfNode);  
561.                  temp112=null;  
562.                 //由根节点转为一般节点  
563.                 if(temp111.getNextLinkNode()!=null){  
564.                     temp112=temp111.getNextLinkNode();  
565.                     findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);  
566.                 }  
567.                 
568.           }  
569.           else{  
570.               if(temp112.getNextLinkNode()!=null&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){  
571.                   temp112=temp112.getNextLinkNode();  
572.                   findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);  
573.               }else{  
574.                   if(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){  
575.                       llqueue.enQueue(temp112.getNextLinkNode().getLocalNodeId());  
576.                         iswalk[temp112.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()]=1;  
577.                         iswalk[temp112.getNextLinkNode().getLocalNodeId()][temp112.getLocalNodeId()]=1;  
578.                         llqueue.enQueue(Integer.parseInt(String.valueOf(map.get(temp112.getNextLinkNode().getLocalNodeId()))));  
579.                           
580.                         System.out.println("下面是打印数据");  
581. //                      for(int d=0;d<route[i].length;d++){  
582. //                          System.out.println(route[i][d]);  
583. //                      }  
584.                         LLNode tempforQueue=llqueue.getFrontNode();  
585.                         while(tempforQueue.getNextNodeForLLNode()!=llqueue.getRearNode()){  
586.                             int data=tempforQueue.getDataForLLNode();  
587.                             System.out.println(data);  
588.                             tempforQueue=tempforQueue.getNextNodeForLLNode();  
589.                         }  
590.                         System.out.println(llqueue.getRearNode().getDataForLLNode());   
591.                         llqueue.setRearNode(tempforQueue);  
592.                         temp112=temp112.getNextLinkNode();  
593.                           findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);  
594.                   }else{if(compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){  
595.                       temp112=temp112.getNextLinkNode();  
596.                       findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);  
597.                   }}  
598.               }  
599.           }  
600.           
601.     }  
602.     //从消费结点开始遍历，存储在队列中  //任取一消费节点，检查其是否满足链路带宽等于其需求，满足则开始配对  
603.     //private static void shorestPath() {   // TODO Auto-generated method stub  //  g   //}  
604.     //思路    //建立一个临接矩阵表示边是否访问过  //要利用主代码新建的变量，就要在方法中输入变量    //依次输入要使用的变量  
605.     //g.LinkRoot.get(temp11).getNextLinkNode()!=null    //判断一个节点下一个指向点不为空的语句    //g.LinkRoot.get(temp11).getNextLinkNode().getLocalNodeId() //获得下一个节点的id  
606. //compare(g. inkRoot.get(temp11).getNextLinkNode().getLocalNodeId(),nextNodeForConsumptionNode);    //比较其临界点是否有链路直连的临接点的方法  //这个方法只遍历头结点  
607.     //parameter要开始遍历的链路头结点，已建立缓存的图，保存消费点临结点的集合,保存路径的数组,第几个消费节点的下标  
608.       

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class run {
	public static void main(String[] args){
		FileUtil fu=new FileUtil();
		//String filePath="D:\\info.txt";
	//	final int spec=4;
		
		//String[] infos=fu.read(filePath, spec);
		
		//int size=infos.length;
		//String info = null;
		//String infoOut=null;
		//for(int i=0;i<size;i++){
		//	 info=infos[i];
		//	System.out.println(info);
		//    infoOut=infoOut+info+"\r";
		//	
	//	}
		
		//Miracle2 mi =new Miracle2(infoOut);
		//mi.showDistance();
		
		
		//String info3="789\n123";
		//System.out.println(info3);
		
		
		
		
		int serverDeploymentCost;//服务器部署成本
		int numOfConsumptionNode;//消费节点数量
		int numOfNetworkLink;//网络链路数量
		int numOfLinkNode;//链路节点数量
		
		Graphs g=new Graphs();
		//g.getInfo2();
		String filePath2="D:\\case0.txt";
		int spec =3;
		String[] infos=fu.read(filePath2, spec);
//		for(int i=0;i<spec;i++){
//			System.out.println(infos[i]);
//		}
		String temp=infos[0];
		System.out.println(temp);
		
		
		
		
		//text3测试按空格分开是否有误
		String[] splitTemp=temp.split("\\s");
//		for(int i=0;i<3;i++){//当i=3时是0,1,2行被选中
//			System.out.println(splitTemp[i]);
//		}
		numOfConsumptionNode=Integer.parseInt(splitTemp[2]);
		numOfNetworkLink=Integer.parseInt(splitTemp[1]);
		numOfLinkNode=Integer.parseInt(splitTemp[0]);
		serverDeploymentCost=Integer.parseInt(infos[2]);
		//28个网络节点，45条链路，12个消费节点
		
		
		
		
		//System.out.println(numOfConsumptionNode);
		//System.out.println(numOfNetworkLink);
		//System.out.println(numOfLinkNode);
		
		//计算需要的总共需要的spec
		spec=5+numOfNetworkLink+numOfConsumptionNode;
		String[] finalinfos=fu.read(filePath2, spec);
		//计算读取链路数需要的开始和结束行
		//第几行-1就是所需行号
		int startNumOfLink=4;
		int endNumOfLink=4+numOfNetworkLink-1;
		//计算读取消费节点数需要的开始和结束行
		int startNumOfConsumptionNode=endNumOfLink+2;
		int endNumOfConsumptionNode=startNumOfConsumptionNode+numOfConsumptionNode-1;
		
		
		System.out.println(endNumOfConsumptionNode);
		
		//先存储消费节点，下面是为消费节点赋值并创建的代码
		
		for(int i=startNumOfConsumptionNode;i<endNumOfConsumptionNode+1;i++){
			String temp2=finalinfos[i];
		String[]	consumptiontemp=temp2.split("\\s");
		//int i=startNumOfConsumptionNode;	
		//consumptiontemp=finalinfos[i].split("\\s");
			
			
			
			int consumptionNodeId=Integer.parseInt(consumptiontemp[0]);//消费节点id,用于确定哪一个消费节点
		    LinkNode nextLinkNodeId=new LinkNode(i, Integer.parseInt(consumptiontemp[1]), 1000, null,0);//链路节点id，用于确定哪一个链路节点
		    //Integer.parseInt(consumptiontemp[1])
		    int bandwidthRequirement=Integer.parseInt(consumptiontemp[2]);//定义一个参数保存贷款需求
		    
		    
		    
		    //消费节点0，相连网络节点ID为8，视频带宽消耗需求为40 
		    
		    
		    
		    
		    //原打算在这里新建添加消费节点的方法，但是该方
		    //法应存在与图中，应直接从图调用
		    //List<consumptionNode> runroot=g.getroot();
			//consumptionNode e=new consumptionNode(consumptionNodeId,nextLinkNodeId,bandwidthRequirement);
			//runroot.add<>;
		    
		    
		    
		    //从上图获得的参数构建消费节点链表
		    g.addNode(consumptionNodeId, nextLinkNodeId, bandwidthRequirement);
		}
		
		//test
//		for(int i=0;i<numOfConsumptionNode;i++){
//			
//			System.out.println(g.returnNode(i).getConsumptionNodeId());
//			System.out.println(g.returnNode(i).getNextLinkNodeId().getLocalNodeId());
//			System.out.println(g.returnNode(i).getBandwidthRequirement());
//			
//		}
		
		
		
		
		
		
		//添加链路头结点的方法
		//numOfLinkNode网络链路节点数量
		int localNodeId;
		LinkNode nextLinkNode;
		for(int i=0;i<numOfLinkNode;i++){
			//rootLinkNode(i,null);
			g.addRootLinkNode(i);
		}
		 //System.out.println("下面是测试链路头结点程序");
		//System.out.println(numOfLinkNode);
		//for(int i=0;i<50;i++){
		//	System.out.println(g.LinkRoot.get(i).getLocalNodeId());
		//}
		
		
		
		//添加链路节点的方法
		
		 //for(int i=startNumOfLink;i<endNumOfConsumptionNode+1;i++){
		for(int i=startNumOfLink;i<endNumOfLink;i++){
			//定义链路节点基本元素
			int lnlocalNodeId;
		    int lntotalBandwidth;
			LinkNode lnnextLinkNode;
			int lnpreNodeId;
			int lnunitRentalCost;
			String temp3=finalinfos[i];
		    String[] consumptiontemp=temp3.split("\\s");
		    lnpreNodeId=Integer.parseInt(consumptiontemp[0]);
		    lnlocalNodeId=Integer.parseInt(consumptiontemp[1]);
		    lntotalBandwidth=Integer.parseInt(consumptiontemp[2]);
		    lnunitRentalCost=Integer.parseInt(consumptiontemp[3]);
		    //新建节点之后加进去
		    lnnextLinkNode=new LinkNode(lnpreNodeId, lnlocalNodeId, lntotalBandwidth, null, lnunitRentalCost);
		    LinkNode reverseLnnextLinkNode;
		    reverseLnnextLinkNode=new LinkNode(lnlocalNodeId, lnpreNodeId, lntotalBandwidth, null, lnunitRentalCost);
		    if(g.LinkRoot.get(lnpreNodeId).getNextLinkNode()==null){
		    	g.LinkRoot.get(lnpreNodeId).setNextLinkNodeForRoot(lnnextLinkNode);
		    }else{
		    	 LinkNode temp4=g.LinkRoot.get(lnpreNodeId).getNextLinkNode();
		    	 LinkNode temp5=g.LinkRoot.get(lnpreNodeId).getNextLinkNode();
				    while(temp4!=null&&temp4.getLocalNodeId()!=lnlocalNodeId){
				    	temp5=temp4;
				    	temp4=temp4.getNextLinkNode();
				    
				    }
				    //if(temp4==null){if(temp4.getLocalNodeId()!=lnlocalNodeId)
				    if(temp4==null){
				    	temp5.setNextLinkNode(lnnextLinkNode);
				    	//g.LinkRoot.get(lnpreNodeId).setNextLinkNodeForRoot(lnnextLinkNode);
				    }
				    
		    }
		    
		    
		    //反向代码
		    if(g.LinkRoot.get(lnlocalNodeId).getNextLinkNode()==null){
		    	g.LinkRoot.get(lnlocalNodeId).setNextLinkNodeForRoot(reverseLnnextLinkNode);
		    }else{
		    	 LinkNode temp4=g.LinkRoot.get(lnlocalNodeId).getNextLinkNode();
		    	 LinkNode temp5=g.LinkRoot.get(lnlocalNodeId).getNextLinkNode();
				    while(temp4!=null&&temp4.getLocalNodeId()!=lnpreNodeId){
				    	temp5=temp4;
				    	temp4=temp4.getNextLinkNode();
				    
				    }
				    if(temp4==null){
				    	g.LinkRoot.get(lnlocalNodeId).setNextLinkNodeForRoot(reverseLnnextLinkNode);
				    }
				    
		    }
		   
		    //g.LinkRoot.get(lnpreNodeId).setNextLinkNodeForRoot(lnnextLinkNode);
		    //LinkNode temp4=g.LinkRoot.get(lnpreNodeId).getNextLinkNode();
		   // while(){
		    	
		  //  }
		
		}
		
		//这里起始节点命名为preNodeId
		//链路起始节点为0，链路终止节点为16 ，总带宽为8，单位网络租用费为2
		
//		System.out.println("下面是测试数据");
//		for(int i =0;i<numOfLinkNode;i++){
//			LinkNode temp6=g.LinkRoot.get(i).getNextLinkNode();
//			System.out.println(temp6.getLocalNodeId());
//		}
//		System.out.println(g.LinkRoot.get(1).getNextLinkNode().getLocalNodeId());
		
		
		//总测试用例
		//我们已经得到
		//28个网络节点，45条链路，12个消费节点
		//服务器部署成本为100
		//链路节点信息
		//链路起始节点为0，链路终止节点为16 ，总带宽为8，单位网络租用费为2
		//消费节点信息
		//消费节点0，相连网络节点ID为8，视频带宽消耗需求为40 
		System.out.printf("有%d个网络节点，%d个链路，%d个消费节点", numOfLinkNode,numOfNetworkLink,numOfConsumptionNode);
		
	
		
		//从消费结点开始遍历，存储在队列中
		//任取一消费节点，检查其是否满足链路带宽等于其需求，满足则开始配对
	int rootSize=g.root.size();
	//System.out.println(rootSize);
	//定义一个集合保存满足单路的结点
	//list<int> singleWayconsumption=new LinkList<>;
	
	int destination;
	int countOfSingleWayConsumption=0;
	int[] nextNodeForConsumptionNode=new int[rootSize];
	for(int i=0;i<rootSize;i++){
		//第一个消费节点的第一个链路节点提供的带宽
		int idFornextNodeofConsumptionNode=g.root.get(i).getNextLinkNodeId().getLocalNodeId();
		//System.out.println(idFornextNodeofConsumptionNode);
		nextNodeForConsumptionNode[i]=idFornextNodeofConsumptionNode;
		int firstConsumptionLinkNodeBandWith=g.LinkRoot.get(idFornextNodeofConsumptionNode).getNextLinkNode().getTotalBandwidth();
		//System.out.println(idFornextNodeofConsumptionNode);
	//	int firstConsumptionLinkNodeBandWith=g.root.get(i).getNextLinkNodeId().getNextLinkNode().getTotalBandwidth();
		
		if(g.root.get(i).getBandwidthRequirement()<=firstConsumptionLinkNodeBandWith){
			//singleWayConsumption[countOfSingleWayConsumption]=g.root.get(i).getConsumptionNodeId();
			
			countOfSingleWayConsumption++;
		}
		
		
//		//text
//		for(int d=0;d<countOfSingleWayConsumption;d++){
//			System.out.println(singleWayConsumption[d]);
//			}
		}
	int[] singleWayConsumption=new int[countOfSingleWayConsumption] ;
	int countFor2=0;
//	System.out.println(countOfSingleWayConsumption);
	
	for(int i=0;i<rootSize;i++){
		//第一个消费节点的第一个链路节点提供的带宽
		//int firstConsumptionLinkNodeBandWith2=g.root.get(c).getNextLinkNodeId().getNextLinkNode().getTotalBandwidth();
		int idFornextNodeofConsumptionNode2=g.root.get(i).getNextLinkNodeId().getLocalNodeId();
		int firstConsumptionLinkNodeBandWith2=g.LinkRoot .get(idFornextNodeofConsumptionNode2).getNextLinkNode().getTotalBandwidth();
		
		
		if(g.root.get(i).getBandwidthRequirement()<=firstConsumptionLinkNodeBandWith2){
			singleWayConsumption[countFor2]=g.root.get(i).getConsumptionNodeId();
			countFor2++;
			//countOfSingleWayConsumption++;
		}
	
}
	
	//map.put(1, 5);
	//System.out.println(map.get(1));
	System.out.println("检验这个数是多少");
	System.out.println(countOfSingleWayConsumption);	
	searchMatrix matrixForRun=new searchMatrix();
	int[][] a=matrixForRun.createMatrix(numOfLinkNode,numOfLinkNode);
	matrixForRun.assignment(a, numOfLinkNode, numOfLinkNode);
	//定义一个数组记录链路可使用的最大带宽	//开始遍历并保存路径
	//获得所有消费节点的临界点，保存在数组中，进行比较	//int[][] route=null;
	//int[][] route=new int[1000][10];
	//当一个索引=-1时，表示该行遍历结束	//nextNodeForConsumptionNode
	for(int i=0;i<numOfLinkNode;i++){
		a[i][i]=1;
	}
	LLQueue llqueue=new LLQueue();
	//建立一个hashmap存储邻接点为键值，消费节点为value
			Map map=new HashMap<>();
			for(int i=0;i<rootSize;i++){
				map.put(g.root.get(i).getNextLinkNodeId().getLocalNodeId(), g.root.get(i).getConsumptionNodeId());		
			}
		
	for(int i=0;i<countOfSingleWayConsumption;i++){
		int thisConsumptionNode=singleWayConsumption[i];
		System.out.println("这是一次遍历");
		
		//route[i][0]=thisConsumptionNode;
		llqueue.enQueue(thisConsumptionNode);
		//route[i][0]=1;		//route[i][1]=nextNodeForConsumptionNode[thisConsumptionNode];
		//llqueue.enQueue(nextNodeForConsumptionNode[thisConsumptionNode]);
		llqueue.enQueue(g.root.get(thisConsumptionNode).getNextLinkNodeId().getLocalNodeId());
		//int temp11=nextNodeForConsumptionNode[thisConsumptionNode];
		int temp11=g.root.get(thisConsumptionNode).getNextLinkNodeId().getLocalNodeId();
		System.out.println(thisConsumptionNode);
		System.out.println(temp11);
		//while(g.LinkRoot.get(temp11).getNextLinkNode().getLocalNodeId()!=null){
		levelSearch(temp11,g,nextNodeForConsumptionNode,llqueue,i,a,map);	
		//}		//g.LinkRoot.get(temp11).getNextLinkNode()!=null//判断一个节点下一个指向点不为空的语句		//g.LinkRoot.get(temp11).getNextLinkNode().getLocalNodeId()
		//获得下一个节点的id		//compare(g. inkRoot.get(temp11).getNextLinkNode().getLocalNodeId(),nextNodeForConsumptionNode);		//比较其临界点是否有链路直连的临接点的方法
	}
	//int[] route = null;//route[0]=0;//route[1]=1;//route[2]=2;//	System.out.println("测试链表是否为空");//	rootLinkNode temp13=g.LinkRoot.get(1);
//	LinkNode temp14=temp13.getNextLinkNode();//	while(temp14!=null){//		System.out.println(temp14.getLocalNodeId());//		temp14=temp14.getNextLinkNode();
//	}//	System.out.println("测试结束");	
	}

	public static void levelSearch(int numOfNode,Graphs g,int[] aggregate,LLQueue llqueue,int i,int[][]iswalk,Map map){
		//每个链路节点的第一个节点是rootlinknode属性
		rootLinkNode temp=g.LinkRoot.get(numOfNode);
		LinkNode temp1=null;
		int maxBandWidth=10000;
//		while(temp.getNextLinkNode()!=null&&compare(temp.getLocalNodeId(),aggregate)){//			temp1=temp.getNextLinkNode();//			j++;//			route[i][j]=temp1.getLocalNodeId();
//			if(maxBandWidth>=temp1.getUpBandwidth()){//				maxBandWidth=temp1.getUpBandwidth();//			}//			//		}
		levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);
	}
	//这个方法遍历子节点
	public static void levelSearchForNode(int numOfNode,Graphs g,int[] aggregate,LLQueue llqueue,int i,rootLinkNode temp,LinkNode temp1,int maxBandWidth,int[][]iswalk,Map map){
		//findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);
		//尝试引入临接矩阵，标签已索引过的边
		//LinkNode temp=g.LinkRoo
			temp=g.LinkRoot.get(numOfNode);
//			System.out.println(numOfNode);t.get(numOfNode);
		 //levelSearchForNode(numOfNode,g,aggregate,route,i,j,temp,temp1,maxBandWidth);
 		while(temp.getNextLinkNode()!=null&&compare(temp.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()])){
			iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]=1;
			iswalk[temp.getNextLinkNode().getLocalNodeId()][temp.getLocalNodeId()]=1;
			temp1=temp.getNextLinkNode();
			//j++;
			//route[i][j]=temp1.getLocalNodeId();
			llqueue.enQueue(temp1.getLocalNodeId());
			//			System.out.println("下面是135135");//6			System.out.println(temp.getNextLinkNode().getLocalNodeId());//			System.out.println("下面是j");//			System.out.println(j);
			if(maxBandWidth>=temp1.getUpBandwidth()){
				maxBandWidth=temp1.getUpBandwidth();
			}
			numOfNode=temp1.getLocalNodeId();
//			System.out.println(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]);
//			System.out.println(conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]));
			levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);
		}
    	if(temp.getNextLinkNode()==null){
		
		
		LLNode tempForIf=null;
		tempForIf=llqueue.getFrontNode();
		while(tempForIf.getNextNodeForLLNode()!=llqueue.getRearNode()){
			tempForIf=tempForIf.getNextNodeForLLNode();
		} 
		llqueue.setRearNode(tempForIf);
		
		numOfNode=tempForIf.getNextNodeForLLNode().getDataForLLNode();
		rootLinkNode temp111=g.LinkRoot.get(numOfNode);
		LinkNode temp112=null;
		//由根节点转为一般节点
		if(temp111.getNextLinkNode()!=null){
			temp112=temp111.getNextLinkNode();
		}
    	
 		findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);}
    	else{
    		rootLinkNode temp111=null;
    		LinkNode temp112=temp.getNextLinkNode();
    		System.out.println( temp112.getLocalNodeId());
    		System.out.println( temp112.getNextLinkNode().getLocalNodeId());
        findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);
    	}
//		if(temp.getNextLinkNode()==null){
			
			
//			LLNode tempForIf=null;
//			tempForIf=llqueue.getFrontNode();
//			while(tempForIf.getNextNodeForLLNode()!=llqueue.getRearNode()){
//				tempForIf=tempForIf.getNextNodeForLLNode();
//			} 
//			llqueue.setRearNode(tempForIf);
			
//			numOfNode=tempForIf.getNextNodeForLLNode().getDataForLLNode();
//			rootLinkNode temp111=g.LinkRoot.get(numOfNode);
//			LinkNode temp112=null;
			//由根节点转为一般节点
//			if(temp111.getNextLinkNode()!=null){
//				temp112=temp111.getNextLinkNode();
//			}
			//if(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){
				
			//}
			//获得未访问的节点	
			//如果下一个节点又为空了，只能递归调用此函数
 //           while(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){
//				if(temp112.getNextLinkNode()==null){
					
//				}
 //           	temp112=temp112.getNextLinkNode();
//			}
			//while(temp111.getNextLinkNode()!=null&&compare(temp.getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()])){			
			//}
//            iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()]=1;
//			iswalk[temp112.getNextLinkNode().getLocalNodeId()][temp111.getLocalNodeId()]=1;
//			numOfNode=temp112.getLocalNodeId();
//		    temp=g.LinkRoot.get(numOfNode);
//			llqueue.enQueue(numOfNode);
//			temp1=null;
//			levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);
//		}
		//if(compareReverse(temp.getNextLinkNode().getLocalNodeId(),aggregate)){
		//获取未访问的下个节点恰好为消费节点邻接点的点，输入消费节点
//			if(temp.getNextLinkNode()!=null&&compareReverse(temp.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()])){	
			//打印路径
//			route[i][j]=-1;
//			llqueue.enQueue(temp.getNextLinkNode().getLocalNodeId());
//			iswalk[temp.getLocalNodeId()][temp.getNextLinkNode().getLocalNodeId()]=1;
//			iswalk[temp.getNextLinkNode().getLocalNodeId()][temp.getLocalNodeId()]=1;
//			llqueue.enQueue(Integer.parseInt(String.valueOf(map.get(temp.getNextLinkNode().getLocalNodeId()))));
//			
//			System.out.println("下面是打印数据");
//			for(int d=0;d<route[i].length;d++){
//				System.out.println(route[i][d]);
//			}
//			LLNode tempforQueue=llqueue.getFrontNode();
//			while(tempforQueue.getNextNodeForLLNode()!=llqueue.getRearNode()){
//				int data=tempforQueue.getDataForLLNode();
//				System.out.println(data);
//				tempforQueue=tempforQueue.getNextNodeForLLNode();
//			}
//			System.out.println(llqueue.getRearNode().getDataForLLNode());
//			llqueue.setRearNode(tempforQueue);
//			while(llqueue.getFrontNode()!=llqueue.getRearNode()){
//				int data=llqueue.deQueue();
//				System.out.println(data);
//			}
//			System.out.println(llqueue.getFrontNode().getDataForLLNode());
//			llqueue.setFrontNode(null);
//			llqueue.setRearNode(null);
//			System.out.println("结束了");	
//			numOfNode=tempforQueue.getDataForLLNode();
//			temp1=g.LinkRoot.get(numOfNode).getNextLinkNode();
//			 while(temp1.getNextLinkNode()!=null&&conversionBoolean(iswalk[numOfNode][temp1.getLocalNodeId()])){
//				 temp1=temp1.getNextLinkNode();
//			 }
//			 if(conversionBooleanReverse(iswalk[numOfNode][temp1.getLocalNodeId()])){
//				 numOfNode=temp1.getLocalNodeId();
//				 temp=g.LinkRoot.get(numOfNode);
///					temp1=null;
//			 }else{
//				 LLNode tempForElse=llqueue.getFrontNode();
//				while(tempForElse.getNextNodeForLLNode()!=llqueue.getRearNode()){
//					tempForElse=tempForElse.getNextNodeForLLNode();
//				}
//				llqueue.setRearNode(tempForElse);
//				numOfNode=tempForElse.getDataForLLNode();
//				temp=g.LinkRoot.get(numOfNode);
//			 }
			
//			levelSearchForNode(numOfNode,g,aggregate,llqueue,i,temp,temp1,maxBandWidth,iswalk,map);
//		}
	}
	
	//最后返回正确，说明该节点成立
	private static boolean compare(int element,int[] aggregate) {
		// TODO Auto-generated method stub
		int a=aggregate.length;
		//int a=8;		//for(int i=0;i<a;i++){					//}
		int c=0;
		//while(element!=aggregate[c]&&c<a){
			while(c<a&&element!=aggregate[c]){	
			c++;
		}
		if(c==a){
			return true;
		}else{
			return false;
		}
	}
	//没访问过返回1，正向转化值输入-1返回true
	public static boolean conversionBoolean(int a){
		if(a==-1){
			return true;
		}else{
			return false;
		}
	}
	//反向的转化值，未访问由TRUE转为false,输入1返回true
	public static boolean conversionBooleanReverse(int a){
		if(a==-1){
			return false;
		}else{
			return true;
		}
	}
	//aggregate集合//输入待比较的元素和比较元素的集合//比较没有返回1，比较有返回0    
	
		//定义反向的比较有返回true，没有返回false
	private static boolean compareReverse(int element,int[] aggregate) {
		// TODO Auto-generated method stub
		int a=aggregate.length;
		//int a=8;		//for(int i=0;i<a;i++){					//}
		int c=0;
		//while(element!=aggregate[c]&&c<a){
			while(c<a&&element!=aggregate[c]){	
			c++;
		}
		if(c==a){
			return false;
		}else{
			return true;
		}
	}
	public void replaceRootNode(int numOfNode,Graphs g,LinkNode temp1,rootLinkNode temp,int[][] iswalk,LLNode rearNode){
		temp1=g.LinkRoot.get(numOfNode).getNextLinkNode();
		 while(temp1.getNextLinkNode()!=null&&conversionBoolean(iswalk[numOfNode][temp1.getLocalNodeId()])){
			 temp1=temp1.getNextLinkNode();
		 }
		 if(conversionBoolean(iswalk[numOfNode][temp1.getLocalNodeId()])){
			 numOfNode=temp1.getLocalNodeId();
			 temp=g.LinkRoot.get(numOfNode);
				temp1=null;
		 }else{
			 if(rearNode.getDataForLLNode()!=g.LinkRoot.get(numOfNode).getLocalNodeId()){				 
			 }
		 }
		
	}
	public static void findNewRootNode(LinkNode temp112,rootLinkNode temp111,int[] aggregate,int[][] iswalk,LLQueue llqueue,int numOfNode,Graphs g,Map map){
		  while(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){
//				if(temp112.getNextLinkNode()==null){					
//				}
          	temp112=temp112.getNextLinkNode();
			}
		  if(temp112.getNextLinkNode()==null){
				LLNode tempForIf=null;
				tempForIf=llqueue.getFrontNode();
				while(tempForIf.getNextNodeForLLNode()!=llqueue.getRearNode()){
					tempForIf=tempForIf.getNextNodeForLLNode();
				} 
				llqueue.setRearNode(tempForIf);
				
				numOfNode=tempForIf.getNextNodeForLLNode().getDataForLLNode();
				 temp111=g.LinkRoot.get(numOfNode);
				 temp112=null;
				//由根节点转为一般节点
				if(temp111.getNextLinkNode()!=null){
					temp112=temp111.getNextLinkNode();
					findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);
				}
			  
		  }
		  else{
			  if(temp112.getNextLinkNode()!=null&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){
				  temp112=temp112.getNextLinkNode();
				  findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);
			  }else{
				  if(temp112.getNextLinkNode()!=null&&compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBoolean(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){
					  llqueue.enQueue(temp112.getNextLinkNode().getLocalNodeId());
						iswalk[temp112.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()]=1;
						iswalk[temp112.getNextLinkNode().getLocalNodeId()][temp112.getLocalNodeId()]=1;
						llqueue.enQueue(Integer.parseInt(String.valueOf(map.get(temp112.getNextLinkNode().getLocalNodeId()))));
						
						System.out.println("下面是打印数据");
//						for(int d=0;d<route[i].length;d++){
//							System.out.println(route[i][d]);
//						}
						LLNode tempforQueue=llqueue.getFrontNode();
						while(tempforQueue.getNextNodeForLLNode()!=llqueue.getRearNode()){
							int data=tempforQueue.getDataForLLNode();
							System.out.println(data);
							tempforQueue=tempforQueue.getNextNodeForLLNode();
						}
						System.out.println(llqueue.getRearNode().getDataForLLNode()); 
						llqueue.setRearNode(tempforQueue);
						temp112=temp112.getNextLinkNode();
						  findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);
				  }else{if(compare(temp112.getNextLinkNode().getLocalNodeId(),aggregate)&&conversionBooleanReverse(iswalk[temp111.getLocalNodeId()][temp112.getNextLinkNode().getLocalNodeId()])){
					  temp112=temp112.getNextLinkNode();
					  findNewRootNode(temp112,temp111,aggregate,iswalk,llqueue,numOfNode,g,map);
				  }}
			  }
		  }
		
	}
	//从消费结点开始遍历，存储在队列中	//任取一消费节点，检查其是否满足链路带宽等于其需求，满足则开始配对
	//private static void shorestPath() {	// TODO Auto-generated method stub	//	g	//}
	//思路	//建立一个临接矩阵表示边是否访问过	//要利用主代码新建的变量，就要在方法中输入变量	//依次输入要使用的变量
	//g.LinkRoot.get(temp11).getNextLinkNode()!=null	//判断一个节点下一个指向点不为空的语句	//g.LinkRoot.get(temp11).getNextLinkNode().getLocalNodeId()	//获得下一个节点的id
//compare(g. inkRoot.get(temp11).getNextLinkNode().getLocalNodeId(),nextNodeForConsumptionNode);	//比较其临界点是否有链路直连的临接点的方法	//这个方法只遍历头结点
	//parameter要开始遍历的链路头结点，已建立缓存的图，保存消费点临结点的集合,保存路径的数组,第几个消费节点的下标
	

[java] view plain copy print ?

http://blog.csdn.net/qq_26122557/article/details/77104961

1. public class searchMatrix {  
2.     private int[][] matrix;  
3.   
4.     public int[][] createMatrix(int x,int y) {  
5.         matrix=new int[x][y];  
6.         return matrix;  
7.     }  
8.     public void assignment(int[][] matrix,int x,int y){  
9.         //分配  
10.         for(int i=0;i<x;i++){  
11.             for(int j=0;j<y;j++){  
12.                 matrix[i][j]=-1;  
13.             }  
14.         }  
15.     }  
16.     //当值为-1时表示未访问，为1表示访问过  
17.     public void setMatrix(int[][] matrix) {  
18.         this.matrix = matrix;  
19.     }  
20.     public int getValue(int x,int y){  
21.         return matrix[x][y];  
22.     }  
23.     public void setValue(int x,int y,int value){  
24.         matrix[x][y]=value;  
25.     }  
26.     public int[][] getMatrix() {  
27.         return matrix;  
28.     }  
29. }