图

package sw;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
 
public class source {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        source.Graph graph = new source().new Graph();
        createGraph(graph,sc);
        dsfGraph(graph);
        bsfGraph(graph);
        sc.close();
    }
      
    //创建邻接矩阵图
    private static void createGraph(Graph graph,Scanner sc){
          
        graph.vertexNum = sc.nextInt();
        graph.edgeNum = sc.nextInt();
        graph.startPoint = sc.nextInt();
        int[][] vertexPair = new int[graph.edgeNum][2];
        graph.edgeWeight = new int[graph.vertexNum][graph.vertexNum];     //边的信息
        graph.isTrav = new int[graph.vertexNum];
          
        for(int k=0;k<graph.edgeNum;k++){
            vertexPair[k][0] = sc.nextInt();
            vertexPair[k][1] = sc.nextInt();
            graph.edgeWeight[vertexPair[k][0]-1][vertexPair[k][1]-1] = 1;
            graph.edgeWeight[vertexPair[k][1]-1][vertexPair[k][0]-1] = 1;
        }
    }
      
    //DSF
    private static void dsfGraph(Graph graph){
        source.Stack_type st=new source().new Stack_type();  
        source.Stack_Data data1=new source().new Stack_Data();  
        source.Stack_type stack = st.STinit(); //初始化栈
          
        //访问顶点v；visited[v]=1；顶点v入栈S
        int startPoint = graph.startPoint;
        data1.vertexName = startPoint;
        st.PushST(stack, data1);
        graph.isTrav[startPoint-1] = 1;       //访问标志修改
        while (st.STIsEmpty(st)) {
            Stack_Data stackTop = st.PeekST(stack);
            int stackTopVer = stackTop.vertexName;
            for(int i=0;i<graph.vertexNum;i++){
                if(graph.edgeWeight[stackTopVer-1][i] != 0 && graph.isTrav[i] != 1){
                    source.Stack_Data data = new source().new Stack_Data();
                    data.vertexName = i+1;
                    st.PushST(stack, data);
                    graph.isTrav[i] = 1;
                    
                }else{
                    
                }
            }
            if(stack.top==graph.vertexNum){
                break;
            }
        }
          
        List<Object> vertex = new ArrayList<Object>();
        while (stack.top>0) {
            Stack_Data stackTopTemp = st.PeekST(stack);
            vertex.add(stackTopTemp.vertexName);
            st.PopST(stack);
        }
        for(int i=vertex.size()-1;i>=0;i--){
            System.out.print(vertex.get(i)+" ");
        }
        System.out.println();
    }
      
    //BSF
    private static void bsfGraph(Graph graph){
        graph.isTrav = new int[graph.vertexNum];
        Queue<Integer> queue = new LinkedList<Integer>();
        //访问顶点v；visited[v]=1；顶点v入队列Q；
        int startPoint = graph.startPoint;
        List<Object> vertex = new ArrayList<Object>();
        queue.offer(startPoint);
        graph.isTrav[startPoint-1] = 1;
        while(!queue.isEmpty()){
            int queueFirst = queue.poll();
            vertex.add(queueFirst);
            for(int i=0;i<graph.vertexNum;i++){
                if(graph.edgeWeight[queueFirst-1][i] != 0){
                    int temp = i+1;
                    while(graph.isTrav[i] != 1){
                        graph.isTrav[temp-1] = 1;
                        queue.offer(temp);
                        break;
                    }
                }
            }
        }
        for(int i=0;i<vertex.size();i++){
            System.out.print(vertex.get(i)+" ");
        }
        System.out.println();
          
    }
      
    //清空图  
    private static void clearGraph(Graph g){  
        int i,j;  
        for(i=0; i< g.vertexNum; i++)  
            for(j =0; j<g.vertexNum; j++)  
                g.edgeWeight[i][j] = 0;           //设置矩阵中各院素的值为MaxValue  
    }
      
    //定义图的结构
    private class Graph{
        int vertexNum;     //图的顶点个数
        int vertexNumMax = 20000;
        int[] vertexInfo = new int[vertexNum];    //图的顶点信息
        int edgeNum;     //边的个数
        int startPoint;     //遍历起始点
        int[][] edgeWeight = new int[vertexNum][vertexNum];     //边的信息
        int[] isTrav = new int[vertexNum];     //遍历标志
    }
      
    class Stack_Data{  
        int vertexName;  
    }  
        
    class Stack_type{  
        static final int MAXLEN=20000; //定义栈的最大长度  
        Stack_Data[] data=new Stack_Data[MAXLEN+1];  
        int top;  
            
        Stack_type STinit(){  
            Stack_type p;  
            if((p=new Stack_type())!=null){  //申请栈内存  
                p.top=0;  
                return p;  
                }  
            return null;  
        }  
            
        boolean STIsEmpty(Stack_type s){  //判断栈是否为空  
            boolean t;  
            t=(s.top==0);  
            return t;  
        }  
            
        boolean STIsFull(Stack_type s){  //判断栈是否已满  
            boolean t;  
            t=(s.top==MAXLEN);  
            return t;  
        }  
            
        void STClear(Stack_type s){  //清空栈  
            s.top=0;  
        }  
            
        void STFree(Stack_type s){ //释放栈所占用空间  
            if(s!=null){  
                s=null;  
            }  
        }  
            
        int PushST(Stack_type s,Stack_Data data){  
            if((s.top+1)>MAXLEN){return 0;}  //栈溢出  
            s.data[++s.top]=data;  
            return 1;  
        }  
            
        Stack_Data PopST(Stack_type s){  
            if(s.top==0){System.out.println("no elements!"); return null;} //栈为空，操作失败  
            return (s.data[s.top--]);  
        }  
            
        Stack_Data PeekST(Stack_type s){  
            if(s.top==0){System.exit(0);}  //栈为空，操作失败  
            return (s.data[s.top]);  
        }  
    }
}