20170113

Author: zhangbingyuan

test/src/main/java/offer/array/FindContinunousSequence.java

@@ -0,0 +1,47 @@
+package offer.array;
+
+import java.util.ArrayList;
+
+/**
+ * 小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。
+ * 但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,
+ * 他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列?
+ * Good Luck!
+ 输出描述:
+ 输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
+ */
+public class FindContinunousSequence {
+    public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
+        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>> ();
+        if(sum<=0){
+            return res;
+        }
+        int small=1;
+        int big=2;
+        int currSum=small+big;
+        int middle=(1+sum)/2;
+        while(small<middle){
+            if(currSum==sum){
+                ArrayList<Integer> list=new ArrayList<>();
+                for(int i=small;i<=big;i++){
+                    list.add(i);
+                }
+                res.add(list);
+            }
+            while(currSum>sum&&small<middle){
+                currSum=currSum-small;
+                small++;
+                if(currSum==sum){
+                    ArrayList<Integer> list=new ArrayList<>();
+                    for(int i=small;i<=big;i++){
+                        list.add(i);
+                    }
+                    res.add(list);
+                }
+            }
+            big++;
+            currSum+=big;
+        }
+        return res;
+    }
+}

test/src/main/java/offer/array/FindGreatestSumOfSubArray.java

@@ -0,0 +1,30 @@
+package offer.array;
+
+/**
+ *
+ * 连续子数组的最大和
+ * HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,
+ * 常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,
+ * 并期望旁边的正数会弥补它呢？
+ * 例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)
+ */
+public class FindGreatestSumOfSubArray {
+    public int FindGreatestSumOfSubArray(int[] array) {
+        if(array==null||array.length==0){
+            return 0;
+        }
+        int currentSum=0;
+        int currentMax=Integer.MIN_VALUE;
+        for(int i=0;i<array.length;i++){
+            if(currentSum<0){
+                currentSum=array[i];
+            }else{
+                currentSum+=array[i];
+            }
+            if(currentSum>currentMax){
+                currentMax=currentSum;
+            }
+        }
+        return currentMax;
+    }
+}

test/src/main/java/offer/array/FindInMatrix.java

@@ -0,0 +1,57 @@
+package offer.array;
+
+/**
+ * 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
+ * 请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
+ * 解答：
+ *
+ * 思路一：
+ * 利用二维数组由上到下，由左到右递增的规律，
+ * 那么选取右上角或者左下角的元素a[row][col]与target进行比较，
+ * 当target小于元素a[row][col]时，那么target必定在元素a所在行的左边,
+ * 即col--；
+ *
+ * 思路二：
+ * 把每一行看成有序递增的数组，
+ * 利用二分查找，
+ * 通过遍历每一行得到答案，
+ * 时间复杂度是nlogn
+ */
+public class FindInMatrix {
+
+    public boolean Find1(int[][] array, int target) {
+        if (array == null) {
+            return false;
+        }
+        int len = array.length - 1;
+        int i = 0;
+        while ((i < array[0].length) && (len >= 0)) {
+            if (array[len][i] < target) {
+                i++;
+            } else if (array[len][i] > target) {
+                len--;
+            } else {
+                return true;
+            }
+        }
+        return false;
+
+    }
+    public boolean Find2(int[][] array,int target){
+        for(int i=0;i<array.length;i++){
+            int low=0;
+            int high=array[i].length-1;
+            while(low<=high){
+                int mid=(low+high)/2;
+                if(target>array[i][mid]){
+                    low=mid+1;
+                }else if(target<array[i][mid]){
+                    high=mid-1;
+                }else{
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

test/src/main/java/offer/array/FindNumbersWithSum.java

@@ -0,0 +1,37 @@
+package offer.array;
+
+import java.util.ArrayList;
+
+/**
+ * 输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S，
+ * 如果有多对数字的和等于S，输出两个数的乘积最小的。
+ 输出描述:
+ 对应每个测试案例，输出两个数，小的先输出。
+ */
+public class FindNumbersWithSum {
+    public ArrayList<Integer> FindNumbersWithSum(int [] array, int sum) {
+        ArrayList<Integer> res=new ArrayList<>();
+        if(array==null){
+            return res;
+        }
+        int i=0;
+        int j=array.length-1;
+        int currSum=0;
+        while(i<j){
+            currSum=array[i]+array[j];
+            if(currSum==sum){
+                res.add(array[i]);
+                res.add(array[j]);
+            }
+            if(currSum<sum){
+                i++;
+            }else {
+                j--;
+            }
+            if(res.size()==2){
+                return res;
+            }
+        }
+        return res;
+    }
+}

test/src/main/java/offer/array/FindNumsAppearOnce.java

@@ -0,0 +1,27 @@
+package offer.array;
+
+/**
+ * 一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
+ */
+public class FindNumsAppearOnce {
+    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
+        if(array==null){
+            return;
+        }
+        int xor=0;
+        for(int i=0;i<array.length;i++){
+            xor^=array[i];
+        }
+        //找到为1的位
+        int flag=1;
+        while((xor&flag)==0)
+            flag=flag<<1;
+        for(int i=0;i<array.length;i++){
+            if((array[i]&flag)!=0){
+                num1[0]^=array[i];
+            }else{
+                num2[0]^=array[i];
+            }
+        }
+    }
+}

test/src/main/java/offer/array/GetLeastNumbers.java

@@ -0,0 +1,50 @@
+package offer.array;
+
+import java.util.ArrayList;
+
+/**
+ * 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
+ */
+public class GetLeastNumbers {
+    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
+
+        if(input==null||k<1||k>input.length){
+            return new ArrayList<Integer>();
+        }
+        create_heap(input,k);
+        for(int i=k;i<input.length;i++){
+            if(input[i]<input[0]){
+                input[0]=input[i];
+                percolate_down(input,0,k);
+            }
+        }
+        ArrayList<Integer> list=new ArrayList<>();
+        for(int i=0;i<k;i++){
+            list.add(input[i]);
+        }
+        return list;
+    }
+    public  void create_heap(int[] arr,int heapSize){
+        for(int i=heapSize/2-1;i>=0;i--){
+            percolate_down(arr,i,heapSize);
+        }
+    }
+    public void percolate_down(int[] arr,int r,int heapSize){
+        int s=2*r+1;
+        while(s<heapSize){
+            if(s<(heapSize-1)&&arr[s]<arr[s+1]){
+                s++;
+            }
+            if(arr[s]>arr[r]){
+                int temp=arr[s];
+                arr[s]=arr[r];
+                arr[r]=temp;
+                r=s;
+                s=2*r+1;
+            }else{
+                break;
+            }
+
+        }
+    }
+}

test/src/main/java/offer/array/GetNumberOfK.java

@@ -0,0 +1,62 @@
+package offer.array;
+
+/**
+ *
+ * 统计一个数字在排序数组中出现的次数。
+ */
+public class GetNumberOfK {
+    public static int GetNumberOfK(int[] array, int k) {
+        if (array == null || array.length == 0) {
+            return 0;
+        }
+        int start = getFirstK(array, k, 0, array.length - 1);
+        int end = getLastK(array, k, 0, array.length - 1);
+        if (end>-1&&start>-1) {
+            return end - start + 1;
+        }else{
+            return 0;
+        }
+    }
+
+    public static int getFirstK(int[] arr, int k, int low, int high) {
+        if (low > high) {
+            return -1;
+        }
+        int mid = (low + high) >> 1;
+        if (arr[mid] > k) {
+            return getFirstK(arr, k, low, mid - 1);
+        } else if (arr[mid] < k) {
+            return getFirstK(arr, k, mid + 1, high);
+        } else {
+            if ((mid > 0 && arr[mid - 1] != k)||mid==0) {
+                return mid;
+            } else {
+
+                return getFirstK(arr, k, low, mid - 1);
+
+            }
+        }
+
+    }
+
+    public static int getLastK(int[] arr, int k, int low, int high) {
+        if (low > high) {
+            return -1;
+        }
+        int mid = (low + high) >> 1;
+        if (arr[mid] > k) {
+            return getLastK(arr, k, low, mid - 1);
+        } else if (arr[mid] < k) {
+            return getLastK(arr, k, mid + 1, high);
+        } else {
+            if ((mid < arr.length-1 && arr[mid + 1] != k)||mid==arr.length-1) {
+                return mid;
+            } else {
+
+                return getLastK(arr, k, mid + 1, high);
+
+            }
+        }
+
+    }
+}

test/src/main/java/offer/array/GetUglyNumber.java

@@ -0,0 +1,29 @@
+package offer.array;
+
+/**
+ * 把只包含因子2、3和5的数称作丑数（Ugly Number）。
+ * 例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
+ */
+public class GetUglyNumber {
+    public int GetUglyNumber_Solution(int index) {
+        if(index<=0){
+            return 0;
+        }
+        int[] res=new int[index];
+        int i2=0;
+        int i3=0;
+        int i5=0;
+        res[0]=1;
+        int count=1;
+        while(count<index){
+            int tmp=Math.min(Math.min(res[i2]*2,res[i3]*3),res[i5]*5);
+            if(tmp==res[i2]*2) i2++;
+            if(tmp==res[i3]*3) i3++;
+            if(tmp==res[i5]*5) i5++;
+            res[count++]=tmp;
+
+        }
+
+        return res[index-1];
+    }
+}