算法入门day1(数组)

二维数组中的查找

题目描述：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。如以下二维数组：
1 2 3 4
2 3 4 5
3 4 5 6

解题思路： 查找的本质是排除。根据这个二维数组的特性，可以选取右上角或者左下角的数字作为标准，假设选择右上角数字，如果目标数字大于右上角的数字，则可以排除最右的一列，如果小于右上角的数字，可以排除第一列，依次下去。这样比一个一个排除的效率更高。

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int i=0;
        //每一行数组的长度
        int j=array[0].size()-1;
        
        while(i<array.size() && j>=0)
        {
            //排除当前列
            if(target<array[i][j])
                j--;
            //排除当前行
            else if(target>array[i][j])
                i++;
            //找到
            else
                return true;
        }
        
        return false;
    }
};

旋转数组的最小数字

题目描述：有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。要求：空间复杂度：O(1) ，时间复杂度：O(logn)

解题思路：

1. 思路1：非降序的数组把前若干个元素搬到数组末尾，那么旋转后的数组最小值会在中间的某个位置，从最前面开始遍历，当左右相邻的两个元素，左边大于右边时，右边的元素就是最小值（出现递减的数字）。如果中间不存在符合条件的元素，就是一个非递减排序的数组（最小值在开头）。
2. 思路2：采用二分查找的方法，不断缩小查找区间。非递减数组旋转后，把这个数组分为两部分，左半部分是没旋转的，右半部分是旋转过去的，左半部分的值一定大于右半部分。定义下标left、right。mid（中间），用left作比较，当left>mid，那么mid在右半部分，最小值就在mid的左边，可以排除mid的右边，即让right=mid；如果left<mid，mid在左半部分，最小值在mid的右边，排除mid的左边，即让left=mid。当left=right=mid时，无法判断，只能线性遍历。

思路1：

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.empty())
            return 0;
        
        for(int i=0;i<rotateArray.size()-1;i++)
        {
            if(rotateArray[i]>rotateArray[i+1])
                return rotateArray[i+1];
        }
        //没有找到符合条件的，可能旋转个数为0，那么第一个元素就是最小值，或者是数组中数字都相同，或者n=1
        return rotateArray[0];
    }
};

思路2：（这里用right与mid比较）

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        //二分查找
        if(rotateArray.empty())
            return 0;
        int left=0,right=rotateArray.size()-1;
        int mid=0;
        
        //保证旋转特性
        while(rotateArray[left]>=rotateArray[right]){
            //如果左边和右边已经相邻，右边就是最小值
            if(right-left==1){
                mid=right;
                break;
            }            
            mid=left+(right-left)/2;
            //左右中都相等，无法判断mid是在左半部分还是右半部分，只能遍历
            if(rotateArray[left]==rotateArray[right] && 
               rotateArray[left]==rotateArray[mid]){
                for(int i=left;i<=right;i++){
                    int ret=rotateArray[i];
                    if(ret>rotateArray[i+1]){
                        return rotateArray[i+1];
                    }
                }
            }
            //最小值在mid的右边
            if(rotateArray[mid]>=rotateArray[left]){
                left=mid;
            }
            //最小值在mid的左边
            else{
                right=mid;
            }
        }
        
        return rotateArray[mid];
    }
};

调整数组位置使奇数位于偶数前面

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

解题思路：如果没有要求相对位置不变，可以定义left和right，一个从左向右，一个从右向左同时进行，left位置为偶数时停下，right位置为奇数时停下，然后交换。这里要求相对位置不变， 可以借用插入排序的思想，从左往右（也可从右往左）找到第一个偶数，保留这个偶数的位置，假设为k，再找到下一个奇数的位置，保存这个奇数的值，把这个奇数前面这段区间的偶数全部往后移一个，再把保存下来的这个奇数放入前面保存的第一个偶数的位置，让k++，即又到了左边第一个偶数的位置，依次循环。

这里的代码是从右往左循环，把偶数往后插，奇数往前挪：

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        if(array.size()==0)
            return ;
        
        //把奇数前移，偶数插入后面
        int k=array.size()-1;
        for(int i=array.size()-1;i>=0;i--){
            if((array[i]&1)!=1){//是偶数
                int tmp=array[i];//保存这个偶数
                int j=i;
                while(j<k){ //k是上一个已经排好位置的偶数的前面一个奇数
                    array[j]=array[j+1];//把这段区间的奇数前移
                    j++;
                }
                array[k--]=tmp;//把保存好的偶数放到k的位置，再让k--，因为前面刚把奇数挪过来，k--一定是奇数
            }
        }
    }
};

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

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

解题思路：

1. 思路1：定义map，使用<数字，次数>的映射关系，最后统计每个字符出现的次数。（后续更新）
2. 思路2：排序，出现次数最多的数字，一定在中间位置。然后检测中间出现的数字出现的次数是否符合要求。
3. 思路3：从数组首元素开始，比较两个数字是否相同，如果不同则去掉这两个数字，最后剩下的数字一定是目标数字。最后判断一下该数字是否符合要求（有可能该数组中不存在出现次数超过数组长度一半的数字）

代码实现：

思路2：

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.empty())
            return 0;
        sort(numbers.begin(),numbers.end());
        
        int target=numbers[numbers.size()/2];
        int n=0;
        for(int i=0;i<numbers.size();i++)
        {
            if(numbers[i]==target)
                n++;
        }
        if(n>numbers.size()/2)
            return target;
        return 0;
     }
};

思路3：

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.empty())
            return 0;
        //假设第一个数据为目标数字，个数为1个
        int cand=numbers[0],count=1;
        for(int i=1;i<numbers.size();i++){
            //后面出现相同数字，个数++
            if(numbers[i]==cand){
                count++;
            }
            else{
                //出现不同数字，个数--，
                count--;
                //两数字抵消完，让cand等于下一个数字
                if(count==0){
                    cand=numbers[++i];
                    count++;
                }
            }
        }
        //有可能数组中没有出现次数超过数组长度一半的数字，
        //这里要确保cand出现次数超过数组长度一半
        int n=0;
        for(int i=0;i<numbers.size();i++)
        {
            if(numbers[i]==cand)
                n++;
        }
        if(n>numbers.size()/2)
            return cand;
        return 0;
    }
};