剑指offer刷题总结——数组篇（三）

蔚落 2021-09-21 03:24 297阅读 0赞

> 星级：5

### 1.顺时针打印矩阵 ###

**【题目】**

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下 4 X 4 矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字 1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

**【代码】**

public ArrayList<Integer> printMatrix(int [][] matrix) { 
    
            int width,height,x,y,count,n;
            height = matrix.length;
            width = matrix[0].length;
            // 遍历游标
            x = 0;
            y = 0;
            count = 0;
            // 元素个数
            n = height * width;
    
            boolean[][] flag = new boolean[height][width];
            ArrayList<Integer> list = new ArrayList<>();
    
            while (count < n) { 
                // x不变，y增加
                while (y<width && !flag[x][y]) { 
                    list.add(matrix[x][y]);
                    flag[x][y] = true;
                    count ++;
                    y ++;
                }
                y--;
                x++;
                // x增加，y不变
                while (x<height && !flag[x][y]) { 
                    list.add(matrix[x][y]);
                    flag[x][y] = true;
                    count ++;
                    x ++;
                }
                x--;
                y--;
                // x不变，y减少
                while (y>=0 && !flag[x][y]) { 
                    list.add(matrix[x][y]);
                    flag[x][y] = true;
                    count ++;
                    y--;
                }
                y++;
                x--;
                // x变少，y不变
                while (x>=0 && !flag[x][y]) { 
                    list.add(matrix[x][y]);
                    flag[x][y] = true;
                    count ++;
                    x--;
                }
                x++;
                y++;
            }
    
    
            return list;
        }

**【思考】**

需要注意边界是否越界以及，游标（x,y）经过x++或者y++之后，定位在什么地方，需要进行手动的转弯。

--------------------

### 2.数组中出现次数超过一半的数字 ###

**【题目】**

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

**【代码】**

package swear2offer.array;
    
    import java.util.Arrays;
    
    public class Half { 
    
        /** * 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。 * 例如输入一个长度为 9 的数组 {1,2,3,2,2,2,5,4,2}。 * 由于数字 2 在数组中出现了 5 次，超过数组长度的一半，因此输出 2。如果不存在则输出 0。 * */
        public int MoreThanHalfNum_Solution(int [] array) { 
    
            int n,count,i,k;
    
            n = array.length;
    
            if (n == 0) return 0;
    
            if (n == 1) return array[0];
    
            // 标记数组
            int[] flag = new int[n];
            // 给数组排序
            Arrays.sort(array);
    
            count = 1;
            flag[0] = 1;
            for (i=1; i<n; i++) { 
                // 因为是排序好的，如果存在相等的
                if (array[i-1] == array[i]) { 
                    count ++;
                } else { 
                    count = 1;
                }
                flag[i] = count;
            }
    
            count = 0;
            k = 0;
            for (i=1; i<n; i++) { 
                if (count < flag[i]) { 
                    count = flag[i];
                    k = i;
                }
            }
    
            return count > n/2 ? array[k] : 0;
    
        }
    }

**【代码2】**

不需要的排序的巧妙方法：

用 preValue 记录上一次访问的值，count 表明当前值出现的次数，如果下一个值和当前值相同那么 count++；如果不同 count–，减到 0 的时候就要更换新的 preValue 值了，因为如果存在超过数组长度一半的值，那么最后 preValue 一定会是该值。

public int MoreThanHalfNum_Solution(int [] array) { 
            if(array == null || array.length == 0)return 0;
            int preValue = array[0];//用来记录上一次的记录
            int count = 1;//preValue出现的次数（相减之后）
            for(int i = 1; i < array.length; i++){ 
                if(array[i] == preValue)
                    count++;
                else{ 
                    count--;
                    if(count == 0){ 
                        preValue = array[i];
                        count = 1;
                    }
                }
            }
            int num = 0;//需要判断是否真的是大于1半数
            for(int i=0; i < array.length; i++)
                if(array[i] == preValue)
                    num++;
            return (num > array.length/2)?preValue:0;
     
        }

**【思考】**

当i从1而不是0开始的时候，通常需要特殊考虑只有一个元素的情况

--------------------

### 3.连续子数组的最大和 ###

**【题目】**

给一个数组，返回它的最大连续子序列的和，例如:\{6,-3,-2,7,-15,1,2,2\}, 连续子向量的最大和为 8 (从第 0 个开始，到第 3 个为止)

**【代码】**

/** * 给一个数组，返回它的最大连续子序列的和 * * 例如:{6,-3,-2,7,-15,1,2,2}, 连续子向量的最大和为 8 (从第 0 个开始，到第 3 个为止) * * 非常典型的dp * * 动规通常分为顺推和逆推两个不同的方向 * 要素：边界，状态转移公式，数组代表含义 * array[] * dp[x],从各个正数开始连续到达x时，最大和，即连续子序列的最大和 * 需要注意：1.从第一个正数开始，2.是连续序列 * 通常情况下，连续序列的复杂度为O(n),非连续序列为O(n*n) * */
        public int FindGreatestSumOfSubArray(int[] array) { 
            int n,i,len,res;
            int[] dp;
    
            n = array.length;
    
            if (n == 0 || array == null) return 0;
            if (n == 1) return array[0];
    
            dp = new int[n];
            dp[0] = array[0];
            len = 0;
            res = array[0];
            for (i=1; i<n; i++) { 
                len = dp[i-1] + array[i];
    
                if (dp[i-1] < 0) { 
                    dp[i] = array[i];
                } else { 
                    dp[i] = len;
                }
    
                if (res < dp[i]) res = dp[i];
            }
    
            return res;
        }

**【思路】**

从前往后遍历，最大的连续子序列的和是由当前元素和之前的最大连续子序列的和叠加在一起形成的。如果之前的最大连续子序列的和大于零，我们可以继续累加，如果小于零，则需要舍去之前的子序列，重新从当前的数字开始累加。时间复杂度为 O (n)

--------------------

### 4.整数中 1 出现的次数 ###

**【题目】**

求出 1~13 的整数中 1 出现的次数，并算出 100~1300 的整数中 1 出现的次数？为此他特别数了一下 1~13 中包含 1 的数字有 1、10、11、12、13 因此共出现 6 次，但是对于后面问题他就没辙了。ACMer 希望你们帮帮他，并把问题更加普遍化，可以很快的求出任意非负整数区间中 1 出现的次数（从 1 到 n 中 1 出现的次数）。

**【代码】**

public int NumberOf1Between1AndN_Solution(int n) { 
            if (n == 1) return 1;
    
            int nCount,i,j;
            nCount = 0;
    
            for (i=1; i<=n; i++) { 
                j = i;
                while (j > 0) { 
                    if (j%10 == 1) nCount++;
                    j = j/10;
                }
            }
    
            return nCount;
    
        }

**【思考】**

不要用递归写，最简单的循环即可

--------------------

### 5.丑数 ###

**【题目】**

把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含质因子 7。 习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。

**【代码】**

/** * 把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。 * 例如 6、8 都是丑数，但 14 不是，因为它包含质因子 7。 * 习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。 * * 从已有的丑数中选取一个，分别*2，*3，*5，再取最小的 * 最小的索引++，并赋值 * */
        public int GetUglyNumber_Solution(int index) { 
            if (index == 0) return 0;
    
            int p2,p3,p5,i,temp;
    
            p2 = p3 = p5 = 0;
    
            int[] res = new int[index];
            res[0] = 1;
    
            for (i=1; i<index; i++) { 
    
                res[i] = Math.min(res[p2]*2,Math.min(res[p3]*3,res[p5]*5));
    
                if (res[i] == res[p2]*2) p2++;
                if (res[i] == res[p3]*3) p3++;
                if (res[i] == res[p5]*5) p5++;
            }
    
            return res[index-1];
        }

**【思考】**

当特定某些性质的数列排序时，可以考虑这种方法