leetcode剑指offer刷题记录

剑指Offer

重点看带符号的题目

03.数组中重复的数字

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 

思路：空间换时间
C++哈希表：unordered_map m

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        //超时->空间换时间
        //哈希表：unordered_map m
        unordered_map <int,int> m;
        for(int temp : nums){
            if(m[temp]) return temp;
            m[temp] = 1;
        } 
        return -1; 
    }
};

04.二维数组中的查找

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

示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。
给定 target = 20，返回 false。

思路：把逆时针矩阵旋转45°，可以看作一颗二叉搜索树。以示例的矩阵为例：根节点是15，往左下，都比15大，往右下都比15小。

• 如果目标值比当前matrix[i][j]小，则减小列数（逻辑上最右上的元素是同行中最大的，找比当前元素更小的目标，就往同行的左侧去找）；
• 如果目标值比当前matrix[i][j]大，则增大行数（逻辑上最右上的元素是同列中最小的，找比当前元素更大的目标，就往同列的下方去找）。

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        //思路，仿二叉搜索树，将矩阵的最右上or矩阵的最左下的一个元素模拟成树的根节点
        //以最右上的元素作为根节点为例：
        if(matrix.empty()) return false;
        int m = matrix.size(); //行数
        int n = matrix[0].size(); //列数
        for(int i=0,j=n-1; i<m && j>=0; ){
            if(matrix[i][j] == target) return true;
            else if(matrix[i][j] > target) j--; //如果目标值比当前matrix[i][j]小，则减小列数（逻辑上最右上的元素是同行中最大的，找比当前元素更小的目标，就往同行的左侧去找）
            else i++; //如果目标值比当前matrix[i][j]大，则增大行数（逻辑上最右上的元素是同列中最小的，找比当前元素更大的目标，就往同列的下方去找）
        }
        return false;
    }
};

05.替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

限制：

0 <= s 的长度 <= 10000

思路：

• 如果用的是C++，先将原字符串s.resize()，然后再倒序依次修改。
• 如果是Python或Java，则需要新建字符数组，因为在这两种语言中，字符串类型是常量，一旦初始化不可以直接修改。

class Solution {
public:
    string replaceSpace(string s) {
        /*注意：C++中的string类型是变量类型，因此可以在原字符串的基础上更改
         * 而Jave和Python中的字符串类型是常量，不能直接在原字符串上进行修改，只能新建
        */
        int cnt = 0;
        for(char each : s){
            if(each == ' '){
                cnt++;
            }
        }
        int i = s.size()-1;
        int j = cnt*2 + s.size()-1;
        s.resize(j+1);
        //倒序修改
        for (; i<j ; i--,j--){
            if(s[i] == ' '){
                s[j] = '0';
                s[j-1] = '2';
                s[j-2] = '%';
                j -= 2;
            }
            else{
                s[j] = s[i];
            }
        }
        return s;
    }
};

06.倒序打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

限制：
0 <= 链表长度 <= 10000

思路：栈 or 递归（但递归本质就是栈）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        //思路：利用栈；or利用递归（递归本质就是栈）
        //注意：没有不含val的头节点
        vector <int> res;
        if(head == NULL) return res;
        //首先遍历一次，依次入栈
        stack <int> s;
        ListNode *p = head;
        while(p!=NULL){
            s.push(p->val);
            p=p->next;
        }
        //然后出栈记录
        while(!s.empty()){
            res.push_back(s.top());
            s.pop();
        }
        return res;
    }
};