剑指offer题目31-40

面试题31：连续字数组的最大和

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        int len = array.length;
        if(len==0) return 0;
        int[] dp = new int[len];
        dp[0] = array[0];
        int res = dp[0];
        for(int i=1;i<len;i++){
            dp[i] = Math.max(array[i],dp[i-1]+array[i]);
            res = Math.max(dp[i],res);
        }
        return res;
    }
}

面试题32：从1到n中出现的1的个数

public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
        int cnt = 0;
        int i = 1;
        int current = 0,after = 0 ,before = 0;
        while((n/i)!=0){
            current = (n/i)%10;
            before  = n /(i*10);
            after   = n - (n/i)*i;
            if(current > 1){
                cnt += (before + 1)*i;
            }else if(current == 0){
                cnt += before * i;
            }else if(current == 1){
                cnt += before * i + after + 1;
            }
            i *= 10;
        }
        return cnt;
    }
}

面试题33：把数组排列成最小的数

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Arrays;
public class Solution {
    public String PrintMinNumber(int [] numbers) {
        StringBuilder res = new StringBuilder();
        if(numbers == null || numbers.length==0){
            return "";
        }
        String[] nums =new String[numbers.length];
        for(int i=0;i<numbers.length;i++){
            nums[i] = Integer.toString(numbers[i]);
        }
        Comparator<String> comp = new Comparator<String>(){
            @Override
            public int compare(String str1,String str2){
                return (str1 + str2).compareTo(str2 + str1);
            }
        };
        Arrays.sort(nums,comp);
        if(nums[nums.length-1].equals("0")){
            return "0";
        }
        for(int i=0;i<numbers.length;i++){
            res.append(nums[i]);
        }
        return res.toString();
    }
}

面试题34：丑数

public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if(index == 0) return 0;
        int factor2 = 2,factor3 = 3,factor5 = 5;
        int index2 = 0,index3 = 0,index5=0;
        int[] ugly = new int[index];
        ugly[0] = 1;
        for(int i=1;i<index;i++){
            int min  = Math.min(factor2,Math.min(factor3,factor5));
            ugly[i]  = min;
            if(min == factor2){
                factor2 = 2 * ugly[++index2];
            }
            if(min == factor3){
                factor3 = 3 * ugly[++index3];
            }
            if(min == factor5){
                factor5 = 5 * ugly[++index5];
            }
        }
        return ugly[index-1];
    }
}

面试题35：第一个只出现一次的字符位置

import java.util.HashMap;
public class Solution {
    public int FirstNotRepeatingChar(String str) {
        if(str.length() == 0) return -1;
        char[] arr = str.toCharArray();
        HashMap<Character,Integer> map = new HashMap<Character,Integer>();
        for(int i=0;i<arr.length;i++){
            if(map.get(arr[i]) == null){
                map.put(arr[i],1);
            }else{
                map.put(arr[i],map.get(arr[i])+1);
            }
        }
        boolean flag = false;
        int index=0;
        for(;index<arr.length;index++){
            if(map.get(arr[index]) == 1){
                flag = true;
                break;
            }
        }
        if(flag == true){return index;}
        else return -1;
    }
}

面试题36：数组中的逆序对

public class Solution {

    public int InversePairs(int [] array) {
        int cnt = 0;
        cnt = inverseHelp(array,0,array.length-1);
        return cnt;
    }
    public int inverseHelp(int[] arr,int start,int end){
        int cnt = 0;
        if(start < end){
            int mid = start + (end - start)/2;
            cnt += inverseHelp(arr,start,mid);
            cnt += inverseHelp(arr,mid+1,end);
            cnt += merge(arr,start,mid,end);
        }
        return cnt;
    }
    public int merge(int[] arr,int start,int mid,int end){
        int cnt = 0,i=start,j=mid+1,k=start;
        int[] tmp = new int[arr.length];
        while(i<=mid && j<=end){
            if(arr[i]>arr[j]){
                cnt += end - j + 1;
                tmp[k++] = arr[i++];
            }else{
                tmp[k++] = arr[j++];
            }
        }
        while(i<=mid) tmp[k++] = arr[i++];
        while(j<=end) tmp[k++] = arr[j++];
        for(int p=start;p<=end;p++){
            arr[p] = tmp[p];
        }
        return cnt;
    }
}

平衡二叉树

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root == null) return true;
        return height(root) != -1;
    }
    public int height(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftHight = height(root.left);
        if(leftHight == -1){return -1;}
        int rightHight = height(root.right);
        if(rightHight == -1){return -1;}
        if(leftHight - rightHight<-1 || leftHight - rightHight > 1){
            return -1;
        }
        return Math.max(leftHight,rightHight)+1;
    }
}

面试题37：求两个链表的第一个公共结点

public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        int len1 = getLen(pHead1);
        int len2 = getLen(pHead2);
        ListNode pFirst = (len1 > len2)?pHead1:pHead2;
        ListNode pSecond = (len1 > len2)?pHead2:pHead1;
        int i=0;
        while(i<Math.abs(len1 - len2) && pFirst != null){
            i++;
            pFirst = pFirst.next;
        }
        while(pFirst != pSecond && pFirst != null && pSecond != null){
            pFirst = pFirst.next;
            pSecond = pSecond.next;
        }
        return pFirst;
    }
    public int getLen(ListNode p){
        int len = 0;
        while(p != null){
            len ++;
            p = p.next;
        }
        return len;
    }
}

面试题38：数字在排序数组中出现的次数

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
       int num = 0;
       if(array != null && array.length>0){
            int first = getFirstK(array,k,0,array.length - 1);
            int last  = getLastK(array,k,0,array.length - 1);
            if(first>-1 && last>-1){
                num  = last - first + 1;
            }
       }
       return num;
    }
    public int getFirstK(int[] array,int k,int start,int end){
        if(start > end){
            return -1;
        }
        int mid = (start + end)/2;
        if(array[mid] == k){
            if(mid>0 && array[mid-1]!=k || mid == 0)
                return mid;
            else
                end = mid - 1;
        }else if(array[mid] > k){
            end = mid - 1;
        }else{
            start = mid + 1;
        }
        return getFirstK(array,k,start,end);
    }
    public int getLastK(int[] array,int k,int start,int end){
        if(start > end){
            return -1;
        }
        int mid = (start + end)/2;
        if(array[mid] == k){
            if(mid<array.length-1 && array[mid+1]!=k || mid == array.length-1)
                return mid;
            else
                start = mid + 1;
        }else if(array[mid] > k){
            end = mid - 1;
        }else{
            start = mid + 1;
        }
        return getLastK(array,k,start,end);
    }
}

面试题39：二叉树的深度

public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(TreeDepth(root.left) , TreeDepth(root.right))+1;
    }
}

面试题40：数组中只出现1次的数字

public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        if(array == null || array.length<2) return;
        int diff = 0;
        for(int num : array){
            diff ^= num;
        }
        diff = Integer.highestOneBit(diff);
        for(int num : array){
            if((diff & num) == 0){
                num1[0] ^= num;
            }else{
                num2[0] ^= num;
            }
        }
        return;
    }
}

​