简单的leetcode题

简单的leetcode题

环绕字符串中唯一的子字符串

把字符串 s 看作是\(“abcdefghijklmnopqrstuvwxyz”\)的无限环绕字符串，所以 s 看起来是这样的\(“zabcdefghijklmnopqrstuvwxyzabcdefghijklm....”\)

现在我们有了另一个字符串 p 。你需要的是找出 s 中有多少个唯一的 p 的非空子串，尤其是当你的输入是字符串 p ，你需要输出字符串 s 中 p 的不同的非空子串的数目。

注意: p 仅由小写的英文字母组成，p 的大小可能超过 10000。

分析：我们以26字母分别结尾为划分，这样可以保证子字符串不重复。答案就是每个字母结尾的最大子字符串长度加起来。

class Solution {
public:
    int findSubstringInWraproundString(string p) {
        if(p.size()==0)
            return 0;
        int dp[27]={0};//以每个字母结尾的字串长度
        int last=1;//此时结尾处的长度
        dp[p[0]-'a']=1;//边界条件
        for(int i=1;i<p.size();i++)
        {
            if(dp[p[i]-'a']==0)
                dp[p[i]-'a']=1;
            int j=i-1;
            if((p[i]-p[j]+26)%26==1)//判断条件
            {
                if(last+1>=dp[p[i]-'a'])//出现更加长的子串
                {
                    dp[p[i]-'a']=last+1;
                }
                last++;
            }
            else
                last=1;
        }
        int ans=0;
        for(int i=0;i<26;i++)
        {
            ans+=dp[i];
        }
        return ans;
    }
};

二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

非递归版本

分析：二叉树层次遍历，然后只加最后一个点的值即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
       vector<int>ans;
       queue<TreeNode* >Q;
         if(root)
            Q.push(root);
        while(Q.size())
        {
            int n=Q.size();
            for(int i=0;i<n;i++)
            {
                TreeNode* cur=Q.front();
                Q.pop();
                if(i==n-1)
                    ans.push_back(cur->val);
                if(cur->left)
                    Q.push(cur->left);
                if(cur->right)
                    Q.push(cur->right);
            }
        }
        return ans;
    }
};

递归版本

分析：当递归到第k层时(设根节点为第0层)，如果这时ans数组里面有k个元素，加把此时的节点的值加入ans数组中。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
       vector<int>ans;
       dfs(root,ans,0);
        return ans;
    }
    void dfs(TreeNode* root,vector<int> &ans,int cnt)
    {
        if(!root)
            return ;
        if(ans.size()==cnt)
            ans.push_back(root->val);
        dfs(root->right,ans,cnt+1);
        dfs(root->left,ans,cnt+1);
    }
};

合并两个有序链表

递归版本

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL)
            return l2;
        else if(l2==NULL)
            return l1;
        else if(l1->val<l2->val)
            {
                l1->next=mergeTwoLists(l2,l1->next);
                return l1;
            }
        else
        {
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};

非递归版本

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

排序链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
       ListNode Head(-1);
       Head.next=head;
       ListNode* p=head;
       int len=0;
       while(p)
       {
           len++;
           p=p->next;
       }
       for(int siz=1;siz<len;siz=siz*2)
       {
           ListNode* cur=Head.next;
            ListNode* tail=&Head;
            while(cur)
            {
                ListNode* left=cur;
                ListNode* right=cut(left,siz);
                cur=cut(right,siz);
                tail->next=merge(left,right);
                while(tail->next)
                {
                     tail= tail->next;
                }
            }

       }
       return Head.next;
}
    ListNode* cut(ListNode* p,int n)
    {
        while(p&&--n)
        {
            p=p->next;
        }
        if(!p)
            return NULL;//返回空指针
        ListNode* r=p->next;
        p->next=NULL;
        return r;
    }
    ListNode* merge(ListNode* l1,ListNode* l2)
    {
        ListNode head(-1);
        ListNode* p=&head;
        while(l1&&l2)
        {
            if(l1->val<l2->val)
            {
                p->next=l1;
                l1=l1->next;
            }
            else
            {
                p->next=l2;
                l2=l2->next;
            }
            p=p->next;
        }
        p->next=(l1?l1:l2);
        return head.next;
    }
};