03-树2 List Leaves

//03-树2 List Leaves


import java.util.Scanner;
import java.util.ArrayList;

class node{
	int left;
	int right;
}

public class Main {
	
	final static int Max_Size = 10;
	
	static ArrayList<Integer> Path(node[] T, int leaf, int R) {
		ArrayList<Integer> path = new ArrayList<Integer>();	
		while(leaf != R) {
			path.add(leaf);
			for(int i = 0; i < T.length; i ++) {
				if(T[i].left == leaf || T[i].right == leaf) {
					leaf = i;
					break;
				}
			}
		}
		path.add(R);
		return path;
	}
	
	static boolean judgeleft(node[] T, ArrayList<Integer> p1, ArrayList<Integer> p2) {
		int flag = 0;
		if(p1.get(0) == p2.get(0)) {
			return false;
		}
		for(int i = 1; i < p1.size(); i ++) {
			if(p1.get(i) == p2.get(i)) {
				flag = i;
				break;
			}
		}
		
		if(T[p1.get(flag)].left == p1.get(flag - 1)) {
			return true;
		}
		else {
			return false;
		}
	}
	
	static boolean judge(node[] T, ArrayList<Integer> p1, ArrayList<Integer> p2){
		boolean flag;
		if(p1.size() > p2.size()) {
			return false;
		}
		else if(p1.size() < p2.size()) {
			return true;
		}
		else {
			flag = judgeleft(T, p1, p2);
			return flag;
		}
		
	}
	
	static int Read(Scanner s, node[] T) {
		int n = 0;
		int R = -1;
		n = s.nextInt();
		int[] a = new int[n];
		String x, y;
		for(int i = 0; i < n; i ++) {
			T[i] = new node();
			x = s.next();
			y = s.next();
			if(!x.equals("-")) {
				T[i].left = Integer.parseInt(x);
			}
			else {
				T[i].left = -1;
			}
			if(!y.equals("-")) {
				T[i].right = Integer.parseInt(y);
			}
			else {
				T[i].right = -1;
			}
		}
		for(int i = 0; i < n; i ++) {
			if(T[i].left != -1) {
				a[T[i].left] = 1;
			}
			if(T[i].right != -1) {
				a[T[i].right] = 1;
			}
		}
		for(int i = 0; i < n; i ++) {
			if(a[i] == 0) {
				R = i;
				break;
			}
		}
		return R;
	}
	
	static void printleaves(node[] T, int R) {
		ArrayList<Integer> lea = new ArrayList<Integer>();
		int n = 0;
		int flag = 0;
		int N = 0;
		while(T[N] != null) {
			N ++;
		}
		if(N > 1) {
			ArrayList<Integer> outpath = new ArrayList<Integer>();
			for(int i = 0; i < N; i ++) {
				if(T[i].left == -1 && T[i].right == -1) {
					lea.add(i);
					n ++;
				}
			}
			@SuppressWarnings("rawtypes")
			ArrayList[] paths  = new ArrayList[n];
			for(int i = 0; i < n; i ++) {
				paths[i] = Path(T, lea.get(i), R);
			}
			if(paths.length > 1) {
				
				if(judge(T, paths[0], paths[1])) {
					outpath.clear();
					outpath.addAll(paths[0]);
				}
				else {
					outpath.clear();
					outpath.addAll(paths[1]);
					flag = 1;
				}
				while(n > 1) {
					for(int i = 0; i < n; i ++) {
						if(judge(T, paths[i], outpath)){
							outpath.clear();
							outpath.addAll(paths[i]);
							flag = i;
						}
					}
					System.out.print(outpath.get(0) + " ");
					for(int i = flag; i < n - 1; i ++) {
						paths[i] = paths[i + 1];
					}
					paths[n - 1] = null;
					n --;
					outpath.clear();
					outpath.addAll(paths[0]);
					flag = 0;
				}
				System.out.print(paths[0].get(0));
			}
			else {
				System.out.print(paths[0].get(0));
			}
		}
		else {
			System.out.print(0);
		}
	}
	
	public static void main(String args[]){
		Scanner s = new Scanner(System.in);
		int N = 0;
		node[] T = new node[Max_Size + 1];
		int R = Read(s, T);
		s.close();
		printleaves(T, R);
	}
}