数据结构和算法

toCharArray() //get char array of a String
Arrays.sort()  //sort an array
Arrays.toString(char[] a) //convert to string
charAt(int x) //get a char at the specific index
length() //string length
length //array size 
substring(int beginIndex) 
substring(int beginIndex, int endIndex)
Integer.valueOf() //string to integer
String.valueOf() //integer to string

class Node {
	int val;
	Node next;

	Node(int x){
	val = x;
	next = null;
	}
}

class Stack{
	Node top;

	public Node peek(){
		if (top != null){
			return top;
	}

		return null
	}

	public Node pop(){
		if (top == null){
			return null;
		}else{
			Node temp = top;
			top = top.next;
			return temp;
		}

	}

	public void push(Node n){
		if (n != null){
			n.next = top;
			top = n;
		}
	}
}

class Queue{
	Node first, last;

	public void enqueue(Node n){
		if(first == null){
			first = n;
			last = first;
		}else{
			last.next = n;
			last = n;
		}

	}

	public Node dequeue(){
		if(first == null){
			return null;
		}else{
			Node temp = new Node(first.val)
			first = first.next;
			return temp;
		}

	}
}

class TreeNode{
	int value;
	TreeNode left;
	TreeNode right;
}

class GraphNode{
	int val;
	GraphNode next;
	GraphNode[] neighbors;
	boolean visited;

	GraphNode(int x){
		val =x;
	}

	GraphNode(int x, GraphNode[] n){
		val = x;
		neighbors = n;
	}

	public String toString(){
		return "value:" + this.val;
	}
}

public class BubbleSort{
	public static void sort(int[] values){
		int temp;
		for(int i = 0; i < values.length; i++){
			for(int j = 0; j<values.length-i-1; j++){
				if(values[j] > values[j+1]){
					temp = values[j];
					values[j] = values[j+1];
					values[j+1] = temp;
				}
			}
		}
	}
}

public class InsertSort{
	public static int[] sort(int[] array){
		for(int i = 1; i < array.length; i++){
			int temp = array[i];
			for(int j = i - 1; j >= 0 && temp < array[j]; j--){
				array[j+1] = array[j];
				array[j] = temp;
			}
		}
	}
}

void QuickSort(int s[], int l, int r){
	if(l < r){
		int i = l, j = r, x = s[l];
		while(i < j)
		{
			while(i < j && s[j] >= x)
				j--;
			if(i < j)
				s[i++] = s[j];
			while(i < j && s[i] < x)
				i++;
			if(i < j)
				s[j--] = s[i];
		}
		s[i] = x;
		QuickSort(s, l, i - 1);
		QuickSort(s, i+1, r);
	}
}