剑指offer数组类题目汇总（共12道题目）

1.二维数组中的查找

题目描述：

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

解题思路：

很明显，由于该二维数组上到下递增，左到右递增的特殊性，遍历整个矩阵进行查找不是该题目的意图所在。总结规律我们可以发现：应该从矩阵的右上角或者左下角开始查找。

以右上角为例，首先选取右上角的数字，如果该数字等于要查找的数字，则查找过程结束；如果该数字大于要查找的数字，则说明该列其他元素都大于要查找的数字，便可以删掉该列；如果该数字小于要查找的数字，则说明该行其他元素也都小于要查找的数字，便可以删掉该行。

这样，每一次比较都可以剔除一行或者一列，进而缩小查找范围，时间复杂度为O(n)。

举例：

比如在下面的二维数组中查找数字7，查找过程如下：

代码如下：

class Find{
    public boolean find(int target,int [][] arr){
        if(arr == null|| arr.length == 0)
            return false;  //数组为空或不是二维数组直接返回false
        int row = arr.length; //定义行
        int col = arr[0].length;//定义列
        int i = 0;
        int j = col - 1;   //从右上角开始
        while(i<row && j>0)
        {
            if (arr[i][j] == target)
                return true;  //找到目标值
            else if (arr[i][j] > target)
                j--;   //这一列不符合
            else
                i++;  //这一行不符合
        }
        return false;
    }
}

**

2.旋转数组的最小数字

**
题目描述：

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

解题思路：

本题的直观解法很简单，直接对数组进行一次遍历就可以找到最小值，复杂度为O(n)，但是显然这不是本题的意图所在，因为没有利用到任何旋转数组的特性。

进一步分析，如果整个数组是有序的，那我们一定会想到用折半查找来实现。对于旋转数组，我们发现，它实际上可以划分为两个排序的子数组，而且前面数组的元素都不小于后面数组的元素，并且最小值正好就是这两个数组的分界线，由此，我们可以得出以下解决方法。

首先用两个指针low和high分别指向数组的第一个元素和最后一个元素，然后可以找到中间元素mid。对于这个中间元素，有以下两种情况：（1）该元素大于等于low指向的元素，此时最小的元素说明在mid的后面，可以把low=mid；（2）中间元素小于等于high指向的元素，那么最小元素在mid之前，可以high=mid。特别注意：这里不要+1或者-1，因为只有这样才能保证low始终在第一个数组，high始终在第二个数组。依次循环，当最后low和high相差1时，low指向第一个数组的最后一个，high指向第二个数组的第一个（即为我们要找的最小值）。
  除此之外，本题还有两个特殊情况：

将数组前0个元素移动到后面（相当于没有旋转，数组整体有序）。明显我们上面的分析没有包含这种情况，需要特殊处理，方法也很简单，将第一个元素和最后一个元素相比，若第一个元素小于最后一个元素，则说明最小值就是的第一个元素，可以直接返回。

首尾指针指向的数字和中间元素三者都相等时，无法判断中间元素位于哪个子数组，无法缩小问题规模。此时，只能退而求其次，进行顺序查找。

  很明显，以上查找的时间复杂度为O(logN)。

public int find(int[] arr) {
        int len = arr.length;
        if (len == 0)
            return 0; //数组长度为零则返回0
        int low = 0;
        int high = len-1;
        if (arr[low] < arr[high])
            return arr[low]; //此情况为按升序排列的数组
        while (low < high){
            int mid = low + (high - low)/2; //寻找中间数
            if (arr[low] == arr[mid] && arr[high] == arr[mid])
                return minInOrder(arr); // 不是一个规则的旋转数组就直接查找最小数
            if (arr[mid] < arr[high])
                high = mid; // 中间数小于最右边的数则说明最小数在次数左边
            else if (arr[mid] > arr[low])
                low = mid;
            if (high - low == 1)
            return arr[high]; //两个指针只相差一位时 说明最大数就在右边的指针上

        }
        return -1;
    }

    private int minInOrder(int[] arr) {
        int num = arr[0];
        for (int a: arr) {
            if (a < num)
                num  = a;
        }
        return num;
    }

3.调整数组顺序使奇数位于偶数前面

题目描述：

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

解题思路：

首先，如果不考虑奇数和奇数，偶数和偶数的相对位置，那么我们有一种双指针解法来求解，类似于快排，维护两个指针，第一个指针指向数组的第一个数字，第二个指针指向数组的最后一个数字。第一个指针向后移，第二个指针向前移，如果第一个指针指向偶数，第二个指针指向的是奇数，则交换着两个数字，接着继续移动直到两指针相遇。

上面的方法看似不错，但是对本题不适用，因为本题有相对位置不变的要求，直接交换会导致相对位置改变。因此，我们采用下面的思路来解决本题。

本题解法：对数组进行遍历，设置两个指针even和odd，even指向当前第一个偶数，odd从这个偶数之后开始查找，找到第一个奇数，此时为了相对位置不变，不能直接交换even和odd，而是将从even到odd-1的元素都依次向后移一个位置，将odd指向的那个奇数放到even的位置。然后再找下一个偶数，重复这一过程，最终就可以将奇数都放到偶数的前面，并且保证了相对位置的不变。
  代码如下：

public void sort(int[] arr){
        int len = arr.length;
        int odd = 0;
        int even = 0;
        while(odd < len && even < len){
            while (even < len && arr[even]%2 != 0)
                even++;
            odd = even +1;
            while (odd < len && arr[odd]%2 ==0)
                odd++;
            if (odd >= len)
                break;
            int tmp = arr[odd];

            for (int i = odd;i>even;i--)
                arr[i] = arr[i-1];
            arr[even] = tmp;
            even++;

        }
    }

4.顺时针打印矩阵

题目描述：

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.

解题思路：

由于是按照从外到内的顺序依次打印，所以可以把矩阵想象成若干个圈，用一个循环来打印矩阵，每次打印矩阵中的一圈。假设矩阵的行数是row，列数是col，则每次都是从左上角开始遍历，而我们注意到左上角行标和列标总是相同的，假设是start，那么循环继续的条件就是row>start * 2 && col > start * 2。

而对于每一圈的打印，很自然便可以想到遵循从左到右，从上到下，从右到左，从下到上的顺序。但是这里需要注意的是最后一圈的打印，由于矩阵并不一定是方阵，最后一圈有可能退化为只有一行，只有一列，甚至只有一个数，因此要注意进行判断，避免重复打印。
  

 public void printMatrixClockwisely(int[][] numbers, int rows, int columns) {
        if (numbers == null || rows <= 0 || columns <= 0) {
            return;
        }
        int start = 0;
        while (start * 2 < columns && start * 2 < rows) {
            printMatrixInCircle(numbers, rows, columns, start);
            start++;
        }
    }

    public void printMatrixInCircle(int[][] numbers, int rows, int columns,int start) {
        //静止列号
        int endX = columns - 1 - start;
        //静止行号
        int endY = rows - 1 - start;
        //从左至右打印一行
        for(int i = start; i <= endX; i++){
            System.out.print(numbers[start][i]+"  ");
        }
        //从上到下打印一列
        if(endY > start){
            for(int i = start+1; i<= endY; i++){
                System.out.print(numbers[i][endX] + "  ");
            }
        }
        //从右至左打印一行
        if(endY > start && endX > start){
            for(int i  = endX-1 ; i>= start; i--){
                System.out.print(numbers[endY][i] + "  ");
            }
        }
        //从下到上打印一列
        if(endY - 1 > start && endX > start){
            for(int i = endY-1; i >= start+1 ; i--){
                System.out.print(numbers[i][start] + "  ");
            }
        }
    }

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

题目描述：

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

解题思路：

本题有以下三种方法可解：

方法一：首先对数组进行排序，在一个有序数组中，次数超过一半的必定是中位数，那么可以直接取出中位数，然后遍历数组，看中位数是否出现次数超过一半，这取决于排序的时间复杂度，最快为O(nlogn)。

方法二：遍历数组，用 HashMap 保存每个数出现的次数，这样可以从map中直接判断是否有超过一半的数字，这种算法的时间复杂度为O(n)，但是这个性能提升是用O(n)的空间复杂度换来的。

方法三（最优解法）：根据数组特点得到时间复杂度为O(n)的算法。根据数组特点，数组中有一个数字出现的次数超过数组长度的一半，也就是说它出现的次数比其他所有数字出现的次数之和还要多。因此，我们设两个栈，当空栈或者遇到相同数时我们往栈里压入数字，反之弹栈，这样最后就剩一个数字就是我们要找的那个。
  代码如下：

class HalfElements{
    //方式一
    public int find_1( int[] arr){
        Arrays.sort(arr);
        int low = 0;
        int hight = arr.length-1;
        return arr[low + (hight - low)/2];  //中位数就是我们要找的那个
    }
    //方式二
    public  int find_2(int[] arr) {
        Map<Integer, Integer> map = new HashMap();
        for (int i = 0;i<arr.length;i++)
        {
            if (!map.containsKey(arr[i]))
                map.put(arr[i],1); //哈希表里没有的话就往里面存
            else
                map.put(arr[i],map.get(arr[i])+1);//发现相同键值就value值加1
        }
       /* for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() * 2 > arr.length)
                return entry.getKey();
        }*/
       //两种不同的遍历方式喜欢哪种都行
       for (int Key:map.keySet())
       {
           if (map.get(Key)>arr.length/2)
               return Key;
       }
            return 0; 
    }
//方式三
    public int find_3(int[] arr){
        Stack<Integer> s = new Stack<>();
        for (int i = 0;i<arr.length;i++)
        {
            int a = arr[i];
            
            if (s.isEmpty()||a == s.peek())//当前值与栈里的值相同则入栈
                s.push(a);
            else
                s.pop();
        }
        return s.peek(); //剩下这个就是我们需要的
    }
}