LeetCode刷题记录（二）

剑指 Offer 17. 打印从1到最大的n位数

解法一：

缺点：未考虑到大数的情况，当数字较大时，int不够用

class Solution {
public:
    vector<int> printNumbers(int n) {
        //1.先判断n为几位数
        n = pow(10,n);
        vector<int>v;
        for(int i=1;i<n;i++){
            v.push_back(i);
        }
        return v;
    }
};

解法二：考虑大数的情况

大数加法的模板

string Add(string a,string b) {
        string ans;
        int numA[MAX_SIZE]={0},numB[MAX_SIZE]={0};//用来保存数字
        int lenA = a.size();
        int lenB = b.size();

        for(int i=0;i<lenA;i++){
            //字符串转数字
            numA[lenA-1-i] = a[i] - '0';//从个位开始转换
        }
        for(int i=0;i<lenB;i++){
            numB[lenB-1-i] = b[i] - '0';
        }
        int lenMax = lenA>lenB ? lenA:lenB;
        // 从个位开始计算
        for(int i=0;i<lenMax;i++){
            numA[i]+=numB[i];
            numA[i+1]+=numA[i]/10;//判断是否有进位
            numA[i]%=10;
        }
        //去除前置0
        if(!numA[lenMax])   lenMax--;	
        for(int i= lenMax;i>=0;i--){
            ans+=numA[i]+'0';	//保存到结果中
        }
        return ans; 
    }

用字符串模拟数字加法：流程为，先判断是否有溢出，没有溢出就加1并保存该值

class Solution {
public:
    vector<int> output;
    vector<int> printNumbers(int n) {
        // 以下注释的前提：假设 n = 3
        if(n <= 0) return vector<int>(0);
        string s(n, '0'); // s最大会等于999，即s的长度为n
        while(!overflow(s)) inputNumbers(s);// 当没有溢出999时
        return output;	
    }
    bool overflow(string& s)	//判断溢出情况
    {
        // 本函数用于模拟数字的累加过程，并判断是否越界（即 999 + 1 = 1000，就是越界情况）
        bool isOverFlow = false;
        int carry = 0; // carry表示进位
        for(int i=s.length()-1; i>=0; --i)	//从高到低
        {
            int current = s[i] - '0' + carry; // current表示当前这次的操作
            if(i == s.length() - 1) current ++; // 如果i此时在个位，current执行 +1 操作
            if(current >= 10)	//有进位了
            {
                // 假如i已经在最大的那一位了，而current++之后>=10，说明循环到头了，即999 + 1 = 1000
                if(i == 0) isOverFlow = true;
                else
                {
                    // 只是普通进位，比如current从9变成10
                    carry = 1;
                    s[i] = current - 10 + '0'; 
                }
            }
            else
            {
                // 如果没有进位，更新s[i]的值，然后直接跳出循环，这样就可以回去执行inputNumbers函数了，即往output里添加元素
                s[i] = current + '0';
                break;
            }
        }
        return isOverFlow;
    }
    void inputNumbers(string s)
    {
        // 本函数用于循环往output中添加符合传统阅读习惯的元素。比如001，我们会添加1而不是001。
        bool isZero = true; // 判断是否是0，比如001前面的两个0
        string temp = "";
        for(int i=0; i<s.length(); ++i)
        {
            if(isZero && s[i] != '0') isZero = false;
            if(!isZero) temp += s[i];   //去除0后，将该值保存
        }
        output.push_back(stoi(temp));//stoi	string to integer
    }
};

剑指 Offer 18. 删除链表的节点

//主要是要考虑到头结点也有可能要被删除这种情况，所有再开辟一个新结点指向头结点，这样循环向后一个判断即可可以方便不少
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        ListNode *pre = new ListNode(0);
        pre->next = head;
        head = pre;
        while(pre->next!=NULL){
            if(pre->next->val==val){
                pre->next = pre->next->next;
                return head->next;
            }
            pre = pre->next;
        }
        return head->next;
    }
};

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

第一时间我想到的是快速排序中的类似partition函数这样做分割，但关键地方有点卡住了，就先暴力过了一边

法一：暴力法

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        vector<int>res;
        for(auto it=nums.begin();it!=nums.end();++it){
            if( (*it)%2!=0 ){
                res.push_back((*it));
            }
        }
        for(auto it=nums.begin();it!=nums.end();++it){
            if( (*it)%2==0 ){
                res.push_back((*it));
            }
        }
        return res;
    }
};

法二：双指针法

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int i=0;
        int j=nums.size()-1;
        while(i < j){
            while(i<j && (nums[i] & 1) == 1) i++;	//奇数
            while(i<j && (nums[j] & 1) == 0) j--;	//偶数
            swap(nums[i],nums[j]);
        }
        return nums;
    }
};

法三.快慢指针

思路是让一个先走，而每当快指针指向的是奇数时，将其与low交换（即向左边靠）

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int low = 0, fast = 0;
        while (fast < nums.size()) {
            if (nums[fast] & 1) {	//当快指针指向的是奇数时
                swap(nums[low], nums[fast]);
                low ++;
            }
            fast ++;
        }
        return nums;
    }
};

剑指 Offer 22. 链表中倒数第k个节点

没什么难度，直接双指针就出来了，倒数第K个，就让一个先走K步，再两个指针一起走，当先走的到达链尾时，后走的正好到达倒数第K个

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode *rear = head;
        for(int i = 0;i<k;++i){
            rear = rear->next;
            if(rear==NULL){//代表K超出范围
                return head;
            }
        }
        while(rear){
            rear = rear->next;
            head = head->next;
        }
        return head;
    }
};

剑指 Offer 24. 反转链表

相当简单，就是画个图，分析一下断链的情况和指针的情况就行了。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL)  return head;
            ListNode *p,*q;
            p = head->next;
            head->next = NULL;
            while(p!=NULL){
                q = p->next;
                p->next = head;
                head = p;
                p = q;
            }
            return head;
    }
};

方案二：递归实现

链表的逆序可以自然想到递归，桟

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        return recur(head, nullptr);           // 调用递归并返回
    }
private:
    ListNode* recur(ListNode* cur, ListNode* pre) {
        if (cur == nullptr) return pre;        // 终止条件，开始回溯
        
        //该语句会一直向下指到5
        ListNode* res = recur(cur->next, cur); // 递归后继节点
        //开始回溯时修改指针指向	5->next = 4  4->next = 3....
        cur->next = pre;                       // 修改节点引用指向
        return res;                            // 返回反转链表的头节点
    }
};

剑指 Offer 25. 合并两个排序的链表

解法一

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list_1, ListNode* list_2) {
        ListNode * list = new ListNode(0),*cur =list;
        while(list_1 && list_2){
            //按递增排序
            if(list_1->val<list_2->val){
                cur->next = list_1;
                list_1 = list_1->next;
            }else{
                cur->next = list_2;
                list_2 = list_2->next;
            }
            cur = cur ->next;
        }
        cur->next = list_1 ? list_1 : list_2 ;//处理剩余的结点，因为前一个while循环一定会让一个链表到尾
        return list->next;//为什么要return list->next呢？因为一开始申请的时候申请了一个0当头结点
    }
};

解法二

递归写法，貌似有关链表的题目，都可以用递归来写,但是有一点难理解

class Solution {
public:
         ListNode* mergeTwoLists(ListNode *l1, ListNode *l2) {
        
        if(l1 == NULL) return l2;   //l1到头了
        if(l2 == NULL) return l1;   //l2到头了
        if(l1->val <= l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);	//l1向后
            return l1;
        } else {
            l2->next = mergeTwoLists(l1, l2->next);	//l2向后
            return l2;
        }
    }

};

剑指 Offer 27. 二叉树的镜像

解法一法：

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(root == nullptr) return nullptr;	//这里是边界条件
        TreeNode * temp = root->left;
        root->left=
            mirrorTree(root->right);//根节点的左结点应该向右递归
        root->right=
            mirrorTree(temp); 	//右结点向左递归
        return root;
    }
};

解法二：

用栈来处理

//桟的写法
class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(root == nullptr) return nullptr;//一个特殊情况的判断
        stack<TreeNode *>s;
        s.push(root);
        while(!s.empty()){//非空
            TreeNode *node = s.top();//根结点出栈	处理顺序为4,7,9,6，2,3,1
            s.pop();
            if(node->left!=NULL)    s.push(node->left);//左进桟
            if(node->right!=NULL)   s.push(node->right);
            //实现左右指针的一个交换
            TreeNode *temp = node->left;
            node->left = node ->right;
            node->right = temp;
        }
        return root;
    }
};

总结：这几天写了下这种有类似反转啊，逆置啊，感觉一般首先可以想递归，然后想桟，这种FILO的结构来处理

剑指 Offer 28. 对称的二叉树

大佬的写法

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        // 如果是空树
        if(!root)
            return true;
        else
            return isSymmetric(root->left, root->right);	//判断左子树和右子树是否对称
    }
    // 此函数比较二叉树中位置对称的两个节点
    bool isSymmetric(TreeNode* left, TreeNode* right){
        // 结束条件1：如果对称两个节点都为空，则返回true
        if(!left && !right){
            return true;
        }
        // 结束条件2：如果单独一个节点为空，另一个节点不为空，又或者是对称节点间的val值不等，则返回false
        if(!left || !right || left->val != right->val)
            return false;
        // 该层符合对称二叉树的要求，开始比较下一层
        //左结点的左结点，右结点的右结点
        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);      
    }
};

补一下递归：

递归，一定有1.递推关系2.递推出口

• 递归计算数组的前你项和

• 实现一个字符串的逆序输出

  void reverse_print(int index,string str){
      if(str[index]==NULL){
          return;			//1
      }
      else{
          reverse_print(index+1,str);	//2
          cout<<str[index];		//3
      }
  }
  执行流程是： 2 2 2 2 2..... 1 3 3 3 3 3.....
  

• 杨辉三角

最核心的也是找出递推关系：

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> ret(numRows);
        for (int i = 0; i < numRows; ++i) {
            ret[i].resize(i + 1);	//空间的初始化 
            ret[i][0] = ret[i][i] = 1;
            for (int j = 1; j < i; ++j) {
                ret[i][j] = ret[i - 1][j] + ret[i - 1][j - 1];	//最核心的递推关系
            }
        }
        return ret;
    }
};

217. 存在重复元素

这是用集合的特性来做的，集合本身就具有排同性O（nlog2n），还有一种解法就是先排序，之后再判断相邻元素是否相等来判断O(n)

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int>s;
        for(int x:nums){
            if(s.find(x)!=s.end()){
                return true;
            }
            s.insert(x);
        }
        return false;
    }
};

类似的287. 寻找重复数

和上篇文章剑指 Offer 03. 数组中重复的数字的解题思路一样，详情见上篇文章

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int res;
        int i=0;
        while(i<nums.size()){
            if(nums[i]==i){ //已经归位
                i++;
                continue;
            }
            else if(nums[i]==nums[nums[i]])
                return nums[i];
                swap(nums[i],nums[nums[i]]);
        }
        return res;
    }
};

剑指 Offer 29. 顺时针打印矩阵

模拟这个顺时针的过程，一开始向右走到右边界，走完上边界++，向下走到下边界，走完右边界--，向左走到左边界,走完下边界--，向上走上边界，走完左边界++

class Solution 
{
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) 
    {
        if (matrix.empty()) return {};
        vector<int> res;
        int l = 0;                      //左边界
        int r = matrix[0].size() - 1;   //右边界
        int t = 0;                      //上边界
        int b = matrix.size() - 1;      //下边界
        while (true)
        {
            //left -> right
            for (int i = l; i <= r; i++) res.push_back(matrix[t][i]);
            if (++t > b) break;
            //top -> bottom
            for (int i = t; i <= b; i++) res.push_back(matrix[i][r]);
            if (--r < l) break;
            //right -> left
            for (int i = r; i >= l; i--) res.push_back(matrix[b][i]);
            if (--b < t) break;
            //bottom -> top
            for (int i = b; i >= t; i--) res.push_back(matrix[i][l]);
            if (++l > r) break;
        }
        return res;
    }
};