剑指offer刷题

3、数组重复数字

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        //* 遍历放进Set中,利用集合的特性(唯一性)进行解决
        //（1)set不允许重复，如果放不进去,那么就说明该元素重复
        //set() myset;//注意！！！
        set<int> myset;
        for (size_t i = 0; i < nums.size(); i++) {
            if(!myset.insert(nums[i]).second)//（3）insert返回值是键值对，第一个值是迭代器，第二个是插入成功与否.
            {
                return nums[i];
            }
        }
        return -1;
    }
};

(2)size_t是“整型”类型，保存的是一个整数。这种整数用来记录一个大小(size)。size_t的全称应该是size type，就是说“一种用来记录大小的数据类型”。
通常我们用sizeof(XXX)操作，这个操作所得到的结果就是size_t类型.
（3）

4、

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
       //（1）c++求二维数组行和列数（注意c++没有array.length和array[0].length）
        int h=matrix.size()/matrix[0].size();
        int l=matrix[0].size();
        
        if(h==0||l==0)
        {return false;}
        for(int i=0;i<h;i++)
        {
            for(int j=0;j<l;j++)
            {
                if(matrix[i][j]==target)
                return true;
            }           
        }
        return false;
    }
};

注意（1）

5、空格替换

public:
    string replaceSpace(string s) {//（1）string s就是一个字符数组，所以直接s[i]就是字符串中元素
    //string s1=" ";//（1）编译通过，但是提交出错！！！注意双引号“”不要“ ”！？？？
    string s1="";
//方法一：（2）增强型for循环
    for(char ch:s )//(2)注意这个是冒号不是分号！！！
    {
     s1=(ch==' ')?s1+"%20":s1+ch;//看清题啊是%20而不是20%
    }
//方法二：
   //for(int i=0;i
   // {
   //    s1=(s[i]==' ')?s1+"20%":s1+s[i]; //20%记得加“”
   //}
    return s1;
    }
};

6、反转打印链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> res;//自己加的，可以在这写代码
    vector<int> reversePrint(ListNode* head) {
    //方法一：reverse方法
    /*
    while(head)
    {
        res.push_back(head->val);
        head=head->next;//注意这两句都是head->  因为head相当于钙元素其实地址，他可以访问该元素val和next提供-》
    }
    reverse(res.begin(),res.end());//注意这一句写法res.begin(),res.end()
    return res;
   */
   //方法二：入栈法
    stack<int> s;
    while(head)
    {
     s.push(head->val);
     head=head->next;
    }
    while(!s.empty())
    {
        res.push_back(s.top());//访问使用栈顶元素
        s.pop();//每使用一个栈顶元素便弹出一个
    }
    return res;
    }  
};

class Solution {
public:
    int fib(int n) {
    if(n==1||n==0)
    return n;

    long long fibone=0;
    long long fibtow=1;
    long long fibn=0;//主意用long long数很大
    for(int i=2;i<=n;i++)
    {
        //fibn=fibone+fibtow;//（1）//数太大会报错！！！在这里，每一次都取模数就不会超限！
        fibn=(fibone+fibtow)%1000000007;//(2)
        fibone=fibtow;
        fibtow=fibn;
    }
    // return fibn%1000000007;//（1）//数太大会报错！！！
    return fibn;//（2）
    }
};

注意：看题：要取模！注意取模位置！！！

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
    if(head==NULL||k==0)//(1)情况12
    return NULL;

    ListNode* l1=head;
    ListNode* l2=head;
    //for(int i=0;i
    for(int i=0;i<k-1;i++)//间距是k-1不是k！！！！
    {
        if(l1->next==NULL)//（1）情况3
        {return NULL;}
        else
        //{l1=l1->l1.next;}
        {l1=l1->next;}
    }
    //while(l1!=NULL)//(3)这时l1都跑到最后一个节点后面的了。也就是说l1和l2都多走了一步！！！
    while(l1->next!=NULL)
    {
        //l1=l1->l1.next;
        //l2=l2->l2.next;
        l1=l1->next;
        l2=l2->next;
    }
    return l2;
    }
};

注意：（1）三种特殊情况，鲁棒
（2）（3）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //双指针解法
        ListNode* l1=head;
        ListNode* l2=NULL;
        while(l1!=NULL)//注意：不是l1->next!=null
        {
            ListNode* t=l1->next;
            l1->next=l2;
            l2=l1;
            l1=t;
        }
        return l2;
    }
};

有没有特殊情况？？？？