结构体、类、指针、引用

21. 斐波那契数列

题目地址

class Solution {
public:
    int Fibonacci(int n) {
        return f(n);
    }
    int f(int n)
    {
        if(n==0) return 0;
        if(n==1||n==2) return 1;
        return f(n-1)+f(n-2);
    }
};

16. 替换空格

题目地址

class Solution {
public:
    string replaceSpaces(string &str) {
        string ans;
        for(int i=0;i<str.size();i++) 
        {
             if(str[i]==' ') ans+="%20";
             else ans+=str[i];
        }
        return ans;
    }
};

78. 左旋转字符串

题目地址

class Solution {
public:
    string leftRotateString(string str, int n) {
        string a=str.substr(0,n);
        str=str.substr(n);
        str+=a;
        return str;
    }
};

class Solution {
public:
    string leftRotateString(string str, int n) {
        return str.substr(n)+str.substr(0,n);
    }
};

87. 把字符串转换成整数

题目地址

class Solution {
public:
    int strToInt(string str) {
        if(!str.size()) return 0;
        
        int  flag=1;
        long long sum=0;
        
        while(str[0]==' ') str=str.substr(1);
        if(str[0]=='+') str=str.substr(1);
        else if(str[0]=='-') str=str.substr(1),flag=-1;
        
        while(str.size()) 
        {
            if(str[0]<'0'||str[0]>'9') break;
            sum=sum*10+str[0]-'0';
            str=str.substr(1);
        }
        sum=sum*flag;
        if(sum>INT_MAX) return INT_MAX;
        if(sum<INT_MIN) return INT_MIN;
        return sum;
    }
};

84. 求1+2+…+n

题目地址

class Solution {
public:
    int getSum(int n) {
       int res=n;
       n>0&& (res+=getSum(n-1));
       return res;
    }
};

28. 在O(1)时间删除链表结点

题目地址

我们不知道前驱，但是我们可以复制后继的值，再将其后继删除即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        auto p=node->next;
        node->val=node->next->val;
        node->next=p->next;
        
        delete p;
    }
};

36. 合并两个排序的链表

题目地址

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* merge(ListNode* l1, ListNode* l2) {
        auto head=new ListNode(-1);
        auto temp=head;
        while(l1&&l2)
        {
            if(l1->val<=l2->val) temp=temp->next=l1,l1=l1->next;
            else temp=temp->next=l2,l2=l2->next;
        }
        while(l1) temp=temp->next=l1,l1=l1->next;
        while(l2) temp=temp->next=l2,l2=l2->next;
        return head->next;
    }
};

35. 反转链表

题目地址

头插法

/**
 * 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* ans=nullptr;
       ListNode* p=head;
       while(p)
       {
            ListNode* temp=p->next;
            p->next=ans;
            ans=p;
            p=temp;
       }
       return ans;
    }
};

66. 两个链表的第一个公共结点

题目地址
暴力做法TLE一个点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) {
        while(headA)
        {
            auto temp=headB;
            while(temp)
            {
                if(temp==headA) return temp;
                temp=temp->next;
            }
            headA=headA->next;
        }
        return nullptr;
    }
};

让A和B一块走，A走到底了走B那条路，B走到底了走A那条路。‘
俩人走的总路径和是一模一样的，故一定可以找到公共点(包括公共点是null的情况)。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) {
       auto p=headA,q=headB;
       while(p!=q)
       {
           if(p) p=p->next;
           else p=headB;
           if(q) q=q->next;
           else q=headA;
       }
       return p;
    }
};

29. 删除链表中重复的节点

题目地址

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplication(ListNode* head) {
        auto ans=new ListNode(-1);
        auto p=ans;
        while(head)
        {
            int t=head->val;
            bool flag=false;//标记是否重复
            while(head->next&&head->next->val==t) head=head->next,flag=true;//一直重复就一直移动
            if(!flag) p=p->next=head;//不重复就加
            head=head->next;
        }
        p->next=nullptr;//让答案的最后结点指向null,目的是断开可能与原链表的多余数
        return ans->next;
    }
};