Merge pull request Hearen#15 from zhewen166/master

week one

Author: Hearen

LiuCaiZheng/src/com/cz/algorithm/learn/first/RotatedSortedArray.java

@@ -0,0 +1,27 @@
+package com.cz.algorithm.learn.first;
+
+public class RotatedSortedArray {
+
+	public static void main(String[] args) {
+		int[] nums = {5, 6 ,7,0, 1 ,1,2,2,3,3 ,4};
+		int target = 3;
+		System.out.println(search(nums, target));
+	}
+	public static boolean search(int[] nums, int target) {
+		int right  = nums.length - 1;
+		int left  = 0;
+		while (left <=  right) {
+			    int middle = (left + right)/2 ; 
+			    System.out.println(middle + "   " + nums[middle]);
+				if( target ==  nums[middle]) {
+					return true;
+				} else if(target > nums[middle]) {
+					left = middle + 1;
+				
+				} else if(target <= nums[middle]) {
+					right = middle - 1;
+				}
+	 }
+	 return false;
+	}
+} //done

LiuCaiZheng/src/com/cz/algorithm/learn/first/SumClosest.java

@@ -0,0 +1,26 @@
+package com.cz.algorithm.learn.first;
+
+public class SumClosest {
+
+	public static void main(String[] args) {
+		int[] nums = {-1, 2 ,1 ,-4, 4};
+		int target = 1;
+		System.out.println(threeSumClosest(nums, target));
+	}
+
+	public static int threeSumClosest(int[] nums, int target) {
+
+		int len = nums.length;
+		if(len < 3) {
+			return 0;
+		}
+		int sum = nums[0] + nums[1] + nums[2];
+		for(int i = 1; i < len - 2 ; i ++) {
+			int temp = nums[i] + nums[i + 1] + nums[i + 2];
+			if(Math.abs(sum - target)  > Math.abs( temp -target)) {
+				sum = temp;
+			} 
+		}
+		return sum;
+	}
+}//done

LiuCaiZheng/src/com/cz/algorithm/learn/first/TrappingRainWater.java

@@ -0,0 +1,42 @@
+package com.cz.algorithm.learn.first;
+
+public class TrappingRainWater {
+
+	public static void main(String[] args) {
+        int[] A = {0,1,0,2,1,0,1,3,2,1,2,1};
+        System.out.println(trap(A));
+	}
+	
+//	public static int trap(int[] A) {
+//		int left = 0;
+//		int right = A.length - 1;  //
+//		int sum = 0;    //the sum of the rain
+//		int pre = 0;     //recode the previous one or more 
+//		while(left < right) {
+//			
+//		}
+//		return 0;
+//	}
+
+	public static  int trap(int[] A) {
+		 int left = 0 , right = A.length-1;
+	        int sum = 0;
+	        int pre = 0;
+	        while(left < right){
+	            sum += (Math.min(A[left], A[right])-pre) * (right-left-1);
+	            pre = Math.min(A[left],A[right]);
+	            if(A[left] > A[right]){ 
+	                int temp = right-1;
+	                while(left < temp && A[temp] <= pre){sum-=A[temp];temp--;}
+	                if(left < temp) sum -= pre;
+	                right = temp;
+	            }else{
+	                int temp = left+1;
+	                while(temp < right && A[temp] <= pre){sum-=A[temp];temp++;}
+	                if(temp < right) sum -= pre;
+	                left = temp;
+	            }
+	        }
+	        return sum;
+	}
+}

LiuCaiZheng/src/com/cz/algorithm/learn/first/WordSearch.java

@@ -0,0 +1,58 @@
+package com.cz.algorithm.learn.first;
+
+public class WordSearch {
+
+	public static void main(String[] args) {
+		
+		String word = "ABCCED";
+		char[][] words = {
+			{'A','B','C','E'},
+			{'S','F','C','S'},
+			{'A','D','E','E'}
+		};
+	    System.out.println(exist(words,word));
+	}
+	/**
+	 * */
+	 public static  boolean exist(char[][] board, String word) {
+	
+//		    if(word == "") return true;
+//		    boolean[][]  visited  = new boolean[board.length][board[0].length];
+//		    
+//		    for(int i = 0 ; i < board.length ; i ++) {
+//		    	for(int j = 0; j < board[i].length ; j ++) {
+//		    		visited[i][j] = false;
+//		    	}
+//		    }
+//		    char [] wordCharArray = word.toCharArray();
+//		    int outLen = board.length;
+//		    int innerLen = board[0].length;
+//	        return false;
+		 
+		        int m = board.length;  
+		        int n = board[0].length;  
+		        boolean[][] visited = new boolean[m][n];  
+		        for (int i = 0; i < m; i++) {  
+		            for (int j = 0; j < n; j++) {  
+		                if (dfs(board, visited, i, j, word, 0)) return true;  
+		            }  
+		        }  
+		        return false;  
+		    }  
+	 
+	   public static boolean dfs(char[][] board, boolean[][] visited, int x, int y, String word, int k) {  
+	        if (k == word.length()) return true;  
+	        if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) return false;  
+	        if (visited[x][y]) return false;  
+	        if (board[x][y] != word.charAt(k)) return false;  
+	          
+	        visited[x][y] = true;  
+	        if (dfs(board, visited, x - 1, y, word, k + 1)) return true;  
+	        if (dfs(board, visited, x + 1, y, word, k + 1)) return true;  
+	        if (dfs(board, visited, x, y - 1, word, k + 1)) return true;  
+	        if (dfs(board, visited, x, y + 1, word, k + 1)) return true;  
+	        visited[x][y] = false;  
+	          
+	        return false;  
+	    }  
+}

LiuCaiZheng/src/com/cz/algorithm/learn/first/removeDuplicates.java

@@ -0,0 +1,44 @@
+package com.cz.algorithm.learn.first;
+
+public class removeDuplicates {
+
+	public static void main(String[] args) {
+		int[] nums = {1,1,1,2,2,3 };
+		System.out.println(removeDuplicate(nums));
+	}
+	
+	/*
+	 * return the lentgh of the array.
+	 * */
+	 public static int removeDuplicate(int[] A) {
+		   int n = A.length;
+		   if(n==0)return 0;
+	        if(n==1)return 1;
+	        int num=1,i,temp=A[1];
+	        for(i=2;i<n;++i)
+	            if(A[i]!=A[i-2]) {
+	                A[num++]=temp;
+	                temp=A[i];
+	            }
+	        A[num++]=temp;
+	        return num;
+	}
+	
+	 /**
+	  * compare from the last elements.
+	  * */
+//	 public int removeDuplicates(int[] A) {
+//		    if(A.length ==0){
+//		      return 0;
+//		    }
+//		    int count=1;
+//		    for(int i=1; i<A.length; ++i){
+//		      if(A[i] != A[i-1]){ //注意这行代码
+//		        A[count]=A[i];
+//		        count++;
+//		      }
+//		    }
+//		    return count;
+//		  }
+
+}