Leetcode Problem 汇总一

最新推荐文章于 2020-10-03 21:39:11 发布
最新推荐文章于 2020-10-03 21:39:11 发布
阅读量723 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Heu_Ice_Fire/article/details/21274439
版权

此文章内的所有题目选自Leetcode,实现语言为Python && C++.

地址：http://oj.leetcode.com/


第一题：

Triangle

地址：http://oj.leetcode.com/problems/triangle/

分析：题目要求O(n)的内存，简单DP问题，自下而上。

代码：

class Solution:
    # @param triangle, a list of lists of integers
    # @return an integer
    def minimumTotal(self, triangle):
        tri_len = len(triangle)
        i = tri_len - 2
        while i >= 0 :
            ele_len = len(triangle[i])
            for j in range(ele_len):
                triangle[i][j] = min(triangle[i+1][j],triangle[i+1][j+1]) + triangle[i][j]
            i = i-1
        return triangle[0][0]


第二题：

Gray Code

地址：oj.leetcode.com/problems/gray-code/

分析：求格雷码，格雷码是有规律的，比如4位二进制格雷码，则从右向左，第一位上变化规律为0110,第二位变化规律00111100，以此推之。

代码：

class Solution:
    # @return a list of integers
    def work(self, pos, time):
        count = int(1)
        for i in range(pos):
            count = count*2
        time = time % (count*2)
        if time <= count/2:
            return 0
        elif time > count/2 and time <= (count+count/2):
            return 1
        return 0 
    
    def grayCode(self, n):
        ans = []
        count = int(1)
        for i in range(n):
            count = count*2
        for i in range(count):
            num = int(0)
            for j in range(n):
                num = num*2 + Solution.work(self, n-j, i+1)
            ans.append(num)
        return ans

第三题：

Maximum Depth of Binary Tree

地址：http://oj.leetcode.com/problems/maximum-depth-of-binary-tree/

分析：求树的深度，递归即可。

代码：（C++版本）

class Solution {
public:
    int max;
    void dfs(TreeNode *root, int depth)
    {
        if(root->left == NULL && root->right == NULL)
        {
            if( depth > max )
                max = depth;
            return ;
        }
        if( root->left != NULL )
        {
            dfs( root->left, depth+1);
        }
        if( root->right != NULL )
        {
            dfs( root->right, depth+1);
        }
    }
    int maxDepth(TreeNode *root) {
		if( root == NULL ) return 0;
		max = 0;
        dfs(root,1);
        return max;
    }
};

第四题：

Add Two Numbers

地址：http://oj.leetcode.com/problems/add-two-numbers/

分析：主要考察链表的使用

代码(C++版本)：

class Solution {
public:
    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
		struct ListNode *ans(0), *ok(0);
		int num, num1, num2, pre = 0;
		ok = ( struct ListNode * )malloc( sizeof( struct ListNode ));
		ans = ( struct ListNode * )malloc( sizeof( struct ListNode ));
		ok->next = ans;
		ans->val = 0;
		while( 1 )
		{
			if( l1 == NULL && l2 == NULL ) break;
			num1 = num2 = num = 0;
			if( l1 != NULL )
			{
				num1 = l1->val;
				l1 = l1->next;
			}
			if( l2 != NULL )
			{
				num2 = l2->val;
				l2 = l2->next;
			}
			num = num1 + num2 + ans->val;
			pre = num/10;
			ans->val = num%10;
			if(( l1 != NULL || l2 != NULL ) || ( pre != 0 ) )
			{
				struct ListNode *add;
				add = ( struct ListNode * )malloc( sizeof( struct ListNode) );
				add->val = 0, add->next = NULL;
				add->val = pre;
				ans->next = add;
				ans = ans->next;
			}
		}

		return ok->next;
    }
};

python版本： 

# Definition for singly-linked list.
class ListNode:
def __init__(self, x):
    self.val = x
    self.next = None

class Solution:
    # @return a ListNode
    def addTwoNumbers(self, l1, l2):
        ans = ListNode()
        ok = ListNode()
        ok.next = ans
        num = 0
        pre = 0
        while true:
            if l1 == None and l2 == None:
                break
            num1 = num2 = num = int(0)
            if l1 != None:
                num1 = l1.val
                l1 = l1.next
            if l2 != None:
                num2 = l2.val
                l2 = l2.next
            num = num1 + num2 + ans.val
            pre = num//10
            ans.val = num % 10
            if l1 != None or l2 != None or pre != 0:
                add = ListNode()
                add(0)
                add.val = pre
                ans.next = add
                ans = ans.next
        return ok.next

第五题：

Merge Sorted Array

地址：http://oj.leetcode.com/problems/merge-sorted-array/

分析：挺简单的一个，two pointers算法

代码：

（C++版）

class Solution 
{
public:
    void merge(int A[], int m, int B[], int n) 
    {
        int i, j, cnt = 0;

        for( i = m-1; i >= 0; i-- )
            A[n+i] = A[i];
        for( i = 0, j = 0;; )
        {
            if(i == m || j == n) break;
            if(A[i+n] < B[j])
            {
                A[cnt] = A[i+n];
                i += 1;
            }
            else
            {
                A[cnt] = B[j];
                j += 1;
            }
            cnt += 1;
        }
        if(i < m)
        {
            for(; i < m; i++)
                A[cnt] = A[i+n], cnt += 1;
        }
        if(j < n)
        {
            for(; j < n; j++ )
                A[cnt] = B[j], cnt += 1;
        }
    }
};

(Python版)

class Solution:
    # @param A  a list of integers
    # @param m  an integer, length of A
    # @param B  a list of integers
    # @param n  an integer, length of B
    # @return nothing
    def merge(self, A, m, B, n):
        i = m-1
        cnt = int(0)
        while i >= 0:
            A[n+i] = A[i]
            i = i-1
        i = int(0)
        j = int(0)
        while 1:
            if i == m or j == n:
                break
            if A[i+n] < B[j]:
                A[cnt] = A[i+n]
                i += 1
            else:
                A[cnt] = B[j]
                j += 1
            cnt += 1
        while i < m:
            while i < m:
                A[cnt] = A[i+n]
                cnt += 1
                i += 1
        while j < n:
            A[cnt] = B[j]
            cnt += 1
            j += 1

第六题：

First Missing Positive

地址：http://oj.leetcode.com/problems/first-missing-positive/

分析：用C++写的时候直接用了个常量大小的数组，但是在用python写的时候就不行了，总是TLE，所以没用常量大小的list

代码：

（C++版）

class Solution 
{
public:
    int firstMissingPositive(int A[], int n) 
	{
        int ans, visit[100000], i;
		for( i = 0; i < 100000; i++ )
			visit[i] = 0;
		ans = 1;
		for( i = 0; i < n; i++ )
		{
			if( A[i] > 0 && A[i] < 100000) visit[A[i]] = 1;
			if( visit[ans] == 1 || A[i] == ans )
			{
				while( visit[ans] == 1)
				{
					ans += 1;
				}
			}
		}
		return ans;
    }
};
(Python版)： 

class Solution:
    # @param A, a list of integers
    # @return an integer
    def firstMissingPositive(self, A):
        visit = []
        for i in range(1000000):
            visit.append(0)
        ans = 1
        for i in range(len(A)):
            if A[i] > 0 or A[i] < 1000000:
                visit[A[i]] = 1
            if visit[ans] == 1 or A[i] == ans:
                while visit[ans] == 1:
                    ans += 1
        return ans

第七题：

Binary Tree Level Order Traversal

地址：http://oj.leetcode.com/problems/binary-tree-level-order-traversal/

分析：用了两个标记，一个是depth，一个是num.

代码：

（C++版）

typedef struct Node
{
	int depth;
	int value;
	int num;
}Node;

class Solution 
{
public:
	vector< Node > ans;
	int number;
	void dfs( int depth, TreeNode *root )
	{
		if( root == NULL ) return;
		Node add;
		add.depth = depth;
		add.value = root->val;
		add.num = number++;
		ans.push_back( add );
		if( root->left != NULL ) dfs( depth+1, root->left );
		if( root->right != NULL ) dfs( depth+1, root->right );
	}
	static bool cmp ( const Node &a, const Node &b )
	{
		if( a.depth != b.depth)
			return a.depth < b.depth;
		return a.num < b.num;
	}
	
    vector<vector<int> > levelOrder(TreeNode *root) 
	{
		int max, i, j;
		vector< vector < int > > ret;
		
		number = 0;
		if( root == NULL ) return ret;
		dfs( 1, root );
		sort( ans.begin(), ans.end(), cmp );
		max = ans[ans.size()-1].depth;
		j = 0;
		for( i = 1; i <= max; )
		{
			vector < int > add;
			while( ans[j].depth == i )
			{
				add.push_back( ans[j].value );
				j++;
				if( j == ans.size() ) break;
			}
			i++;
			ret.push_back( add );
			if( j == ans.size() ) break;
		}
		return ret;
    }
};

python版： PS 用python写的，提交之后一直wa，然后返回wa的测试数据，我用测试数据本地测试，完全正确，不知道什么情况，我觉得没问题。

'''
Definition for a  binary tree node
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
'''

class work:
    @staticmethod
    def dfs(depth, root):
        if root == None:
            return
        add = []
        add.append(root.val)
        add.append(Solution.number)
        add.append(depth)
        Solution.ans.append(add)
        del add
        Solution.number += 1
        if root.left != None:
            work.dfs(depth+1, root.left)
        if root.right != None:
            work.dfs(depth+1, root.right)

class Solution:
    # @param root, a tree node
    # @return a list of lists of integers
    number = int(0)
    ans = []
    def levelOrder(self, root):
        ret = []
        if root == None:
            return ret
        work.dfs( 1, root)
        Solution.ans.sort(key = lambda x:(x[2], x[1]))
        maxlen = Solution.ans[len(Solution.ans)-1][2]
        j = int(0)
        i = int(1)
        while i <= maxlen:
            aad = []
            while Solution.ans[j][2] == i:
                aad.append(Solution.ans[j][0])
                j += 1
                if j == len(Solution.ans):
                    break
            i += 1
            ret.append( aad )
            del aad
            if j == len(Solution.ans):
                break
        return ret

第八题：

Add Binary

地址：http://oj.leetcode.com/problems/add-binary/

分析：很简单的题目

class Solution 
{
public:
    string addBinary(string a, string b) 
	{
		string ans = "";
		int l1 = a.length(), l2 = b.length();
		int aa, bb;
		int i, j, next, cnt, num;
		num = 0, next = 0;
		for( i = l1-1, j = l2-1;;)
		{
			aa = bb = 0;
			if( i < 0 && j < 0 ) break;
			if( i >= 0 ) aa = a[i]-'0', i--;
			if( j >= 0 ) bb = b[j]-'0', j--;
			num = next + aa + bb;
			next = num/2;
			num = num%2;
			ans.push_back( char(num+'0' ));
		}
		if( next != 0 ) ans.push_back( '1' );
		string ret = "";
		l1 = ans.length();
		for( i = 0; i < l1; i++ )
			ret.push_back( ans[l1-i-1] );
		return ret;
    }
};

(python版) 

class Solution:
    # @param a, a string
    # @param b, a string
    # @return a string
    def addBinary(self, a, b):
        l1 = len(a)
        l2 = len(b)
        i = int(l1-1)
        j = int(l2-1)
        next = int(0)
        ans = []
        while True:
            aa = bb = int(0)
            if i < 0 and j < 0: break
            if i >= 0:
                aa = int(a[i])-int('0')
                i -= 1
            if j >= 0:
                bb = int(b[j])-int('0')
                j -= 1
            num = next + aa + bb
            next = num//2
            num = num%2
            ans.append(num)
        if next != 0:
            ans.append(1)
        ret = ''
        l1 = len(ans)
        for i in range(l1):
            if ans[l1-i-1] == 1:
                ret = ret + '1'
            else:
                ret = ret + '0'
        return ret

第九题：

Pascal's Triangle

地址：http://oj.leetcode.com/problems/pascals-triangle/

分析：帕斯卡三角(杨辉三角)

（Python版）

class Solution:
    # @return a list of lists of integers
    def generate(self, numRows):
        ans = []
        add = []
        if numRows == 0:
            return ans
        if numRows == 1:
            add = [1]
            ans.append(add)
            return ans
        add.append(1)
        ans.append(add)
        add = [1,1]
        ans.append(add)
        if numRows == 2:
            return ans
        i = int(2)
        while i < numRows:
            add = [1]
            l1 = len(ans[i-1])
            for j in range(l1-1):
                add.append(ans[i-1][j]+ans[i-1][j+1])
            add.append(1)
            ans.append(add)
            i += 1
        return ans

第十题：

Merge k Sorted Lists

地址：http://oj.leetcode.com/problems/merge-k-sorted-lists/

分析： K路合并问题，最小堆实现。

（C++版）

typedef struct Node
{
	int val, index;
}Node;

class Solution
{
public:
	Node *heap;

	static int cmp( const void *a, const void *b )
	{
		Node *aa, *bb;
		aa = (Node *)a, bb = (Node *)b;
		return aa->val - bb->val;
	}
	
	ListNode *mergeKLists(vector<ListNode *> &lists) 
	{
		int size = lists.size();
		int INF = 10000000;
		struct ListNode *ans(0), *go(0);
		if(size == 0) return NULL;
		go = (ListNode *)malloc(sizeof(struct ListNode));
		ans = go;
		go->next = NULL;
		Node heap[100010];
		int i;
		for(i = 0; i < 100010; i++) heap[i].index = -1, heap[i].val = INF;
		for(i = 1; i <= size; i++)
		{
			if(lists[i-1] != NULL)
			{
				heap[i].val = lists[i-1]->val;
				heap[i].index = i-1;
			}
			else
			{
				heap[i].val = INF;
				heap[i].index = -1;
			}
		}
		qsort(heap+1, size, sizeof(Node), cmp);
		while(1)
		{
			int idx = heap[1].index;
			if(idx == -1) break;
			struct ListNode *add;
			add = (ListNode *)malloc(sizeof(ListNode));
			add->val = heap[1].val;
			add->next = NULL;
			go->next = add;
			go = go->next;
			if(lists[heap[1].index]->next != NULL)
			{
				lists[heap[1].index] = lists[heap[1].index]->next;
				heap[1].val = lists[heap[1].index]->val;
			}
			else
			{
				heap[1].val = INF;
				heap[1].index = -1;
			}
			int ii = 1;
			while(heap[ii].val > heap[ii*2].val || heap[ii].val > heap[ii*2+1].val)
			{
				if(heap[ii*2].val > heap[ii*2+1].val)
				{
					Node temp;
					temp = heap[ii];
					heap[ii] = heap[ii*2+1];
					heap[ii*2+1] = temp;
					ii = ii<<1|1;
				}
				else
				{
					Node temp;
					temp = heap[ii];
					heap[ii] = heap[ii*2];
					heap[ii*2] = temp;
					ii = ii<<1;
				}
			}
		}
		return ans->next;
	}
};

第十一题：

Candy

地址：http://oj.leetcode.com/problems/candy/

分析：简单动态规划问题

代码：

（C++版）

class Solution 
{
public:
	int ans[100000];
    int candy(vector<int> &ratings) 
	{
        int i;
		for(i = 0; i < 100000; i++)
			ans[i] = 0;
		int size = ratings.size();
		int sum;
		ans[0] = 1;
		sum = 1;
		for(i = 1; i < size; i++)
		{
			if(ratings[i] > ratings[i-1])
				sum += 1;
			else sum = 1;
			if(sum > ans[i]) ans[i] = sum;
		}
		sum = 1;
		for(i = size-2; i >= 0; i--)
		{
			if(ratings[i] > ratings[i+1])
				sum += 1;
			else sum = 1;
			if(sum > ans[i]) ans[i] = sum;
		}
		sum = 0;
		for(i = 0;i < size; i++)
			sum += ans[i];

		return sum;
    }
};

（python版） 

class Solution:
    # @param ratings, a list of integer
    # @return an integer
    def candy(self, ratings):
        l1 = len(ratings)
        ans = []
        for i in range(l1):
            ans.append(0)
        sum = 1
        ans[0] = 1
        i = 1
        while i < l1:
            if ratings[i] > ratings[i-1]:
                sum += 1
            else:
                sum = 1
            if sum > ans[i]:
                ans[i] = sum
            i += 1
        sum = 1
        i = l1-2
        while i >= 0:
            if ratings[i] > ratings[i+1]:
                sum += 1
            else:
                sum = 1
            if sum > ans[i]:
                ans[i] = sum
            i -= 1
        sum = 0
        for i in range(l1):
            sum += ans[i]
        return sum

第十二题：

3Sum

地址：http://oj.leetcode.com/problems/3sum/

分析：转化为2Sum，再用two pointers算法

代码：

（C++版）

class Solution {
public:
  void twoSum(vector<int> &num, int len, vector<vector<int> > &vec, int target) {
      vec.clear();
      vector<int> tmp;
      int i=0,j=len-1;
      while(i<j) {
          if(num[i]+num[j] == target)
          {
              tmp.push_back(num[i]);tmp.push_back(num[j]);vec.push_back(tmp);tmp.clear();
              do{
                  i++;
              }while(num[i]==num[i-1]);
              do{
                  j--;
              }while(num[j]==num[j+1]);
              continue;
          }
          if(num[i]+num[j]>target)
            do{
                j--;
            }while(num[j]==num[j+1]);
          else
            do{
                i++;
            }while(num[i]==num[i-1]);
            
      }
  }
  vector<vector<int> > threeSum(vector<int> &num) {
      sort(num.begin(),num.end());
      vector<vector<int> > vecvec;
      vector<vector<int> > tmp;
      for(int i=num.size()-1;i>=2;i--) {
          if(i!=num.size()-1 && num[i]==num[i+1])
              continue;
          twoSum(num,i,tmp,-num[i]);
          for(int j=0;j<tmp.size();j++) {
              tmp[j].push_back(num[i]);
              vecvec.push_back(tmp[j]);
          }
          tmp.clear();
      }
      return vecvec;
  }
};

第十三题：

Single Number

地址：http://oj.leetcode.com/problems/single-number/

分析：异或的神奇之处正在于此处。amazing……

(C++代码)：

class Solution {
public:
    int singleNumber(int A[], int n) {
        int a = A[0];
        int i = 0;
        for(i = 1; i < n; i++)
            a = A[i]^a;
        return a;
    }
};

(python代码): 

class Solution:
    # @param A, a list of integer
    # @return an integer
    def singleNumber(self, A):
        a = A[0]
        l1 = len(A)
        i = 1
        while i < l1:
            a = a^A[i]
            i += 1
        return a

第十四题：

Remove Nth Node From End of List

地址：http://oj.leetcode.com/problems/remove-nth-node-from-end-of-list/

分析：基础题。

代码：

(C++版)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *removeNthFromEnd(ListNode *head, int n) 
    {
        ListNode *ans, *go(0);
        int count = 0;
        ans = head;
        while(ans != NULL)
        {
            ans = ans->next;
            count += 1;
        }
        if(count == 1 && n == 1)return NULL;
        go = (ListNode *)malloc(sizeof(ListNode));
        ans = go;
        int i = 0;
        while(head != NULL)
        {
            if(i != count-n)
            {
                ListNode *add(0);
                add = (ListNode *)malloc(sizeof(ListNode));
                add->val = head->val;
                add->next = NULL;
                head = head->next;
                go->next = add;
                go = go->next;
                i += 1;
            }
            else
            {
                head = head->next;
                i += 1;
            }
        }
        return ans->next;
    }
};

(python版)： 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # @return a ListNode
    def removeNthFromEnd(self, head, n):
        go = ListNode(0)
        ans = head
        count = 0
        while ans != None:
            count += 1
            ans = ans.next
        if count == 1 and n == 1:
            return None
        ans = go
        i = 0
        while head != None:
            if i != count-n:
                add = ListNode(0)
                add.val = head.val
                add.next = None
                head = head.next
                go.next = add
                go = go.next
                i += 1
            else:
                head = head.next
                i += 1
        return ans.next

第十五题：

ZigZag Conversion

地址：http://oj.leetcode.com/problems/zigzag-conversion/

分析：注意边界情况处理，比如 nRows = 1的时候。

代码：

(C++代码)

class Solution 
{
public:
    string convert(string s, int nRows) 
	{
		int i, j, len, flag;
		string ans = "";
		len = s.length();
		if(nRows >= len || nRows == 1)
            return s;
		for(j = 1; j <= len;)
		{
			ans += s[j-1];
			j += 2*(nRows-2)+2;
		}
		for(i = 2; i < nRows; i++)
		{
			flag = 0;
			for(j = i; j <= len; )
			{
				ans += s[j-1];
				if(flag == 0) j += (nRows-i-1)*2+2, flag = 1;
				else j += (i-2)*2+2, flag = 0;
			}
		}
		for(j = nRows; j <= len; )
		{
			ans += s[j-1];
			j += (nRows-2)*2+2;
		}
		
		return ans;
    }
};

(Python版) 

class Solution:
    # @return a string
    def convert(self, s, nRows):
        ans = ''
        l1 = len(s)
        j = 1
        if nRows >= l1 or nRows == 1:
            return s
        while j <= l1:
            ans += s[j-1]
            j += 2*(nRows-2)+2
        i = 2
        while i < nRows:
            flag = 0
            j = i
            while j <= l1:
                ans += s[j-1]
                if flag == 0:
                    j += (nRows-i-1)*2+2
                    flag = 1
                else:
                    j += (i-2)*2+2
                    flag = 0
            i += 1
        j = nRows
        while j <= l1:
            ans += s[j-1]
            j += (nRows-2)*2+2
        return ans

第十六题：

Rotate Image

地址：http://oj.leetcode.com/problems/rotate-image/

分析：难度小，慢慢分析一下，主要就是要求原地操作。

代码：

(C++版)

class Solution 
{
public:
	int n;
	void change(vector<vector<int>> &mat, int x, int y)
	{
		int pre = mat[x][y];
		mat[x][y] = mat[n-y-1][x];
		mat[n-y-1][x] = mat[n-x-1][n-y-1];
		mat[n-x-1][n-y-1] = mat[y][n-x-1];
		mat[y][n-x-1] = pre;

	}

	void rotate(vector<vector<int> > &matrix) 
	{
		int i, j;
		
		n = matrix.size();
		for(i = 0; i < n/2; i++)
			for(j = i;j < n-i-1; j++)
				change(matrix, i, j);
    }
};


(Python版)：需要返回一个List，而C++版不需要。。。 

class Solution:
    # @param matrix, a list of lists of integers
    # @return a list of lists of integers
    def rotate(self, matrix):
        n = len(matrix)
        i = 0
        j = 0
        for i in range(n//2):
            j = i
            while j < n-i-1:
                pre = matrix[i][j]
                matrix[i][j] = matrix[n-y-1][x]
                matrix[n-j-1][i] = matrix[n-i-1][n-j-1]
                matrix[n-i-1][n-j-1] = matrix[j][n-i-1]
                matrix[j][n-i-1] = pre

第十七题：

Merge Two Sorted Lists

地址：oj.leetcode.com/problems/merge-two-sorted-lists/

分析：two pointers双指针

代码：

(C++版)

class Solution 
{
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) 
    {
        ListNode *ans(0), *go(0), *add(0);
		go = (ListNode *)malloc(sizeof(ListNode));
		go->next = NULL;
		ans = go;
		if(l1 == NULL && l2 == NULL) return NULL;
		while(l1 != NULL || l2 != NULL)
		{
			if(l1 == NULL || l2 == NULL)
			{
				add = (ListNode *)malloc(sizeof(ListNode));
				add->next = NULL;
				if(l1 == NULL)
				{
					add->val = l2->val;
					l2 = l2->next;
				}
				else
				{
					add->val = l1->val;
					l1 = l1->next;
				}
				go->next = add;
				go = go->next;
			}
			else
			{
				add = (ListNode *)malloc(sizeof(ListNode));
				add->next = NULL;
    			if(l1->val < l2->val)
    			{
					add->val = l1->val;
					l1 = l1->next;
    			}
    			else
    			{
					add->val = l2->val;
					l2 = l2->next;
    			}
				go->next = add;
				go = go->next;
			}
		}
		return ans->next;
    }
};

(Python版) 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    # @param two ListNodes
    # @return a ListNode
    def mergeTwoLists(self, l1, l2):
        if l1 == None and l2 == None:
            return None
        go = ListNode(0)
        ans = go
        while l1 != None or l2 != None:
            add = ListNode(0)
            add.next = None
            if l1 == None or l2 == None:
                if l1 == None:
                    add.val = l2.val
                    l2 = l2.next
                else:
                    add.val = l1.val
                    l1 = l1.next
            else:
                if l1.val < l2.val:
                    add.val = l1.val
                    l1 = l1.next
                else:
                    add.val = l2.val
                    l2 = l2.next
            go.next = add
            go = go.next

        return ans.next

第十八题：

Text Justification

地址：http://oj.leetcode.com/problems/text-justification/

分析：考虑的方面比较多，要求也比较多。慢慢分析。。

代码：

(C++版)

class Solution 
{
public:
	string work(int l)
	{
		string str = "";
		int i;
		for(i = 0; i < l; i++)
			str += " ";
		return str;
	}
    vector<string> fullJustify(vector<string> &words, int L) 
	{  
		vector<string> ans;
		int i, j, k,size, sum, len;
		int space;
		size = words.size();
		if(L == 0)
		{
		    string str = "";
		    ans.push_back(str);
		    return ans;
		}
		if(size == 1 && words[0] == "")
		{
		    string str = "";
		    str = work(L);
		    ans.push_back(str);
		    return ans;
		}
		for(i = 0; i < size;)
		{
			string str = "";
			sum = len = 0;
			for(j = i; j < size; j++)
			{
				sum += words[j].length();
				if(sum > L) break;
				else sum += 1;
				len += words[j].length();
			}
			int div;
			if(j != size) div = j-i-1;
			else div = j-i;
			if(div == 0) div = 1;
			space = (L-len)/div;
			str += words[i];
			int mod = (L-len)%div;
			if(j != size)
			{
				if(mod != 0)
					str += work(space + 1), mod -= 1;
				else str += work(space);
				for(k = i+1; k < j; k++)
				{
					str += words[k];
					if(k != j-1)
					{
						if(mod != 0) str += work(space+1), mod -= 1;
						else str += work(space);
					}
				}
			}
			else
			{
				len = 0;
				len += words[i].length();
				if(i < j-1)
					str += " ",len += 1;
				for(k = i+1; k < j; k++)
				{
					str += words[k];
					len += words[k].length();
					if(k != j-1)
						str += " ", len += 1;
				}
				str += work(L-len);
			}
			ans.push_back(str);
			i = j;
		}

		return ans;
    }
};

第十九题：

Reverse Words in a String

地址：http://oj.leetcode.com/problems/reverse-words-in-a-string/

分析：注意s= "         "这种空情况。

代码：

(C++版)

class Solution 
{
public:
	void reverseWords(string &s) 
	{
		vector<string> vec;
		int len = s.length();
		int i, j;
		string str = "";
		int flag = 0;
		for(i = 0; i < len; i++)
		{
			if(s[i] != ' ')
				str += s[i],flag = 1;
			else if(flag)
			{
				vec.push_back(str);
				str = "";
				flag = 0;
			}
		}
		if(flag) vec.push_back(str);
		string ans = "";
		int size = vec.size();
		if(size != 0)
		{
			for(i = size-1; i >= 0; i--)
			{
				ans += vec[i];
				if(i != 0) ans += " ";
			}
		}
		s = ans;
    }
};

第二十题：

Evaluate Reverse Polish Notation

地址：http://oj.leetcode.com/problems/evaluate-reverse-polish-notation/

分析：栈的用法之一。 逆波兰数。

代码：

(C++版)

class Solution
{
public:
	int evalRPN(vector<string> &tokens) 
	{
		int stack[100000];
		int pos;
		int i, j;
		pos = -1;
		int size = tokens.size();
		for(i = 0; i < size; i++)
		{
			char c = tokens[i][0];
			if(c == '+')
			{
				int ans = stack[pos] + stack[pos-1];
				pos -= 1;
				stack[pos] = ans;
			}
			else if(c == '-' && tokens[i].length() == 1)
			{
				int ans = stack[pos-1] - stack[pos];
				pos -= 1;
				stack[pos] = ans;
			}
			else if(c == '*')
			{
				int ans = stack[pos] * stack[pos-1];
				pos -= 1;
				stack[pos] = ans;
			}
			else if(c == '/')
			{
				int ans = stack[pos-1] / stack[pos];
				pos -= 1;
				stack[pos] = ans;
			}
			else
			{
				int flag = 1;
				int len = tokens[i].length();
				if(c == '-') flag = -1, j = 1;
				else j = 0;
				int add = 0;
				for(; j < len; j++)
				{
					add *= 10;
					add += tokens[i][j]-'0';
				}

				pos += 1;
				stack[pos] = add * flag;
			}
		}
		return stack[0];
	}
};



IceFire
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode打不开-LeetCode-Problems:LeetCode-问题
06-30
leetcode打不开LeetCode-问题 一组 LeetCode 问题来自 添加数字 给定一个非负整数 num，重复将其所有数字相加，直到结果只有一位。 输入：38 输出：2 解释：过程就像：3 + 8 = 11, 1 + 1 = 2。因为 2 只有一位数，所以返回它。 两个数字相加 给定两个代表两个非负整数的非空链表。 数字以相反的顺序存储，它们的每个节点都包含一个数字。 将两个数字相加并将其作为链表返回。 您可以假设这两个数字不包含任何前导零，除了数字 0 本身。 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 解释：342 + 465 = 807。 二叉树中序遍历给定一个二叉树，返回其节点值的中序遍历。 输入：[1,null,2,3] 1 2 / 3 输出：[1,3,2] 二叉树层序遍历给定一棵二叉树，返回其节点值的层序遍历。 （即，从左到右，逐级）。 给定二叉树 [3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回其层序遍历为： [ [3], [9,20], [15,7] ] 二叉树后序遍历给
leetcode problem 4
08-23
leetcode problem 4 的三种实现方法及测试
LeetCode Problems
追随梦想，实现梦想
01-13 126
LeetCode Problems 网站 此网站可以看到LeetCode所有题目（包括上锁的）和公司相关的题目。
LeetCode Problems #365
qq_38789531的博客
10-21 183
2018年10月21日 #365. Water and Jug Problem 问题描述： You are given two jugs with capacities x and y litres. There is an infinite amount of water supply available. You need to determine whether it is possi...
LeetCode Problem #1
qq_38789531的博客
09-09 131
2018年9月9日 周日 #1. Two Sum 问题描述： Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solut...
LeetCode Problems #3
qq_38789531的博客
09-09 123
2018年9月9日 #3. Longest Substring Without Repeating Characters 问题描述： Given a string, find the length of the longest substring without repeating characters. 样例: Given "abcabcbb", the answer is "abc"...
leetcode_problem_rating:每周两次leetcode中自我计算的问题评分
04-28
总的来说，这个“leetcode_problem_rating”项目结合了LeetCode的编程挑战和JavaScript的编程实践，为开发者提供了一个提升自身技能和个性化评估问题难度的工具。通过学习和应用这些知识，开发者不仅可以提高解题...
leetcode338-Leetcode_Problem:leetcode记录
07-01
给定一个非负整数数组，您最初位于数组的第一个索引处。 数组中的每个元素代表您在该位置的最大跳跃长度。 您的目标是以最少的跳跃次数到达最后一个索引。 例子： 输入：[2,3,1,1,4] 输出：2 解释：到达最后一个索引...
leetcode-problem
04-10
这是一个基础级别的LeetCode问题，编号为`1`。问题要求给定一个整数数组`nums`和一个目标值`target`，找出数组中两个数使得它们的和等于目标值，并返回这两个数的索引。这个问题可以通过哈希表来高效解决。首先创建...
leetcode2sumc-leetcode_problem:leetcode_problem
06-30
leetcode 2 和 c 力码 为准备面试做 leetcode 问题。 第 1 天 (5/24/2020) 双指针 第167章 二和二（简单） ##python solution class Solution : def twoSum ( self , numbers : List [ int ], target : int ) -> ...
LeetCode Problems #802
qq_38789531的博客
10-07 181
2018年10月7日 #802. Find Eventual Safe States 问题描述： In a directed graph, we start at some node and every turn, walk along a directed edge of the graph.  If we reach a node that is terminal (that is, i...
Leetcode Problem17
vandance的博客
08-20 122
Letter Combinations of a Phone Number 问题描述：给定包含来自包含数字的字符串2-9，返回该数字可能表示的所有可能的字母组合，下面给出了数字和字母的映射及相应的例子。 输入： “23” 输出： [“ad”，“ae”，“af”，“bd”，“be”，“bf”，“cd”，“ce”，“cf”] 这道题一开始我也想不出要用什么方法做，然后就去查找Di...
Leetcode Problem108
vandance的博客
09-26 217
Convert Sorted Array to Binary Search Tree 问题描述：将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 问题解决：题目要求是要将一个按照升序排列的有序数组转换为一棵高度平衡的二叉搜索树，二叉搜索树我们知道，就是节点的值小于其右子树节点的值而大于其左子树节点的值，平衡则为该树的任意节点左右子树的高度差不超过一。因为数组已经是按照升序排列好了的，所...
https://leetcode.com/problems/two-sum/
le_chateau的专栏
05-03 709
https://leetcode.com/problems/two-sum/ 寻找两个数的和是target 其实这道题可以遍历全部list 但是效率特别低 很容易超时  所以我的方法是将数组排序固定其中一个 另一个二分查找 有一个niddle 是为了判定 当找到刚好合适的值的时候 niddle=0  由于假设了只有一组解  就不必继续执行while了  要注意的是二分查找用j=(x+l
LeetCode Problems #135
qq_38789531的博客
10-28 159
2018年10月28日 #135. Candy 问题描述： There are N children standing in a line. Each child is assigned a rating value. You are giving candies to these children subjected to the following requirements: Eac...
LeetcodeProblem7 Reverse Integer解题报告
qq_34475845的博客
09-11 151
这一题主要是边界的控制，自己没想出什么好办法，就是用long long型res，来比较int32型的最大值，如果结果大于int32的max，则返回0，否则返回res。 看到leetcode上提供的解法，结果res为int32型，每次循环时累计计算后，判断（res-余数）/10是否==0，如果不是，说明溢出，则返回0，否则继续循环，最后返回。 我的代码： int reverse(int x)
【leetcode】高频题目整理_所有题目汇总篇( High Frequency Problems, All Problems )
嵌入式与Linux那些事的博客
10-03 7321
截止至今LeetCode题目总量已经有1582题，估计将来每年平均增长300题左右，大部分人肯定是刷不完的，所以得有选择地刷LeetCode。 一种公认的刷题策略是按类别刷题，可是每个类别也有许多题，在有限的时间里到底该刷哪些题呢？个人根据LeetCode官方给出的每个题目的出现频率，整理并收录了每个类别里高频出现的题目，对于官方统计频率太低的题目，不予收录，最终得到了这个高频题目表格。 例如，对于下图中题号#275与#270的题目将被收录，并且#275出现频率大于#270；而对于题号#1011与#11
leetcode 1st problem two sum
duringsummer的博客
02-19 155
去年未上传的代码， 问题描述 一个vector容器中，假定只有一个解，使得和为0，找出这两个数 class Solution { public: vector&lt;int&gt; twoSum(vector&lt;int&gt;&amp; nums, int target) { for(int i = 0;i&lt;=nums.size()-2;i++) ...
【leetcode】高频题目整理_图篇( High Frequency Problems, Graph )
Liber-coder的博客
03-30 1149
图篇-12题(Graph, 12 problems) 截止至今LeetCode题目总量已经有`1582题`，估计将来每年平均增长`300题`左右，大部分人肯定是`刷不完的`，所以得有选择地刷LeetCode。 一种公认的刷题策略是`按类别刷题`，可是每个类别也有许多题，在有限的时间里`到底该刷哪些题呢`？个人根据`LeetCode官方`给出的每个题目的`出现频率`，整理并收录了每个类别里`高频出现`的题目，对于官方统计频率太低的题目，不予收录，最终得到了这个高频题目表格。
LeetCode 刷题汇总1
最新发布
08-03
LeetCode 刷题汇总1;LeetCode 刷题汇总1; LeetCode 刷题汇总1;LeetCode 刷题汇总1;LeetCode是一家专注于编程技能提升的在线学习平台，提供了大量的算法题目供用户练习。通过刷LeetCode题目，可以帮助提升编程能力和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值