剑指Offer学习笔记（4）——时间效率

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

public class Solution {
    /**
     * 采用阵地攻守的思想： 第一个数字作为第一个士兵，守阵地；count = 1；
     * 遇到相同元素，count++; 遇到不相同元素，即为敌人，同归于尽,count--；
     * 当遇到count为0的情况，又以新的i值作为守阵地的士兵，继续下去，到最后还留在阵地上的士兵，
     * 有可能是主元素。 再加一次循环，记录这个士兵的个数看是否大于数组一般即可。
     * @param array
     * @return
     */
    public int MoreThanHalfNum_Solution(int[] array) {
        int length = array.length;
        if (array == null || length <= 0) {
            return 0;
        }
 
        int result = array[0];
        int times = 1;
        for (int i = 1; i < length; i++) {
            if (times == 0) {
                result = array[i];
                times = 1;
            } else {
                if (array[i] == result) {
                    times++;
                } else {
                    times--;
                }
            }
        }
 
         
        times = 0;
        for (int i = 0; i < length; i++) {
            if (result == array[i]) {
                times++;
            }
        }
 
        if (times * 2 < length) {
            result = 0;
        }
        return result;
    }
}

最小的K个数
题目描述：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
import java.util.ArrayList;
public class Solution {
    /**
     * 最小的K个数
     * @param input
     * @param k
     * @return
     */
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
        ArrayList<Integer> aList = new ArrayList<Integer>();
        if (input.length < k || input == null) {
            return aList;
        }
        if (k == 0) {
            return aList;
        }
        int len = input.length;
        findSort(input, 0, len - 1, k);
        for(int i=0;i<k;i++){
            aList.add(input[i]);
        }
        return aList;
    }
 
    /*
    递归查找
    */
    private void findSort(int[] input, int p, int r, int k) {
        if (p == r) {
            return;
        }
        int q = partition(input, p, r);
        int temp = q - p + 1;///当前的长度
         
        if (temp == k) {
            return;
        } else if (k < temp) {
            findSort(input, p, q - 1, k);
        } else {
            findSort(input, q + 1, r, k - temp);
        }
 
    }
   /*
    分治法来实现最小k的查找/*
    */
    private int partition(int[] input, int p, int q) {
        int x = input[q];
        int i = p - 1;
        for (int j = p; j < q ; j++) {
            if (input[j] <= x) {
                i = i + 1;
                int temp = input[i];
                input[i] = input[j];
                input[j] = temp;
            }
        }
 
        input[q] = input[i + 1];
        input[i + 1] = x;
        return i + 1;
    }
}
连续子数组的最大和
题目描述：HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
public class Solution {
    /*
    分治法求解最大字数组 这个算法自己曾经实现过 不过有些问题没有解决
     
    */
     
   public int FindGreatestSumOfSubArray(int[] array) {
        if (array.length == 0 || array == null) {
            return 0;
        }
         
        int result = findMaxSubArray(array, 0, array.length - 1);
        return result;
    }
 
    private int findMaxSubArray(int[] arr, int left, int right) {
        int result=0;
        if (left == right) {
            result=arr[left];
            return result;
        } else {
            int mid = (left + right) / 2;
            int saleft = findMaxSubArray(arr, left, mid);
            int saright = findMaxSubArray(arr, mid+1, right);
 
            int sacross = findCrossingMaxSubArray(arr, left, mid,
                    right);
 
            if (saleft > saright
                    && saleft > sacross) {
                return saleft;
            } else if (saright > saleft
                    && saright > sacross) {
                return saright;
            } else {
                return sacross;
            }
        }
    }
 
    private int findCrossingMaxSubArray(int[] arr, int left, int mid, int right) {
        int sum=0;
        int begin=0;
        int end=0;
 
        int leftsum = arr[mid] ;
        sum=arr[mid];
        for(int i=mid-1;i>=left;i--){
            sum=sum+arr[i];
            if(sum>leftsum){
                leftsum=sum;
                begin=i;
            }
        }
        int rightsum = arr[mid+1];
        sum=arr[mid+1];
        for(int i=mid+2;i<=right;i++){
            sum=sum+arr[i];
            if(sum>rightsum){
                rightsum=sum;
                end=i;
            }
        }
        return leftsum+rightsum;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Solution {
    public static int FindGreatestSumOfSubArray(int[] array) {
        if(array.length==0) return 0;
        int sum = 0 ,result = array[0];
        for (int i = 0; i < array.length; i++) {
            if(sum<0)
                sum = array[i];
            else
                sum += array[i];
            result = Math.max(result, sum);
        }
        return result;
    }
}
整数中1出现的次数（从1到n整数中1出现的次数）
题目描述：求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
 
        if(n<=0){
            return 0;
        }
        String str = Integer.toString(n);
        char[] strN=str.toCharArray();
         
        return NumberOf1(strN,0);
         
 
    }
 
    private int NumberOf1(char[] strN,int loc) {
        if(strN==null||strN[loc]<'0'||strN[loc]>'9'||strN[loc]==''){
            return 0;
        }
         
        int first=strN[loc]-'0';
        //剩余长度
        int len = strN.length-loc;//剩余 长度 下标是从0开始
         
        if(len==1&&first==0){
            return 0;
        }
        if(len==1&&first>0){
            return 1;
        }
         
        int numFirstDigit=0;
        if(first>1){
            numFirstDigit=PowerBase10(len-1);
        }else if(first==1){
            numFirstDigit=Atoi(strN,loc+1)+1;//将后序的字符转换成为数值
        }
        //除了开头第一位的所有其他的四位数中的情况
        int numOtherDigit=first*(len-1)*PowerBase10(len-2);
         
        int numRecursive = NumberOf1(strN, loc+1);
         
        return numFirstDigit+numOtherDigit+numRecursive;
         
    }
 
    private int Atoi(char[] strN, int loc) {
        int num = 0;
        for(int i=loc;i<strN.length;i++){
            num=num*10+(strN[i]-'0');
        }
        return num;
    }
 
    private int PowerBase10(int n) {
         
        int res=1;
        for(int i=0;i<n;i++){
            res*=10;
        }
        return res;
    }
}
把数组排成最小的数
题目描述：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import java.util.ArrayList;
 
public class Solution {
   /**
     * 生成最小数值的数组排列 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
     * 例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
     *
     * @param numbers
     * @return
     *
     *         这个题目主要是想找到一个排序规则，数组根据这个排序规则来排成一个最小的数字。要确定排序规则就要比较两个数字，也就是比较
     *         m和n，我们需要一个规则判断m和n哪一个应该排在前面，而不是仅仅比较两个数字的值哪个更大。
     *
     *         根据题目要求，两个数字m和n 拼接成为mn和nm如果mn小于nm，那么我们应该打印出mn，也就是m应该排在n 的前面。
     *         我们定义此时m<n.这是我们自定义的大小比较关系。
     *
     *         拼接称为字符串，按照字符串比较大小就可以了。
     */
    public String PrintMinNumber(int[] numbers) {
 
        if (numbers.length == 0 || numbers == null) {
            return "";
        }
 
        int len = numbers.length;
        String[] strNums = new String[len];
        for (int i = 0; i < len; i++) {
            strNums[i] = Integer.toString(numbers[i]);
            // construct string from a int array
        }
 
        String res = qSortStrArray(strNums, len);
 
        return res;
    }
 
    private String qSortStrArray(String[] strNums, int len) {
        if (strNums == null || strNums.length == 0)
            return null;
         
        for(int i=0;i<len-1;i++){
            for(int j=i;j<len;j++){
                if((strNums[i]+strNums[j]).compareTo(strNums[j]+strNums[i])>0){
                    String temp = strNums[i];
                    strNums[i]=strNums[j];
                    strNums[j]=temp;
                }
            }
        }
         
        String res="";
        for(int i=0;i<len;i++){
            res+=strNums[i];
        }
        return res;
 
    }
}
踏实 踏踏实实~
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/mrzhang123/p/5365798.html