剑指offer刷题

03 数组中重复的数字

在一组数组中找到重复的数，任意找到一组就行 ，善用哈希表。

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        unordered_set<int> res;
        int tmp;
        for(int i=0;i<nums.size();i++)
        {
            if(res.find(nums[i])==res.end())  //这个意思是找不到，就插入
            {
                res.insert(nums[i]);
            }else
            {
               
               tmp=nums[i];  //找到弹出就行
               break;
            }
        }
         return tmp;
    }
};

剑指offer 04二维数组中的查找。

这里用递归，从一个角开始。

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if(matrix.size() == 0)
            return false;
        int x = 0,y = matrix[0].size() - 1;  //上右三角
        while(x < matrix.size() && y >= 0)
        {
            if(matrix[x][y] > target)
                y--;
            else if(matrix[x][y] < target)
                x++;
            else 
                return true;
        }
        return false;
    }
};

剑指offer 06 从尾部到头部返回链表的值。

这里用一个栈，塞进去，然后出栈就行了。 

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
         stack<int>stk;
         vector<int>res;
         ListNode *p=head;
         while(p!=nullptr)
         {
             stk.push(p->val);
             p=p->next;
         }
         while(!stk.empty())
         {
             int a=stk.top();//返回栈顶元素
             res.push_back(a);
             stk.pop();//删除栈顶元素
         }
         return res;

    }
};

剑指offer09 两个栈实现队列

class CQueue {
public:
    stack<int> stack1;
    stack<int> stack2;
    CQueue() {}
    
    void appendTail(int value) {
        stack1.push(value);
    }
    
    int deleteHead() {
        if (stack1.empty()) return -1;
        
        while (!stack1.empty()){ // 1 -> 2
            int tmp = stack1.top();
            stack1.pop();
            stack2.push(tmp);
        }
        // delete head
        int res = stack2.top();
        stack2.pop();
        while (!stack2.empty()){ // 1 <- 2
            int temp = stack2.top();
            stack2.pop();
            stack1.push(temp);
        }
        return res;
    }
};

 剑指offer 11 旋转数组的最小值，旋转的话，肯定是从中间到最大，这些值都比右边的大，中间值与右边的相比，就比右边大的时候，说明旋转点在右边，接口在右边，这时候就区间调到右边。

当中间值比右边小时，说明旋转拼接点在左边。最小值也在左边。这时候选j+1，有可能最小的就是这个了。

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int n=numbers.size();
        int i=0,j=n-1;
        
        while(i<j)
        {
            int m=i+(j-i)/2;
            if(numbers[m]>numbers[j])
            {
            i=m+1;
            }else if(numbers[m]<numbers[j])
            {
                j=m;
            }
            else
            j--;
        }
        return numbers[i];
    }
};