剑指offer（1/12）

数组中出现长度超过一半的数字

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

import java.util.Arrays;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        Arrays.sort(array);
        int count = 0;
        int half = array.length/2;
        for(int i = 0 ;i < array.length; i++){
            if(array[i] == array[half]){
                count++;
            }
        }
        if(count>half)
            return array[half];
        else
            return 0;
        
    }
}

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers)
    {
        // 因为用到了sort，时间复杂度O(NlogN)，并非最优
        if(numbers.empty()) return 0;
        sort(numbers.begin(),numbers.end()); // 排序，取数组中间那个数
        int middle = numbers[numbers.size()/2];
         
        int count=0; // 出现次数
        for(int i=0;i<numbers.size();++i)
        {
            if(numbers[i]==middle) ++count;
        }
        return (count>numbers.size()/2) ? middle :  0;
    }
};

找出最小的K个数

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

import java.util.ArrayList;
public class Solution {
    //快速排序
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        if(k > input.length) return result;
        Solution sol = new Solution();
        sol.QuickSort(input,0,input.length-1);
        for(int i = 0; i < k; i++)
            result.add(input[i]);
        return result;
    }
    public void QuickSort(int a[] ,int begin, int end){
        if(begin>end || a.length==0 || a==null)
            return;
        int num = a[begin];
        int i = begin,j = end;
        while(i != j){
            while(a[j]>=num && i<j){
                j--;
            }
            while(a[i]<=num && i<j){
                i++;
            }
            if(i < j){
                int t = a[j];
                a[j] = a[i];
                a[i] = t;
            }
        }
        a[begin] = a[i];
        a[i] = num;
        QuickSort(a,begin,i-1);
        QuickSort(a,i+1,end);
    }
}

class Solution {
public:
   vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> res;
        if(input.empty()||k>input.size()) return res;
        sort(input.begin(),input.end());
        for(int i=0;i<k;i++)
            res.push_back(input[i]);
        return res;
    }
};

连续子数组最大的和

输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为 O(n).

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

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int cursum=array[0];
        int maxsum=array[0];
        for(int i=1;i<array.size();i++){
            cursum+=array[i];
            if(cursum<array[i])
                cursum=array[i];
            if(cursum>maxsum)
                maxsum=cursum;           
        }
    return maxsum;
    }
};