leetcode

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 示例1： 给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 你不需要考虑数组中超出新长度后面的元素。 示例2： 给定 nums = [0,0,1,1,1,2,2,3,3,4], 函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。 你不需要考虑数组中超出新长度后面的元素。 说明 ： 为什么返回数值是整数，但输出的答案是数组呢?请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。你可以想象内部操作如下: // nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates ( nums ); // 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for ( int i = 0 ; i < len ; i ++) { print ( nums [ i ]); } ˼· return len(set(nums))，不通过

Leetcode算法Java全解答–24. 两两交换链表中的节点 文章目录 Leetcode算法Java全解答--24. 两两交换链表中的节点 题目 想法 结果 总结 代码 我的答案 大佬们的答案 测试用例 其他 题目 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 示例： 给定 1->2->3->4, 你应该返回 2->1->4->3. 说明: 你的算法只能使用常数的额外空间。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 想法 声明三个变量存储 cur–当前node，preCur–上一个node，preDoubleCur–上一个node的上一个node 声明循环次数num，偶数次的时候就交换 循环，交换 时间复杂度/空间复杂度： n/1 假设数据为，1,2,3,4,5,6，已经循环到4这个数据 cur: val = 4,next=5 preCur: val = 3,next=4 preDoubleCur: val = 2,next=3 交换方式： ListNode tmpCur = cur; cur = cur.next; preDoubleCur.next = tmpCur; tmpCur.next = preCur; preCur.next = cur; 结果 超过70%的测试案例 时间复杂度/空间复杂度： n/1 总结 代码 我的答案 /**

题目标签：Array, Hash Table Java Solution: 完成日期：03/08/2019 关键点：对于每一个新的string，把common array 里面的次数进行更新，取最小的次数，排除不是 common 的 字符。 class Solution { public List<String> commonChars(String[] A) { List<String> result = new ArrayList<>(); int [] commonCharsCount = new int[26]; Arrays.fill(commonCharsCount, Integer.MAX_VALUE); // iterate each string in A for(String str : A) { int [] tempCharsCount = new int[26]; // count char for this string for(char c : str.toCharArray()) tempCharsCount[c - 'a']++; // update the commonCharsCount for(int i=0; i<commonCharsCount.length; i++) commonCharsCount[i] = Math.min

分析 难度 易 来源 https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/ 题目 Given an array where elements are sorted in ascending order, convert it to a height balanced BST. For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1. Example: Given the sorted array : [- 10 ,- 3 , 0 , 5 , 9 ], One possible answer is : [ 0 ,- 3 , 9 ,- 10 , null , 5 ], which represents the following height balanced BST : 0 / \ - 3 9 / / - 10 5 解答 1 package LeetCode ; 2 3 import java . util . LinkedList ;

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。 案例: s = "leetcode" 返回 0. s = "loveleetcode", 返回 2. 注意事项：您可以假定该字符串只包含小写字母。 /** * @param {string} s * @return {number} */ var firstUniqChar = function (s) { let len = s.length, obj = {}; for (let i = 0; i !== len; i++) { if (obj[s[i]] === undefined) { obj[s[i]] = 0; } else { obj[s[i]]++; } } for (let key of Object.keys(obj)) { if (obj[key] === 0) { return s.indexOf(key); } } return -1; }; 我又想了好久，明明看上去好像是个比较简单的问题… 然后看一眼大佬的解法，牛皮 /** * @param {string} s * @return {number} */ var firstUniqChar = function(s) { for (var i = 0; i < s.length; i++) { if (s

给定两个 非空 链表来表示两个非负整数。位数按照 逆序 方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。 你可以假设除了数字 0 之外，这两个数字都不会以零开头。 示例： 输入：( 2 -> 4 -> 3 ) + ( 5 -> 6 -> 4 ) 输出： 7 -> 0 -> 8 原因： 342 + 465 = 807 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution : def addTwoNumbers ( self , l1 , l2 ): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ carry = 0 isFirst = True currentNode = None head = None while ( l1 or l2 or carry != 0 ): val1 = 0 val2 = 0 if l1 : val1 = l1 . val l1 = l1 . next if l2 : val2 = l2 . val l2 = l2 . next sum = val1 +

160 . 相交链表 编写一个程序，找到两个单链表相交的起始节点。 例如，下面的两个链表 ： A : a1 → a2 c1 → c2 → c3 B : b1 → b2 → b3 在节点 c1 开始相交。 注意： 如果两个链表没有交点，返回 null . 在返回结果后，两个链表仍须保持原有的结构。 可假定整个链表结构中没有循环。 程序尽量满足 O( n ) 时间复杂度，且仅用 O( 1 ) 内存。 思路：其实就是暴力解决，找出他们共同部分，判断这一段是否相同。 代码如下： # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution ( object ): def getIntersectionNode ( self , headA , headB ): """ :type head1, head1: ListNode :rtype: ListNode """ #### the first method # if headA == None or headB == None: # return None # def get_length(head): # count = 0

描述 编写一个函数，以字符串作为输入，反转该字符串中的元音字母。 示例 给定 s = “hello”, 返回 “holle”. 给定 s = “leetcode”, 返回 “leotcede”. 元音字母不包括 “y”. 思路：元音字母a,o,i,e,u。首先按序找出字符串中的元音字母，记录下索引值存放在列表index_list中，然后进行倒叙。 我 class Solution : def reverseVowels ( self , s ) : """ :type s: str :rtype: str """ l = [ 'a' , 'o' , 'e' , 'u' , 'i' , 'A' , 'O' , 'E' , 'U' , 'I' ] res = list ( s ) index_list = [] for i in range ( len ( res )): if res [ i ] in l : index_list . append ( i ) length = len ( index_list ) for j in range ( length // 2 ): res [ index_list [ j ]], res [ index_list [- j - 1 ]] = res [ index_list [- j - 1 ]], res [ index_list [

本人一直在努力地积累Leetcode上用Python实现的题，并且会尽力讲清每道题的原理，绝不像其他某些博客简略地带过。 如果觉得讲的清楚，欢迎关注。 2-9 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入： "23" 输出： ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]. 思路：首先一定要明确，这本质是一道穷举题。如何通过数字获取字母？答：字典。所以我们有个self.data。所以看看示例，我们首先遍历2所代表的字母，进入a后我们先把d,e,f搜索完，再去进入b，再把d、e、f搜索完。有点像DFS，深度优先搜索。 首先在实例化时生成我们的电话本～～，用来搜索的。 helper 函数是帮助我递归的，我的base条件是我们制造的字母的长度与原数字长度相同。 这里很多人可能不太明白为什么我要用t = s, s = t这操作。 其实我是想保存s（也就是目前制造出来的字符串的值），因为如果我不保存，如果我像下面这样写的话（以下代码是错的）： def helper(self, L, d, s): if len(s) == self.length: L.append(s) else: for i in self.data[d[0]]: s += i self.helper(L, d[1:],

标签（空格分隔）： LeetCode 题目地址： https://leetcode.com/problems/magic-squares-in-grid/description/ A 3 x 3 magic square is a 3 x 3 grid filled with distinct numbers from 1 to 9 such that each row, column, and both diagonals all have the same sum. Given an grid of integers, how many 3 x 3 “magic square” subgrids are there? (Each subgrid is contiguous). Example 1: Input: [[4,3,8,4], [9,5,1,9], [2,7,6,2]] Output: 1 Explanation: The following subgrid is a 3 x 3 magic square: 438 951 276 while this one is not: 384 519 762 In total, there is only one magic square inside the given grid. Note: 1 <= grid.length