LeetCode算法打卡--复杂度

最新推荐文章于 2020-10-30 09:41:30 发布

qi_700

最新推荐文章于 2020-10-30 09:41:30 发布

阅读量159

点赞数

本文链接：https://blog.csdn.net/qi_700/article/details/100887666

版权

54. 螺旋矩阵

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

链接：https://leetcode-cn.com/problems/spiral-matrix/

/*基本思想：先统计一共有几圈，然后每走一圈，下一圈边界都少1，四个方向遍历，注意边界条件
*/
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int cur_c;
        int row = matrix.size();
        vector<int> res;
         if(row==0)
            return res;
        int col = matrix[0].size();
        
        int c = (min(row, col)+1)/2;
        cur_c=0;
        cout<<c<<endl;
        
        while(cur_c<c )                //cur_c是当前循环的圈数，没循环一圈，边界行列均少1，
        { 
            int i,j;
            for(j=cur_c;j<col-cur_c;j++)          //从左向右
                res.push_back(matrix[cur_c][j]);
            if(cur_c+1==row-cur_c)                //本圈只有一行的情况，就直接返回了
                return res;
            for(i=cur_c+1;i<row-cur_c;i++)    //从上到下
            {
               
                res.push_back(matrix[i][j-1]);
            }
            if(j-1==cur_c)                        //本圈只有一列的情况 ，直接返回          
            {
                return res;
            }
            for(j=col-cur_c-2;j>=cur_c;j--)   //从右向左
            {
    
           
                res.push_back(matrix[i-1][j]);
            }
            
            for(i=row-cur_c-2;i>cur_c ;i--)   //从下到上
            {
               
                res.push_back(matrix[i][j+1]);
            }
            cur_c++;
        }
        return res;
    }
};

59. 螺旋矩阵 II

给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

链接：https://leetcode-cn.com/problems/spiral-matrix-ii/


/*基本思想：申请空间之后，顺序螺旋存放就好，注意下标的变化
*/
class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        
        int k=0;
        int cir = (n+1)/2;
        vector<vector<int>> res(n,vector<int>(n,0));
        int num=1;
        int start,i,j;
       
           for(start=0;start<(n+1)/2;start++)
           {
              
              for(j=start;j<n-k;j++)
                {res[start][j] = num;
                
                 num++;
                }
              
              for(i=start+1;i<n-k;i++)
              {
                  res[i][j-1] = num;
                   
                  num++;
              }
            
          
              for( j=j-2;j>=start;j--)
              {
                  res[i-1][j] = num;
                  
                  num++;
              }
              
             
              for(i=i-2;i>=start+1;i--)
              {
                  res[i][j+1] = num;
                 
                  num++;
              }
              
             k++;
           }
           
        
        return res;
    }
};

130. 被围绕的区域

给定一个二维的矩阵，包含 'X' 和 'O'（字母 O）。

找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X'填充。

链接：https://leetcode-cn.com/problems/surrounded-regions/


/*基本思想：遍历四条边上（上下左右边界）的O，并深度遍历dfs与其相连的O，将这些O都转为1

          1代表没被包围，再将这些1都变为O

*/
class Solution {
public:
    void dfs(int row,int col,vector<vector<char>>& board)
    {
        if(row<0 || row>=board.size() || col<0 ||col>=board[0].size()) return;
        
        if(board[row][col]=='O')
        {
            board[row][col] = '1';
            dfs(row,col+1,board);
            dfs(row+1,col,board);
            dfs(row,col-1,board);
            dfs(row-1,col,board);
        }
        
    }
    
    
    void solve(vector<vector<char>>& board) {
        
        if(board.size()==0)
            return;
        int r;
        int c;
        for(r=0;r< board.size();r++)
        {
            dfs(r,0,board);
            dfs(r,board[0].size()-1,board);
        }
        for(c=0;c<board[0].size();c++)
        {
            dfs(0,c,board);
            dfs(board.size()-1,c,board);
        }
        
        for(r=0;r<board.size();r++)
        {
            for(c=0;c<board[0].size();c++)
            {
                if(board[r][c] == '1')
                    board[r][c]='O';
                else
                    board[r][c]='X';
            }
        }
        
    }
};

11. 盛最多水的容器

给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

链接：https://leetcode-cn.com/problems/container-with-most-water

/*基本思想：对于每一个高度，分别找以他为一端边界的面积最大的，就是作为左边界和右边界中取最大，然后在所有高度中找最大。
           找以一个高度为边界的面积就是：作为右边界就是找从头开始第一个和他相同或比他大的边作为左边界围成的面积
                                      作为左边界就是找从尾开始第一个和他相同或比他大的边作为右边界围成的面积
*/
class Solution {
public:
    int maxArea(vector<int>& height) {
        
        int leftarea,rightarea;
        int i,j;
        int resarea=0;
        for(i=0;i<height.size();i++)
        {
           
            int lefti = i;
        
            for(j=0;j<i;j++){
                
                if(height[j] >= height[i])
                {
                   
                    lefti = j;
                    break;
                }
                
            }
           
            cout<<"lefti"<<lefti<<endl;
            leftarea = height[i] * (i-lefti);
            
            j=i+1;
            
            int righti = i;
            for(j=height.size()-1;j>i;j--)
            {
                if(height[j] >= height[i])
                {
                    
                    righti = j;
                    break;
                }

            }
           
            rightarea = height[i] * (righti-i);
            cout<<leftarea<<" "<<rightarea<<endl;
            resarea = max(resarea,max(leftarea,rightarea));
                
        }
        return resarea;
        
    }
};

48. 旋转图像

给定一个 n × n 的二维矩阵表示一个图像。

将图像顺时针旋转 90 度。

链接：https://leetcode-cn.com/problems/rotate-image/

/*基本思想：先按照左下到右上的对角线进行交换（翻转），然后每一行逆序就好
例
1 2  ->   1 3   ->  3 1
3 4       2 4       4 2
*/
class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        for(int i=0;i<matrix.size();i++)
        {
           for(int j=0;j<i;j++)
              swap(matrix[i][j],matrix[j][i]);
        }
        for(int i=0;i<matrix.size();i++)
        {
            reverse(matrix[i].begin(),matrix[i].end());
        }
    }
};

7. 整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

链接：https://leetcode-cn.com/problems/reverse-integer/

/*基本思想：方法一：利用to_string和atoi，to_string将int转换为string，反转之后用atoi将string转为int，此时溢出会抛出异常，异常返回0
           方法二：直接用longlong类型来处理反转的数据，然后判断不在int范围内返回0
*/

class Solution {
public:
  /*  int reverse(int x) {
    
        string s;
        s = to_string(x);
        int res = 0 ;
        if(s[0]=='-')
            std::reverse(s.begin()+1,s.end());
        else
            std::reverse(s.begin(),s.end());
         try 
     {  
            res=stoi(s);
     }  
    catch (std::out_of_range &exc) 
     {  
        return 0;
     }
        
        return res; 
        
    }*/


int reverse(int x) {
    long long res = 0;
    while (x) {
        res = res*10 + x%10;
        x /= 10;
    }
    return (res > INT_MAX || res < INT_MIN) ? 0 : res;
}
};

73. 矩阵置零

给定一个 m x n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。请使用原地算法，使用常数空间。

链接：https://leetcode-cn.com/problems/set-matrix-zeroes/

/*基本思想：用常数空间，主要可以利用第一行和第一列来存储状态，首先分别遍历第一行和第一列是否有0，有0的话设置标志记录
           然后从第二行第二列开始，如果是0，则对应的行的第一个设为0，对应列的第一个设为0，遍历存储
           都遍历之后，然后修改，如果对于某个数，他所在的行的第一个或者列的第一个为0（可能第一行或第一列本身就是0，也可能是之后遍历其他的时候设成的0），即它设为0
           最后根据之前的标志，如果第一行或者第一列有0，就把第一行或第一列都设为0
*/
class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int row_flag=0;
        int col_flag=0;
        int i,j;
        for(i=0;i<matrix.size();i++)
        {
            if(matrix[i][0]==0)
               col_flag=1;
        }
        for(j=0;j<matrix[0].size();j++)
        {
            if(matrix[0][j]==0)
              row_flag=1;
        }
        
       
        for(i=1;i<matrix.size();i++)
        {
            for(j=1;j<matrix[0].size();j++)
            {
                if(matrix[i][j]==0)
                {
                    matrix[i][0]=0;
                    matrix[0][j]=0;
                }
            }
        }
        
        for(i=1;i<matrix.size();i++)
        {
              
        
       for(j=1;j<matrix[0].size();j++)
        {
           if(matrix[i][0]==0 || matrix[0][j]==0)
               matrix[i][j]=0;
           
        }
        }


        if(row_flag)
        {
         for(j=0;j<matrix[0].size();j++)
         {
            matrix[0][j]=0;
         }
        }
         if(col_flag)
        {
         for(i=0;i<matrix.size();i++)
         {
            matrix[i][0]=0;
         }
        }
    }
};

9. 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

链接：https://leetcode-cn.com/problems/palindrome-number/

/*基本思想：方法一：转化为字符串，反转比较
           方法二：整数反转的方法，怕溢出用long
*/

class Solution {
public:
    /*bool isPalindrome(int x) {
        string s = to_string(x);
        string s1 =s;
        reverse(s.begin(),s.end());
        if(s1 == s)
           return true;
        else
           return false;
    }*/

    bool isPalindrome(int x)
    {
        if (x < 0)
            return false;
        long res = 0;
        long tmp = x;
        while (x) {
          res = res*10 + x%10;
          x /= 10;
       }
       return res==tmp;
    } 
    
};

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

链接：https://leetcode-cn.com/problems/longest-common-prefix/submissions/

/*基本思想：双指针判断

*/
class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
           int i=0;
           string res="";
           int flag=0;
          int j=0;
          if(strs.size()==0)
              return res;
            for( j=0;j<strs[0].size();j++)
            {
                char c=strs[0][j];
                for(i=0;i<strs.size();i++)
              { 
                    if(strs[i][j]!=c)
                    {
                     flag=1;
                     break;
                    }
              }
                if(flag==1)
                   break;
            }
        
         return  strs[0].substr(0,j);
    }
};

qi_700

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode算法打卡--复杂度

136. 只出现一次的数字给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。说明：你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？链接：https://leetcode-cn.com/problems/single-number/*基本思路：两种方法：方法一：数组排序，前后相同则跳过继续，...
复制链接

扫一扫