剑指offer（一）数组

面试题3：二维数组中的查找

题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题思路：首先选取数组右上角的数字。如果这个数字恰好就是目标数字，查找过程结束；如果这个数字比目标数字要大，则剔除这个数字所在列；否则，这个数字比目标数字要小，则剔除这个数字所在行。

    bool Find(int target, vector<vector<int> > array) {
        bool find = false;
        int rows = array.size();
        int columns = array[0].size();
        if(rows>0 && columns>0){
            int row = 0;
            int column = columns-1;
            while(row<rows && column>=0){
                if(array[row][column] == target){
                    find = true;
                    break;
                }else if(array[row][column] < target){
                    row++;
                }else{
                    column--;
                }
            }
        }
        return find;
    }

面试题8：旋转数组的最小数字

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
解题思路：因为旋转数组是部分有序的，所以适用于二分查找法。当mid大于等于前面数组的第一个数，则最小数字在后面数组；当mid小于等于后面数组的最后一个数，则最小数字在前面数组；当三者相等时，无法判断最小数字在前面数组还是后面数组，就得用线性搜索的方法寻找最小数字。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size()==0)
            return 0;
        int index1 = 0;
        int index2 = rotateArray.size()-1;
        int indexMid = index1;  //适于数组本身是排好序的
        while(rotateArray[index1] >= rotateArray[index2]){
            if(index2-index1==1){
                indexMid = index2;
                break;
            }
            indexMid = (index1+index2)/2;
            if(rotateArray[index1]==rotateArray[index2] && rotateArray[index1]==rotateArray[indexMid])
                return MinInOrder(rotateArray,index1,index2);
            if(rotateArray[indexMid] >= rotateArray[index1])
                index1 = indexMid;
            if(rotateArray[indexMid] <= rotateArray[index2])
                index2 = indexMid;
        }
        return rotateArray[indexMid];
    }
    int MinInOrder(vector<int> rotateArray, int index1, int index2){
        int tmp = rotateArray[index1];
        for(int i=index1+1; i<=index2; i++)
            if(rotateArray[i] < tmp){
                tmp = rotateArray[i];
                break;
            }
        return tmp;
    }
};

面试题14：调整数组顺序使奇数位于偶数前面

题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分。
解题思路：用两个指针一前一后遍历，分别遇到偶数和奇数时，互相交换。

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        if(array.size()==0)
            return;
        int left = 0;
        int right = array.size()-1;
        while(left < right){
            while(left<right && (array[left]&0x1)!=0)
                left++;
            while(left<right && (array[right]&0x1)==0)
                right--;
            if(left < right){
                int temp = array[left];
                array[left] = array[right];
                array[right] = temp;
            }
        }
    }
};

增加要求：并保证奇数和奇数，偶数和偶数之间的相对位置不变。
解题思路：增加一个辅助数组可以使时间复杂度O(n)

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int len = array.size();
        if(len==0)
            return;
        vector<int> res(len);
        int p = 0;
        int index = 0;
        while(p < len){
            if((array[p]&0x1)!=0)
                res[index++] = array[p];
            p++;
        }
        p = 0;
        while(p < len){
            if((array[p]&0x1)==0)
                res[index++] = array[p];
            p++;
        }
        array = res;
    }
};

面试题29：

题目：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
解题思路：因为要找的这个数，如果存在，它出现的次数比其他所有数字出现的次数都要多，所有用一个count来记录。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.size()==0)
            return 0;
        int count = 1;
        int result = numbers[0];
        for(int i=1;i<numbers.size();i++){
            if(count == 0){
                result = numbers[i];
                count = 1;
            }else{
                if(result == numbers[i])
                    count++;
                else
                    count--;
            }
        }
        count = 0;
        for(int i=0;i<numbers.size();i++){
            if(result == numbers[i])
                count++;
        }
        if(count*2 <= numbers.size())
            result = 0;
        return result;
    }
};

面试题30：最小的K个数

题目：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
解题思路：以大顶堆存储前K个数，后面的数依次和堆顶比较，如果比堆顶小，则替代堆顶，调整堆。如果可以用STL，可以用multiset存储（multiset基于红黑树实现，查找、删除和插入的时间复杂度都是O(log k)）。还有一种基于Partition的思路，时间复杂度O(n)，但是需要修改输入数组。

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> result;
        if(k > input.size() || k < 1) //如果k比输入数组大小还要大，就返回[]
            return result;
        multiset<int,greater<int>> leastNums; //leastNums从大到小排序
        vector<int>::iterator it = input.begin();
        for(;it!=input.end();it++){
            if(leastNums.size()<k)
                leastNums.insert(*it);
            else{
                multiset<int,greater<int>>::iterator iter = leastNums.begin();
                if(*it < *(leastNums.begin())){
                    leastNums.erase(*iter);
                    leastNums.insert(*it);
                }
            }
        }
        multiset<int,less<int>>::iterator iter = leastNums.begin();
        for(;iter!=leastNums.end();iter++){
            result.push_back(*iter);
        }
        return result;
    }
};

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

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

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

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

题目：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
解题思路：定义新的比较大小的规则，对数组进行排序，然后再连接即可。

class Solution {
public:
    string PrintMinNumber(vector<int> numbers) {
        int len = numbers.size();
        if(len == 0)
            return "";
        sort(numbers.begin(),numbers.end(),cmp);
        string result;
        for(int i=0;i<len;i++){
            result += to_string(numbers[i]);
        }
        return result;
    }
    static bool cmp(int a, int b){
        string ab = to_string(a) + to_string(b);
        string ba = to_string(b) + to_string(a);
        return ab < ba;
    }
};

面试题36：

题目：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
解题思路：用归并排序的思路统计。

class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size()==0)
            return 0;
        int len = data.size();
        vector<int> copy = data;
        return InversePairsCore(data,copy,0,len-1);
    }
    int InversePairsCore(vector<int> &data, vector<int> &copy, int start, int end){
        if(start == end){
            copy[start] = data[start];
            return 0;
        }
        int mid = (start+end)/2;
        long left = InversePairsCore(copy,data,start,mid);
        long right = InversePairsCore(copy,data,mid+1,end);

        long count = 0;
        int i = mid;
        int j = end;
        int index = end;
        while(i>=start && j>=mid+1){
            if(data[i] > data[j]){
                count += j - mid;
                copy[index--] = data[i--];
            }else{
                copy[index--] = data[j--];
            }
        }
        for(;i>=start;i--){
            copy[index--] = data[i];
        }
        for(;j>=mid+1;j--){
            copy[index--] = data[j];
        }
        return (left + right +count) % 1000000007;
    }
};

#

题目：统计一个数字在排序数组中出现的次数。
解题思路：使用二分查找法

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        if(data.size()==0)
            return 0;
        return core(data,k,0,data.size()-1);
    }
    int core(vector<int> data ,int k, int start, int end){
        if(start>end)
            return 0;
        int mid = (start+end)/2;
        if(data[mid] < k)
            return core(data,k,mid+1,end);
        else if(data[mid] > k)
            return core(data,k,start,mid-1);
        else
            return (1+core(data,k,mid+1,end)+core(data,k,start,mid-1));
    }
};

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

题目：一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
解题思路：因为相同数字异或后的结果是0，所以数组中所有数字异或得到的结果是这两个只出现一次的数字相异或的结果tmp，根据tmp从右边起第一个不为0的位（一定存在）是否为1把nums分成两部分，分别求出结果。

class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
        int len = data.size();
        if(len<2)
            return;
        int tmp = 0;
        for(int i=0;i<len;i++){
            tmp ^= data[i];
        }
        unsigned int first1Index = findFirst1Index(tmp);
        *num1 = *num2 = 0;
        for(int i=0;i<len;i++){
            if((data[i]>>first1Index) & 1 == 1){
                *num1 ^= data[i];
            }else{
                *num2 ^= data[i];
            }
        }
    }
    unsigned int findFirst1Index(int tmp){
        int index = 0;
        while(((tmp & 1) == 0) && (index < 8 * sizeof(int))){ //总是通不过，原因为(tmp & 1)少了括号，==优先级比&高
            tmp = tmp >> 1;
            index++;
        }
        return index;
    }
};

面试题52：构建乘积数组

题目：给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…A[i-1]*A[i+1]…*A[n-1]。不能使用除法。
解题思路：构建一个横向为A[i]、纵向为B[i]的矩形，就能观察出规律。

class Solution {
public:
    vector<int> multiply(const vector<int>& A) {
        int n = A.size();
        vector<int> B(n);
        B[0] = 1;
        for(int i=1;i<n;i++)
            B[i] = B[i-1]*A[i-1];
        double temp = 1;
        for(int i=n-2;i>=0;i--){
            temp *= A[i+1];
            B[i] *= temp;
        }
        return B;
    }
};