数组2

剑指offer数组题

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

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
       int n = array.size();
        if(n == 0) return false;
        int m = array[0].size();
        for(int i = n - 1, j = 0; i >= 0 &&  j < m;){
            if(target == array[i][j]) return true;
            else if(target < array[i][j]) {
                i--;
                continue;
            }
            else {
                j++;
                continue;
            }
            
        }
        return false;
    }
};

2.HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

思路：当前面的向量和<0时，就不要加入到后面的向量和中。

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int r = 1;
        int res = array[0];
        int m = array[0];
        int n = array.size();
        while(r < n){
            if(res > 0) res = res + array[r];
            else res = array[r];
            m = max(m, res);
            r++;
        }
        return m;
    }
};

3.输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

思路：关键在于如何定义两个数字m与n的排列顺序。首先，数字m与数字n能拼接出数字mn和nm。如果mn<nm，那么，m应该排在n前面；反之同理。

class Solution {
public:
    static bool isSmall(int n1, int n2){
        string sum1 = "";
        sum1 += to_string(n1);
        sum1 += to_string(n2);
        string sum2 = "";
        sum2 += to_string(n2);
        sum2 += to_string(n1);
        return sum1 < sum2;
    }
    
    string PrintMinNumber(vector<int> numbers) {
        sort(numbers.begin(), numbers.end(), isSmall);
        string res = "";
        for(int i=0; i<numbers.size(); i++){
            res += to_string(numbers[i]);
        }
        return res;
    }
};

4.输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

输出描述:

对应每个测试案例，输出两个数，小的先输出。

思路：使用对撞指针的思想。

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        vector<int> res(2,0);
        int mix = INT_MAX;
        int i = 0, j = array.size()-1;
        while(i < j){
            if(array[i] + array[j] == sum){
                if(i * j < mix){
                    res[0] = array[i];
                    res[1] = array[j];
                    mix = i * j;
                }
                i++; j--;
            }
            else if(array[i] + array[j] < sum) i++;
            else j--;
        }
        if(mix == INT_MAX) return vector<int>();
        else return res;
    }
};

5.小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出描述:

输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

class Solution {
public:
    vector<vector<int> > FindContinuousSequence(int sum) {
        int l = 0, r = -1;
        int n = sum;
        vector<int> nums(sum, 0);
        for(int i = 0; i < sum; i++){
            nums[i] = i + 1;
        }
        int seq = 0;
        vector<vector<int> > res;
        while(l < n){
            if(r + 1 < n && seq <= sum){
                r = r + 1;
                seq = seq + nums[r];
            }else{
                seq = seq - nums[l];
                l = l + 1;
            }
            if(seq == sum && r - l + 1 >= 2){
                vector<int> tmp;
                for(int i = l; i <= r; i++){
                    tmp.push_back(nums[i]);
                }
                res.push_back(tmp);
            }
        }
        return res;
    }
};

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

思路：需要考虑数字大小为0，大小为1，以及旋转后的几种情况：

如，1，2，3，4，5；

3，4，5，1，2；

4，5，1，2，3；

1，1，1，1，0；

1，0，1，1，1 

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int n = rotateArray.size();
        if(n == 0) return 0;
        int left = 0, right = n - 1, middle = 0;
        if(rotateArray[left] < rotateArray[right]){
            return rotateArray[left];
        }
        while(left < right){
            if(right - left == 1){
                return rotateArray[right];
            }
            int middle = (left + right) / 2;
            if(rotateArray[middle] == rotateArray[left] && rotateArray[middle] == rotateArray[left]){
                int m = rotateArray[left];
                for(int i = left; i <= right; i++){
                    m = min(m, rotateArray[i]);
                }
                return m;
            }
            if(rotateArray[middle] <= rotateArray[left]) right = middle;
            if(rotateArray[middle] >= rotateArray[left]) left = middle;
        }
        return rotateArray[middle];
    }
};

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

思路：需要考虑只有一行或者一列或者是否可能重复打印。

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> res;
        int n0 = 0;
        int m0 = 0;
        int n1 = matrix.size()-1;
        int m1 = matrix[0].size()-1;
        while(m1 >= 0 && n1 >= 0 && m1 >= m0 && n1 >= n0){
            printSubMatrix(matrix, res, m0, n0, m1, n1);
            m0++;
            n0++;
            m1--;
            n1--;
        }
        return res;
        

    }
    void printSubMatrix(vector<vector<int> > matrix, vector<int> &res, int m0, int n0, int m1, int n1) {
        for(int i = m0; i <= m1; i++){
            res.push_back(matrix[n0][i]);
        }
        for(int i = n0+1; i <= n1; i++){
            res.push_back(matrix[i][m1]);
        }
        if(n1 > n0){
            for(int i = m1-1; i >= m0; i--){
                res.push_back(matrix[n1][i]);
            }
        }
        
        if(m1 > m0){
            for(int i = n1-1; i > n0; i--){
                res.push_back(matrix[i][m0]);
            }
        }
    }
};

8.给定一个数组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]。不能使用除法。

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

9.在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

思路：利用数组中的每个数字都在0~n-1之间，假设在位置i，首先判断numbers[i]是否在位置numbers[i]上，如果不在，判断位置numbers[i]上面的数字，是否等于numbers[i]，如果相等，则说明找到了重复的数字；如果不等，则将numbers[i]与 numbers[numbers[i]]交换位置。

class Solution {
public:
    // Parameters:
    //        numbers:     an array of integers
    //        length:      the length of array numbers
    //        duplication: (Output) the duplicated number in the array number
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    bool duplicate(int numbers[], int length, int* duplication) {
        for(int i = 0; i < length; i++){
            if(numbers[i] != i){
                if(numbers[i] == numbers[numbers[i]]){
                    *duplication = numbers[i];
                    return true;
                }
                else{
                    swap(numbers[i], numbers[numbers[i]]);
                }
            }
        }
        return false;
    }
};

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

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        int n = 0;
        if(array.size() == 0) return;
        for(int i = 0; i < array.size(); i++){
            if(array[i] % 2 == 1){
                int t = array[i];
                int temp = i;
                int j = i;
                while(j > 0){
                    if(array[j-1] % 2 == 0){
                        j--;
                    }else{
                        break;
                    }
                }
                while(temp > j){
                    array[temp] = array[temp-1];
                    temp--;
                }
                array[temp] = t;
            }
        }
               
    }
};

11.一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。

class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
        int n = data.size();
        map<int, int> m;
        for(int i = 0; i < n; i++){
            if(m.find(data[i]) == m.end()){
                m[data[i]] = 1;
            }else{
                m[data[i]] += 1;
            }
        }
        map<int, int>:: iterator iter1;
        bool flag1 = false;
        for(iter1 = m.begin(); iter1 != m.end(); iter1++){
            if(iter1->second % 2 != 0) {
                if(!flag1){
                    *num1 = iter1 -> first;
                    flag1 = true;
                }else{
                    *num2 = iter1 -> first;
                }
            }
        }


    }
};