leetcode 练习

最新推荐文章于 2022-01-07 10:03:37 发布
最新推荐文章于 2022-01-07 10:03:37 发布
阅读量198 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scutedu/article/details/105483462
版权

1.华为面试题一

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

class Solution {
public:
    string reverseWords(string s) {
        reverse(s.begin(), s.end());
        int left = 0;
        int i = 0;
        for (; i < s.size(); i++)
        {
            if (s[i] == ' ')
            {
                reverse(s.begin() + left, s.begin() + i );
                left = i +1;            
            }
        }
        if (left <= i - 1)
        {
            reverse(s.begin() + left, s.begin() + i);
        }

       
        cout << s << endl;
        return s;
    }
    
};

 

 

5 leetcode

#include <iostream>

#include <string>

#include <algorithm>

#include <vector>

using namespace std;

 

#define MAX(a,b)  ((a)>(b)?(a):(b)) 

 

class Solution {

public:

    string longestPalindrome(string s) {

        if (s.size() == 0)

            return "";

        if (s.size() == 1)

            return s;

        int n = s.size();

        int max = 1;

        int leftmax = 0;

        for (int i = 0; i < n; i++)

        {

            int j = i + 1;

            int r = i-1;

            while (j < n&&r >= 0 && s[r] == s[j])  //奇数

            {

 

                int t=MAX(max, j - r + 1);

                if (max <t)

                    leftmax = r;

                max = t;

                r--;

                j++;

            }

            

            j = i+1;

            r = i;

            while (j < n&&r >= 0 && s[r] == s[j]  )  //偶数

            {

                int t = MAX(max, j - r + 1);

                if (max <t)

                    leftmax = r;

                max = t;

                r--;

                j++;    

                

            }

            

        }

        cout << s.substr(leftmax, max) << endl;

        return s.substr(leftmax, max);

    }

    

};

 6

class Solution {

public:

    string convert(string s, int numRows) {

        if(numRows==1) return s;

        int n=s.size();

        vector<string> vec(min(n,numRows));

        bool bflag=false;

        int row=0;

        for(int i=0;i<n;i++)

        {

            vec[row]+=s[i];

            

            if(row==0 || row==numRows-1)

                    bflag=!bflag; 

            

            if(bflag)

                row++;

            else

            {

                row--;

            }

            

        }

        string res;

        for(string t:vec)

        {

            res+=t;

        }

    

         return res;

    }

};

 

7.

class Solution {

public:

      int reverse(int x) {

        long res=0;

        while(x!=0)

        {

            res=res*10+x%10;

            x=x/10;

        }

        return  res>2147483647||res<-2147483648?0:res;

    }

};

 

8.

  int myAtoi(string str) {

        int n=str.size();

        int i=0;

        for(;i<n;i++)

        {

            if(str[i]!=' ')

                break;

        }

        int b=1;

        int j=i;

        long res=0;

        if(str[i]=='-')

        {

            j++;

            b=-1;

        }

        if(str[i]=='+')

        {

            j++;

            b=1;

        }

 

        for(;j<n;j++)

        {

            if(str[j]>='0'&&str[j]<='9')

            {

                res=res*10+str[j]-'0';

                if((b*res)>2147483647)

                {

                    res=2147483647;

                    break;

                }

                if((b*res)<-2147483648)

                {

                    res=-2147483648;

                    break;

                }

                    

            }

            else

            {

                break;

            }

            

        }

        res*=b;

        cout<<res<<endl;

        return res;

    }

 

9.

 bool isPalindrome(int x) {

        if(x<0)

            return false;

        long rx=0,num=x;

        while(num!=0)

        {

            rx=rx*10+num%10;

            num=num/10;

        }

        if(x==rx)

            return true;

        else

        {

            return false;

        }       

    }

 

10.

// //正则表达式匹配

//     bool isMatch(const string& s,const  string& p)

//     {

//         return doMatch(s, 0, p, 0);

//     }

//     // 考察s串从sIndex开始的子串与模式串p中从pIndex开始的子串是否匹配（均包括开始位置直到末尾）。

//     bool doMatch(const string& s, int sIndex, const string& p, int pIndex)

//     {

//      if (pIndex >= p.size()) return sIndex >= s.size(); //p索引大于p长度，str到末尾则表示匹配成功，否则失败

 

//      bool currentMatch = sIndex < s.size() && (s[sIndex] == p[pIndex] || p[pIndex] == '.');

 

//         if(pIndex + 1 < p.size() && p[pIndex + 1] == '*')

//         {

//          // *匹配0个字符(无论当前字符匹不匹配这都有可能s = abbc, p = ab*bbc) || 当前字符匹配并尝试s中的下一个字符

//          return doMatch(s, sIndex, p, pIndex + 2) || (currentMatch && doMatch(s, sIndex + 1, p, pIndex));

//         }

//         else // 没有*

//         {

//          // 正常匹配，包括了.

//             // 匹配上就考察下一个，否则 return false

//          return currentMatch && doMatch(s, sIndex + 1, p, pIndex + 1);

//         }

//     }

11.

    int maxArea(vector<int>& height)

    {

        //双指针法移动

        int len=height.size();

        int max=0;

        int j=len-1;

        for(int i=0;i<j;)

        {

             max=MAXTF(MINTF(height[i],height[j])*j-i,max);

             if(height[i]<height[j])

             {

                 i++;

             }

             else

             {

                 j--;

             }        

        }

        return max;

    }

 

12.

    string intToRoman(int num)

    {

        if(num<1||num>3999)

            return "";

        vector<int> store={1000,900,500,400,100,90,50,40,10,9,5,4,1};

        vector<string> str={"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};

        string res;

        int size=store.size();

        for(int i=0;i<size;i++)

        {

            while(num>=store[i])

            {

                res.append(str[i]);

                num-=store[i];

            }

        }

        return res;

    }

 

13.

        int romanToInt(string s)

        {

            map<char,int> s_v=

            {

            make_pair('M',1000),make_pair('D',500),make_pair('C',100),make_pair('L',50),

            make_pair('X',10),make_pair('V',5),make_pair('I',1)

            };

            if(s.size()==0)

                return 0;

            s+="I";

            int res=0;

            int i=0;

            for(;i<s.size()-1;i++)

            {

                if(s_v[s[i]]>=s_v[s[i+1]])

                    res+=s_v[s[i]];

                else    res-=s_v[s[i]];

            }

            return res;

        }

14.

 string longestCommonPrefix(vector<string>& strs)

    {

        if(strs.size()==0)  return "";

        if(strs.size()==1)    return strs[0];

        string res="";

        for(int i=0;i<strs[0].size();i++)

        {

            for(int j=1;j<strs.size();j++)

            {

                if(strs[0][i]!=strs[j][i])

                {

                    return res;

                }

            }

             res.push_back(strs[0][i]);

        }

        return res;

    }

15.

vector<vector<int>> threeSum(vector<int>& nums)

    {

        sort(nums.begin(),nums.end());

        vector<vector<int>> res;

        if(nums.size()<3)   return res;

        int len=nums.size();

        int l=1,r=len-1;

        for(int i=0;i<nums.size()-2;i++)

        {

            l=i+1;

            r=len-1;

            if(nums[i]>0||nums.size()<3)   break;

            if(i>0&&nums[i]==nums[i-1])  continue;

            while(l<r)

            {

                if((nums[i]+nums[l]+nums[r])==0)

                {

                    vector<int> t={nums[i],nums[l],nums[r]};

                    res.push_back(t);

                    l++;

                }

                else if(r+1<nums.size()&&nums[r]==nums[r+1]||(nums[i]+nums[l]+nums[r])>0)

                    r--;

                else if(l>i&&nums[l]==nums[l-1]||(nums[i]+nums[l]+nums[r])<0)

                    l++;

            }         

        }

        return res;

    }

16.

    int threeSumClosest(vector<int>& nums, int target) {

        sort(nums.begin(), nums.end());

        if (nums.size() < 3) {

            int res = 0;

            for (int i = 0; i < nums.size(); i++) {

                res += nums[i];

            }

            return res;

        }

        int isum = nums[0] + nums[1] + nums[2];

        for (int i = 0; i < nums.size(); i++) {

            int left = i + 1, right = nums.size() - 1;

            while (left < right) {

                int csum = nums[i] + nums[left] + nums[right];

                if (abs(csum - target) < abs(isum - target))

                    isum = csum;

                if (csum < target)

                    left++;

                else if (csum > target)

                    right--;

                else

                    return target;

            }

        }

        return isum;

    }

17

  map<char,string> mapc={

            {'2',"abc"},

            {'3',"def"},

            {'4',"ghi"},

            {'5',"jkl"},

            {'6',"mno"},

            {'7',"pqrs"},

            {'8',"tuv"},

            {'9',"wxyz"}

        }  ;

     vector<string> res;

        string s;

    void dnf(int index ,string digits)

    {

        if(index==digits.size())

        {

            res.push_back(s);

            return ;

        }

        for(int i=0;i<mapc[digits[index]].size();i++)  //按键对应的字母

        {

            s.push_back(mapc[digits[index]][i]);

            dnf(index+1,digits);

            s.pop_back();

        }

    }

    vector<string> letterCombinations(string digits)

    {

        if(digits.size()==0)

            return res;

        dnf(0,digits);

        return res;

    }

 

18

  vector<vector<int>> fourSum(vector<int>& nums, int target) {

      vector<vector<int>> res;

       if(nums.size()<4)

             return res;

      sort(nums.begin(),nums.end());

      int size=nums.size();

        for(int i=0;i<nums.size()-3;i++)

        {

            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target)  break;

            if(nums[i]+nums[size-1]+nums[size-2]+nums[size-3]<target) continue;

            if(i>0 && nums[i]==nums[i-1])  continue;

            for(int j=i+1;j<size-2;j++)

            {

                if(nums[i]+nums[j]+nums[j+1]+nums[j+2] >target)  break; 

                 if(nums[i]+nums[j]+nums[size-1]+nums[size-2]<target) continue;

                if(j>i+1 && nums[j]==nums[j-1])  continue;

                int left=j+1,right=size-1;

                while(left<right)

                {

                    if((nums[i]+nums[j]+nums[left]+nums[right])==target)

                    {

                         vector<int> tv={nums[i],nums[j],nums[left],nums[right]};

                         res.push_back(tv);

                         int tleft=left,tright=right;

                         while(left<right && nums[tleft]==nums[left])  left++;

                         while(left<right && nums[tright]==nums[right]) right--;

                    }

                    if((nums[i]+nums[j]+nums[left]+nums[right])<target)

                    left++;

                    else if((nums[i]+nums[j]+nums[left]+nums[right])>target)

                    right--;

                }

            }          

        }

        return res;

    }

19

      ListNode* removeNthFromEnd(ListNode* head, int n) {

        vector<ListNode *>  nodeVec;

        if(head==NULL)

            return head;

        ListNode * p=head;

        while(p)

        {

            nodeVec.push_back(p);

            p=p->next;

        }

        if(n==nodeVec.size())

            return head->next;

        nodeVec[nodeVec.size()-n-1]->next=nodeVec[nodeVec.size()-n]->next;

        delete nodeVec[nodeVec.size()-n];

        nodeVec[nodeVec.size()-n]=NULL;

        return head;

    }

20

    bool isValid(string s) {
        bool b = false;
        stack<char> ls;
        ls.push(' ');
        map<char, char> mapcc = {
            { '(', ')' },
            { '[', ']' },
            { '{', '}' },
            { ' ', ' ' },
        };
        for (int i = 0; i < s.size(); i++)
        {
            if (mapcc[ls.top()] == s[i])
            {
                ls.pop();
            }
            else
            {
                ls.push(s[i]);
            }
        }
        return ls.size() > 1 ? false : true;
    }

21

  ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {

      ListNode *p=NULL,*phead=new ListNode(-1);

      p=phead;

      while(l1!=NULL && l2 !=NULL)

      {

          if(l1->val > l2->val)

          {

              p->next=l2;

              l2=l2->next;

          }

          else{

              p->next=l1;

              l1=l1->next;

          }

          p=p->next;

      }

      p->next= (l1==NULL)?  l2: l1;

        return phead->next;

    }

22

回溯法

      vector<string> generateParenthesis(int n) {

         vector<string> res;

         dfs(res,"",0,0,n);

        return res;

    }

    void dfs(vector<string> &res,string cur,int l,int r,int n)

    {

        if(r>l||l>n||r>n) return ;

       if(l==n  && r==n) 

        {

            res.push_back(cur);

            return ;

        } 

        dfs(res,cur+"(",l+1,r,n);

        dfs(res,cur+")",l,r+1,n);        

    }

23

    ListNode* mergetwoList(ListNode *l1,ListNode *l2)

    {

        if(l1==NULL)    return l2;

        if( l2==NULL)   return l1;

        if(l1->val > l2->val)

        {

             l2->next=mergetwoList(l1,l2->next);

             return l2;

        }

        else{

             l1->next=mergetwoList(l1->next,l2);

             return l1;

        }

    }

 

    ListNode* mergeKLists(vector<ListNode*>& lists) {

        if(lists.size()==0) return NULL; 

        ListNode *phead=lists[0];

        for(int i=1;i<lists.size();i++)

        {

            phead=mergetwoList(phead,lists[i]);

        }

        return phead;

    }

24.

 ListNode *swapPairs(ListNode *head)

    {

       if(head==NULL|| head->next ==NULL)  return head;

        ListNode *node=head->next;

        head->next=swapPairs(head->next->next);

        node->next=head;

        return node;

    }

 

26

    int removeDuplicates(vector<int>& nums) {

        int res=0,t=0;

        int size=nums.size();

        nums.push_back(1);

        for(int i=0;i<size;i++)

        {

            

            nums[t]=nums[i];

            t++;

            while(nums[i]==nums[i+1]&& i+1<size) i++ ;

        }

        return t;

    }

27.

 

    int removeElement(vector<int>& nums, int val) {

        int i=0,j=0;

        for(;j<nums.size();j++)

        {

            if(nums[j]!=val)

            {

                nums[i++]=nums[j];

            }

        }

        return i;

    }

42.

    int trap(vector<int>& height)

    {

        int left=0;

        int len=height.size();

        if(len==0)  return 0;

        int cur=height[0],res=0;

        int m=max_element(height.begin(),height.end())-height.begin();

        for(int i=1;i<m;i++)

        {

            if(height[i]>=cur)

            {

                cur=height[i];

            }

            else

            {

                res+=(cur-height[i]);

            }    

        }

        cur=height[len-1];

        for(int j=len-2;j>m;j--)

        {

            if(height[j]>=cur)

                cur=height[j];

            else

            {

                res+=(cur-height[j]);

            }   

        }

        return res;

    }

 

scutedu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode:leetcode 练习
05-30
在IT行业中，LeetCode是一个非常受欢迎的在线平台，它提供了大量的编程练习题，旨在帮助开发者提升他们的算法技能和解决问题的能力。对于JavaScript开发者来说，利用LeetCode进行练习是提高JavaScript实战能力的重要...
leetcode:leetcode练习
05-16
标题 "leetcode: leetcode练习" 暗示了这是一个关于使用LeetCode平台进行编程练习的项目，特别是针对Java语言的。LeetCode是一个流行的在线平台，它提供了大量的算法和编程问题，帮助开发者提升技能并准备技术面试。...
44. 通配符匹配/C++
Zolewit的博客
07-29 761
动态规划 dp[i][j]表示s的前i个字符与p的前j个字符是否匹配。 bool isMatch(string s, string p) { size_t m = s.size(), n = p.size(); vector<vector<bool>> dp(m + 1, vector<bool>(n + 1, false)); dp[0][0] =...
回溯算法
dtzly的博客
12-13 136
216. 组合总和 III 思路：题意是给定[k,n], 从1-9中选出k个数字，他们的和等于n。做法是枚举1-9的数字进行深搜。这里要注意JAVA的深拷贝和浅拷贝。 代码： class Solution { private void dfs(List<List<Integer>> res, List<Integer> tmp, int cur, int n, int k){ //如果候选数字的个数达到k并且和是n(n每次遇到新元素减去直到为0)
java 有序数组 频率,高频算法题解 java
weixin_39825722的博客
03-14 88
替换空格public void replaceSpace(){String s="abc de f ";String t= s.replace(" ","%20");System.out.println(t);}顺时针打印矩阵import java.util.ArrayList;import java.util.List;public class SpiralMatrix {public List...
leetcode JAVA Palindrome Partitioning 3.45 难度系数3
修学储能,平凡之路
02-11 1148
Question： Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of s. For example, given s = "aab", Return
根据字符串恢复IP问题
not_in_mountain的博客
09-17 270
原文链接：http://blog.csdn.net/u011095253/article/details/9158449 public class Solution { public ArrayList restoreIpAddresses(String s) { ArrayList res = new ArrayList(); if (s.l
leetcode练习
qq_36047533的博客
03-31 145
leetcode leetcode第二题 class Solution: def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode: h1=l1 p1=l1 p2=l2 mark=0 while p1.next or p2....
LeetCode练习
种花家的兔子
08-14 143
LeetCode练习 8. 字符串转换整数 (atoi) class Solution { public: int myAtoi(string str) { long long result=0; int len=0,flag=0,temp=0; for(int i=0;i<str.length();i++) { if((str[...
Leetcode练习(Python)
mayanyun2013的专栏
08-12 193
Leetcode练习(Python)：数学类：第7题：整数反转：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 题目： 整数反转：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。 注意: 假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2^31, 2^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。 class Solution(object): @classmethod def reverse(se
Leetcode练习记录
weixin_47532216的博客
01-07 461
文章目录1. 第一天 1. 第一天
LeetCode 练习
杨小熊学习笔记
02-08 2746
对应项目github地址 LintCode 与 LeetCode 练习 LintCode 官网 LintCode 793. Intersection of Arrays 求数组的交集的size LintCode 792.Kth Prime Number 判断素数n是第几个素数 LintCode 761. Smallest Subset LintCode 744. Sum of ...
LeetCode：leetcode练习
02-23
Leetcode练习，其顺序为： ://www.changgy.com/leetcode-101 图样：贪婪 455分配Cookie（简单） 135糖果（硬） 移动零点（简单） 给定总和的最小子数组（简单） 最长的具有K个不同字符的子字符串（中） 水果入...
leetCode:leetCode练习
03-13
在"leetCode: leetCode练习"这个主题中，我们主要关注的是使用Java解决LeetCode上的各种问题。这些题目涵盖了从基础到高级的各种算法，如排序、搜索、动态规划、图论、字符串处理等。在解答过程中，你将有机会实践...
Leetcode:Leetcode练习
03-10
LeetCode 是一个在线平台，专为程序员提供算法练习和面试准备。它包含了各种难度级别的编程题目，涵盖了数据结构和算法的广泛领域，如数组、链表、字符串、二叉树、图、动态规划等。使用 LeetCode 可以提升你的编程...
牛客网-斐波那列数列
scutedu的博客
11-14 521
int FeiBoNaQie::Fibonacci(int n) {     //方案一：用递归做的，当n的值比较大，大于38 时运行时间为1秒多，     //n越大，越耗时越多     //if (0 == n)     //{     //    return 0;     //}     //if (1 == n||2==n)     //{     //    ret
牛客网-二进制中1的个数
scutedu的博客
11-15 519
class Solution { public:      int  NumberOf1(int n) {              int count = 0;     if (n         n = n & 0x7FFFFFFF;         ++count;     }     while (n)     {         count += (n & 1);
反转链表
scutedu的博客
11-18 495
用了别人的做解释： public class Solution {     public ListNode ReverseList(ListNode head) {                 if(head==null)             return null;         //head为当前节点，如果当前节点为空的话，那就什么也不做，直接返回null；    
调整数组顺序
scutedu的博客
11-16 486
void CodeComplite::reOrderArray(vector &array) { /*     //冒泡法，时间换空间     if (0 == array.size())     {         return;     }     int temp = 0;     int i = 0,j=0;     for (i = 0; i     {   
leetcode指南
最新发布
08-26
3. 刷题和练习：刷LeetCode的题目是提高编程能力和算法思维的有效方式。开始时可以选择一些简单的题目，逐渐增加难度。保持刷题的节奏，坚持练习可以加深对不同问题类型的理解和掌握相应的解题技巧。 4. 学习他人的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值