LeetCode刷题记录-简单模块（一）
目录
-
-
-
- 两数之和（HashMap）
- 回文数（反转一般数字）
- 罗马数字转Int（遍历约束条件）
- 最长公共前缀（纵向查找、分治法、二分查找）
- 有效的括号（Stack）
- 合并两个有序链表为一个有序链表（递归法，迭代法）
- 删除有序数组中的重复项（递归、双指针遍历）
- 移除指定元素（双指针遍历）
- 搜索插入位置（二分查找）
- 最后一个单词长度(单指针/双指针遍历)
- 加一(反向指针遍历)
- 算数平方根（二分查找）
- 爬楼梯(动态规划 、 分治递归)
- 删除有序链表中的重复元素 （双指针遍历）
- 合并两个有序数组（尾部遍历数组）
-
-
两数之和（HashMap）
给定一个整数数组 nums 和一个整数目标值 target，
请你在该数组中找出 和为目标值 target 的那两个整数，
并返回它们的数组下标。
使用二维数组或者hashMap处理即可
回文数（反转一般数字）
判断一个int是不是回文数，如121，1221
负数不是回文数
如果只是将数字反转，有可能出现数值溢出的问题，因此可以使用反转一半数字的方式处理
class Solution {
public boolean isPalindrome(int x) {
// 特殊情况：
// 如上所述，当 x < 0 时，x 不是回文数。
// 同样地，如果数字的最后一位是 0，为了使该数字为回文，
// 则其第一位数字也应该是 0
// 只有 0 满足这一属性
if (x < 0 || (x % 10 == 0 && x != 0)) {
return false;
}
int revertedNumber = 0;
while (x > revertedNumber) {
revertedNumber = revertedNumber * 10 + x % 10;
x /= 10;
}
// 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
// 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
// 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
return x == revertedNumber || x == revertedNumber / 10;
}
}
罗马数字转Int（遍历约束条件）
定义一个Map作为转义标准，然后遍历罗马数字字符串中的每一个字符，注意特殊条件，在遍历字符时注意约束前一个字符为负的情况即可
最长公共前缀（纵向查找、分治法、二分查找）
给定一个字符串数组，查询其中的最长公共字符串前缀
- 纵向查找
以一个字符串为标准，纵向查找后续字符串与其的公共部分，并实时更新该公共部分
class Solution {
public String longestCommonPrefix(String[] strs) {
if(strs.length == 0 || strs == null){
return "";
}
for(int i = 1 ; i < strs.length ; i ++){
int tempLength = strs[0].length() > strs[i].length() ? strs[i].length() : strs[0].length();
if(tempLength == 0){
return "";
}
for(int j = 0 ; j < tempLength; j ++){
if(strs[0].charAt(j) == strs[i].charAt(j)){
if(j == tempLength - 1 && strs[0].length() > tempLength){
strs[0] = strs[0].substring(0 , j+1);
}
}else{
strs[0] = strs[0].substring(0 , j);
break;
}
}
}
return strs[0];
}
}
- 分治法查找
将数组分为几组字符串，各自查找他们的最大公串，随后查找最终公串 - 二分查找
最长前缀公串的长度不会超过最短字符串的长度，因此以最短字符串为基准对齐进行二分，对分出来的前缀串与其他字符串进行比较，查看是否startWith，如果存在则将后缀串继续二分。 - 偏方查找
将字符串数组进行排序之后，只需要查找首位和末尾两个字符串的公串即可
有效的括号（Stack）
给定义一个字符串，判定其是否有效，字符串中只有以下字符：
'[' , ']' , '(' , ')' , '{' , '}'
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。
- 使用栈来进行处理，当遇到一个左括号时，将其入栈，遇到一个右括号将栈顶的符号与其配对，配对有效则继续，无效则返回false，直到遍历完整个字符串并且栈为空则说明有效
class Solution {
public boolean isValid(String s) {
//使用Stack来进行处理
Stack<Character> stack = new Stack<Character>();
for(int i = 0 ; i < s.length(); i ++){
if(s.charAt(i) == '(' || s.charAt(i) == '[' || s.charAt(i) == '{'){
stack.add(s.charAt(i));
}else{
if(stack.size() == 0){
return false;
}
char left = stack.pop();
if(s.charAt(i)-left >= 1 && s.charAt(i)-left <= 2){
continue;
}else{
return false;
}
}
}
if(stack.size() > 0){
return false;
}
return true;
}
}
- 直接使用字符串替换来处理
class Solution {
public boolean isValid(String s) {
//直接使用字符串替换来处理
int length = s.length() / 2;
for(int i = 0 ; i < length ; i ++ ){
s = s.replace("()" , "").replace("[]" , "").replace("{}","");
}
return s.length() == 0;
}
}
合并两个有序链表为一个有序链表（递归法，迭代法）
给定两个相同排序规则的链表，将其合并为同样排序规则的一个链表
- 递归法
首先我们对该问题进分析，可以很容易得出结论：当list1的值小于list2的值时，我们需要获取list1[0] + merge(list1[1:] , list2)；当list2的值小于list1的值时，我们需要获取list2[0] + merge(list2[1:],list1)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
if(list1 == null){
return list2;
}
if(list2 == null){
return list1;
}
if(list1.val < list2.val){
list1.next = mergeTwoLists(list1.next , list2);
return list1;
}else{
list2.next = mergeTwoLists(list1 , list2.next);
return list2;
}
}
}
- 迭代法
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
//声明一个头结点 这个头结点主要用于方便迭代
ListNode resList = new ListNode(-1);
ListNode tempList = resList;
while(true){
if(list1 == null){
tempList.next = list2;
break;
}
if(list2 == null){
tempList.next = list1;
break;
}
if(list1.val < list2.val){
tempList.next = new ListNode(list1.val);
list1 = list1.next;
tempList = tempList.next;
}else{
tempList.next = new ListNode(list2.val);
list2 = list2.next;
tempList = tempList.next;
}
}
return resList.next;
}
}
删除有序数组中的重复项（递归、双指针遍历）
给定一个有序数组，将其中的重复项原地删除，并且留下的前N项保留顺序后去重输出
- 使用双指针遍历数组
由于给定的是一个有序数组，因此当inums[i]==nums[j]时，i与j之间的所有元素均相等，因此只需要改变两个指针的相对位置即可
class Solution {
public int removeDuplicates(int[] nums) {
//使用双指针遍历，由于该数组是有序的，因此重复项必然是连续的
int refLeft = 0;
int refRight = 1;
int refCount = 0;
while(true){
//当右指针遍历到末尾时，存在两种情况，一种是同一个数字遍历到末尾，另一种是不同数字遍历到末尾
//当数字相同时，将最后一位放在对应位置即可
//当数字不同时，此时左指针在最后一位，同样处理即可
if(refRight == nums.length){
nums[refCount] = nums[nums.length - 1];
break;
}
if(nums[refLeft] != nums[refRight]){
//数字不同时将左指针的元素放在对应位置，右指针位置赋给左指针，右指针向前进1，继续遍历
nums[refCount] = nums[refLeft];
refCount++;
refLeft = refRight;
refRight++;
}else{
//数字相同则右指针加一
refRight++;
}
}
return refCount + 1;
}
}
class Solution {
public int removeDuplicates(int[] nums) {
int n = nums.length;
if (n == 0) {
return 0;
}
int fast = 1, slow = 1;
while (fast < n) {
if (nums[fast] != nums[fast - 1]) {
nums[slow] = nums[fast];
++slow;
}
++fast;
}
return slow;
}
}
- 递归调用-万能递归
当给到无序数组时也可以搞定
class Solution {
public int removeDuplicates(int[] nums) {
//使用HashSet处理
HashSet<Integer> set = new HashSet<Integer>();
return doRemove(nums , set , 0 , 0 ,0);
}
public int doRemove(int[] nums , HashSet<Integer> indexSet , int index , int count , int numCount){
if(index == nums.length){
return count;
}
if (numCount == nums.length){
return count;
}
numCount++;
if(indexSet.contains(nums[index])){
for(int i = index ; i < nums.length - 1 ; i++){
nums[i] = nums[i + 1];
}
return doRemove(nums , indexSet , index , count , numCount);
}else{
indexSet.add(nums[index]);
return doRemove(nums , indexSet, ++index , ++count , numCount);
}
}
}
移除指定元素（双指针遍历）
给定一个数组，原地移除与给定数值相同的元素，并且留下的前N项保留后输出
- 双指针遍历
跟上面一样，双指针遍历完事
class Solution {
public int removeElement(int[] nums, int val) {
//同样的使用双指针方式处理
if(nums.length == 0 || nums == null){
return 0;
}
int slow = 0;
int fast = 0;
while(true){
if(fast == nums.length){
break;
}
if(nums[fast] != val){
nums[slow] = nums[fast];
slow ++;
}
fast ++ ;
}
return slow;
}
}
- 上面的方法遍历时，极限状态下可能需要遍历两次。因此同样使用双指针的方式来处理，两个指针分别从左右向中间移动，这样只需要最多遍历一次就能完成
class Solution {
public int removeElement(int[] nums, int val) {
int left = 0;
int right = nums.length - 1;
while(true){
if(left > right){
break;
}
if(nums[right] != val){
if(nums[left] == val){
nums[left] = nums[right];
left++;
}else{
left++;
continue;
}
}
right --;
}
return left;
}
}
搜索插入位置（二分查找）
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
- 标准解法（二分查找）
由于是有序数组，因此使用二分查找非常便利。
class Solution {
public int searchInsert(int[] nums, int target) {
//使用二分查找
if(nums.length == 0 || nums==null){
return 0;
}
int l = 0;
int r = nums.length - 1;
int mid = 0;
while(l <= r){
mid = l + (r-l)/2;
if(nums[mid] < target){
l = mid + 1;
}else{
r = mid - 1;
}
}
return l;
}
}
最后一个单词长度(单指针/双指针遍历)
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
- 反向双指针/单指针遍历
class Solution {
public int lengthOfLastWord(String s) {
//双指针方式遍历
int low = s.length() - 1;
int fast = 0;
for(fast = s.length() - 1 ; fast >= 0 ; fast--){
if(s.charAt(fast) == ' '){
if(low - fast != 0){
break;
}
low--;
}
}
return low - fast;
}
}
加一(反向指针遍历)
给定一个非空int数组，返回该数组+1后的数组 ， 如[1,2,3]返回[1,2,4]，[9,9,9]返回[1,0,0,0];
- 反向遍历
class Solution {
public int[] plusOne(int[] digits) {
//反向遍历
for (int lowestRef = digits.length - 1; lowestRef >= -1; lowestRef--) {
if (lowestRef == -1) {
digits = new int[digits.length + 1];
digits[0] = 1;
break;
}
if (digits[lowestRef] + 1 < 10) {
digits[lowestRef] += 1;
break;
} else {
digits[lowestRef] = 0;
}
}
return digits;
}
}
算数平方根（二分查找）
给定一个非负整数，求出它的算数平方根，禁止API战士，禁止使用sqrt、pow、**等方式处理
- 二分查找
注意，当使用乘法时会出现数值溢出问题，因此这里建议使用除法
class Solution {
public int mySqrt(int x) {
if(x <= 1){
return x;
}
//二分法处理 当然这里为了避免数值溢出 可以使用除法处理
int l = 1;
int r = x - 1;
while(true){
if(r - l <= 1){
break;
}
int mid = l + (r - l ) / 2;
if( x / mid >= mid){
l = mid;
}else{
r = mid;
}
}
return l;
}
}
- 迭代法
从0开始一直到x-1，使用除法遍历中间的整数，得到想要的数
爬楼梯(动态规划 、 分治递归)
给定一个n阶楼梯，每次可以爬1或者2层，请求出爬n阶楼梯有多少种爬法
不难得出结论，爬n阶楼梯的爬法F(n) = F(n-1)+F(n-2)，因此可以使用以下两种解法：
- 递归法
使用递归法可以解决这类问题，但是需要注意的是，递归将一个大问题转换为诸多小问题的同时，会导致小问题进行重复求解，因此递归会消耗额外的时间与资源，不建议使用
class Solution {
public int climbStairs(int n) {
if ( i <= 1 ){
return 1;
}
return climbStairs(n - 1) + climbStairs(n - 2);
}
}
- 动态规划
class Solution {
public int climbStairs(int n) {
int p = 0, q = 0, r = 1;
for (int i = 1; i <= n; ++i) {
p = q;
q = r;
r = p + q;
}
return r;
}
}
删除有序链表中的重复元素 （双指针遍历）
给定一个有序链表，删除其中的重复元素，返回一个有序链表。
- 双指针遍历
O(n)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if(head == null){
return null;
}
//双指针遍历
ListNode low = head;
ListNode fast = head.next;
while(fast != null){
if(fast.val != low.val){
low.next = fast;
low = fast;
}
fast = fast.next;
}
low.next = null;
return head;
}
}
- 单指针一次遍历
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if(head == null){
return null;
}
//单指针一次遍历
ListNode temp = head;
while(temp.next != null){
if(temp.next.val == temp.val){
temp.next = temp.next.next;
}else{
temp = temp.next;
}
}
return head;
}
}
合并两个有序数组（尾部遍历数组）
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
最终结果将使用nums1中的数据判断
- 将两个数组合并后排序
O(m+n)log(m+n)
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
for (int i = 0; i != n; ++i) {
nums1[m + i] = nums2[i];
}
Arrays.sort(nums1);
}
}
- 使用中间变量存储数组，头指针遍历两个数组
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
if(n == 0 || nums2 == null){
return ;
}
int[] temp = new int[m + n];
int refA = 0 , refB = 0;
for(int i = 0 ; i < m + n ; i ++){
if(refA == m){
temp[i] = nums2[refB++];
}
else if(refB == n){
temp[i] = nums1[refA++];
}else if( nums1[refA] > nums2[refB]){
temp[i] = nums2[refB++];
}else{
temp[i] = nums1[refA++];
}
}
for(int j = 0 ; j < m + n ; j++){
nums1[j] = temp[j];
}
}
}
- 不使用中间变量，从尾部遍历两个数组
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
if(n == 0 || nums2 == null){
return ;
}
int refA = m - 1;
int refB = n - 1;
for (int i = m + n - 1; i >= 0 ; i--) {
if (refA >= 0 && refB >= 0){
if (nums1[refA] >= nums2[refB]){
nums1[i] = nums1[refA--];
}else{
nums1[i] = nums2[refB--];
}
continue;
}
if (refA < 0){
nums1[i] = nums2[refB--];
}else{
nums1[i] = nums1[refA--];
}
}
}
}