What's wrong with this code (Dijkstra Shortest Path algorithm)

//THE PART OF LINKED LIST:
 
public class List {
	private static int MAX = Integer.MAX_VALUE;
	
	private class Point {
		int p, len;
		Point next;
		
		public Point(int x, int y){
			p = x;
			len = y;
			next = null;
		}
	}
	private Point head;
	private Point tail;
	
	public List(){
		head = null;
		tail = null;
	}
	
	
	//Add edge with vertex x and length len
	public void add(int x, int len){
		Point p = new Point(x, len);
		
		if (head == null){
			head = tail = p;
		}
		else{
			
			tail.next = p;
			tail = p;
		}
	}
	
	//Get edge of vertex y
	public int get(int y){
		if (head == null)
			return MAX;
		Point id = head;
		while (id != null){
			if (id.p == y)
				return id.len;
			id = id.next;
		}
		return MAX;
	}
	
	//Remove the edge of vertex x
	public int remove(int x){
		if (head == null)
			return MAX;
		Point id = head;
		if (head.p == x)
		{
			int val = head.len;
			head = head.next;
			return val;
		}
		while (id.next != null)
		{
			if (id.next.p == x)
			{
				int val = id.next.len;
				id.next = id.next.next;
				return val;
			}
			id = id.next;
		}
		
		return MAX;
	}
	}
 
//THE PART OF DIJSKTRA SHORTEST PATH ALGORITHM
// MAX = Integer.MAX_VALUE to denote infinity
//The List[] data = new List[n] stores the adjacency lists for n vertices
public static int shortestPath(List[] data, int n, int src, int dest){
		Vector<Integer> t = new Vector<Integer>();	//Tenative set
		
		int [] val = new int[n];	//Value of the shortest paths from src to other vertices
		
		//Initial value for val[i] is the length between src and node i
		for(int i = 0; i < n; i++){
			val[i] =  (i == src)? 0 : data[src].get(i);
		}
		
		//Add other vertices into tentative set
		for (int i = 0; i < n; i++)
			if (i != src)
				t.add(i);
	
		//As long as tentative set is not empty, we iterate
		while (!t.isEmpty()){
			int s = t.size();	//Size of tentative node
			int min = 0;
			
			//If there is no edge between permanent set and tentative set, we exit
			for (int i = 1; i < s; i++){
				int m = t.elementAt(i);
				if (m!= src && val[t.elementAt(min)] > val[m])
					min = i;
			}
			
			//Now we find the minimum path length
			int k = t.elementAt(min);		//Get the value of the node with minimum path length
			
			//The smallest value is destination, so we remove it
			if (k == dest)
				return val[dest];
 
			//If the minimum value is MAX, it means that there is no egdges left
			if (val[k] == MAX)
				return -1;
 
			
			//Remove from tentative set
			t.removeElementAt(min);
			
			//Recalculate the value of the array val[]
			for (int i = 0; i < n; i++)
				if(i != src)
				{
					int tmp = MAX;
					int u = data[k].get(i);
					//There is an edge between i and k, calculate the length
					if (u < MAX)					
						tmp = val[k] + u;
					//Update val[i] if we have smaller path length
					if (tmp < val[i])
						val[i] = tmp;
				}
		}
		
		//Return the value of the shortest path length from src to dest
		return val[dest];
	}