第一天

声明：本系列文章仅适合二刷有经验的算法er学习，以后会出详细的每一题的讲解，这里只是简单的说明思路来帮助大家快速刷完Top101，另外博主的算法全程跟着 labuladong 大佬学习，这里特此声明

1.反转链表

解题思路

使用双指针，依次对比两个链表每个节点的值，最后合并为一个新的链表。

代码实现

public class Solution {public ListNode ReverseList(ListNode head) {if (head == null || head.next == null) {return head;}ListNode last = ReverseList(head.next);head.next.next = head;head.next = null;return last;}
}

2.链表内指定区间反转

解题思路

当 m == 1 时，问题退化为反转链表的前 n 个节点，先写出此方法
当 m != 1 时，通过递归将问题的规模向反转链表的前 n 个节点的方向靠拢

代码实现

public class Solution {/*** * @param head ListNode类 * @param m int整型 * @param n int整型 * @return ListNode类*/public ListNode reverseBetween(ListNode head, int m, int n) {// write code hereif (m == 1) {return reverseN(head, n);}head.next = reverseBetween(head.next, m - 1, n - 1);return head;}ListNode successor = null;//反转链表的前n个节点public ListNode reverseN(ListNode head, int n) {if (n == 1) {successor = head.next;return head;}ListNode last = reverseN(head.next, n - 1);head.next.next = head;head.next = successor;return last;}
}

3.链表中的节点每k个一组进行翻转

解题思路

先写出如上一题的链表内指定区间反转的方法，这里通过迭代的方式实现
运用递归的思想不断地翻转前 k 个节点（不足 k 个，不需要反转）

代码实现

public class Solution {/*** * @param head ListNode类 * @param k int整型 * @return ListNode类*/public ListNode reverseKGroup(ListNode head, int k) {// write code hereif (head == null) return null;// 区间 [a, b) 包含 k 个待反转元素ListNode a, b;a = b = head;for (int i = 0; i < k; i++) {// 不足 k 个，不需要反转，base caseif (b == null) return head;b = b.next;}// 反转前 k 个元素ListNode newHead = reverse(a, b);// 递归反转后续链表并连接起来a.next = reverseKGroup(b, k);return newHead;}public ListNode reverse(ListNode a, ListNode b) {ListNode pre, cur, nxt;pre = null;cur = a;nxt = a;// while 终止的条件改一下就行了while (cur != b) {nxt = cur.next;cur.next = pre;pre = cur;cur = nxt;}// 返回反转后的头结点return pre;}
}

4.合并两个排序的链表

解题思路

当两链表都不为空时，根据其 val 值得大小不同来合并，注意是用虚拟头节点来避免{}的问题出现
当某一个链表为空时（另外一个不为空），直接将其连在新链表的结尾

代码实现

public class Solution {public ListNode Merge(ListNode list1, ListNode list2) {ListNode l1 = list1, l2 = list2, dummy = new ListNode(-1), p = dummy;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;}if (l1 != null) {p.next = l1;}if (l2 != null) {p.next = l2;}return dummy.next;}
}

5.合并 k 个已排序的链表

解题思路

使用优先堆的思想先将 lists 里面的链表头结点加入优先队列并排序
按照从小到大的顺序拿出一个节点拼接到新的头结点之后，检查此链表后面是否还有节点，如果有就加入优先队列，如果没有就略过。

代码实现

public class Solution {public ListNode mergeKLists(ArrayList<ListNode> lists) {if (lists.size() == 0) {return null;}ListNode dummy = new ListNode(-1), p = dummy;PriorityQueue<ListNode> pq = new PriorityQueue<>(lists.size(), (a, b) -> (a.val - b.val));for (ListNode head : lists) {if (head != null) {pq.add(head);}}while (!pq.isEmpty()) {ListNode node = pq.poll();p.next = node;if (node.next != null) {pq.add(node.next);}p = p.next;}return dummy.next;}
}

6.判断链表是否有环

解题思路

经典问题，记住就行，当快慢指针相遇时，链表中就出现了环

代码实现

public class Solution {public boolean hasCycle(ListNode head) {ListNode slow = head, fast = head;while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;if (fast == slow) {return true;}}return false;}
}

7.链表中环的入口节点

解题思路

与上题一样的思路，只不过当快慢指针相遇之后，将 slow 指针重置回头结点，然后两个指针每次只走一步，当其再次相遇时，就是链表环的入口

代码实现

public class Solution {public ListNode EntryNodeOfLoop(ListNode pHead) {ListNode slow = pHead, fast = pHead;while (fast != null && fast.next != null) {slow = slow.next;fast = fast.next.next;if (fast == slow) {break;}}if (fast == null || fast.next == null) {return null;}slow = pHead;while (slow != fast) {slow = slow.next;fast = fast.next;}return slow;}
}

8.链表中倒数最后k个节点

解题思路

依旧是快慢指针的解法，快指针先走 k 步，然后慢指针此时从头节点开始，两个指针均每次走一步，直到快指针指向 null ，此时就是链表中倒数最后k个节点

代码实现

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param pHead ListNode类 * @param k int整型 * @return ListNode类*/public ListNode FindKthToTail(ListNode pHead, int k) {// write code hereint n = 0;ListNode fast = pHead, slow = pHead;for (int i = 0; i < k; i++) {if (fast != null) {fast = fast.next;} else {return slow = null;}}while (fast != null) {fast = fast.next;slow = slow.next;}return slow;}
}

9.删除链表的倒数第n个节点

解题思路

与上一题一样，只不过这次找到倒数第 n+1 个节点然后将他后面的节点删掉即可

代码实现

public class Solution {/*** * @param head ListNode类 * @param n int整型 * @return ListNode类*/public ListNode removeNthFromEnd(ListNode head, int n) {// write code hereListNode dummy = new ListNode(-1);dummy.next = head;ListNode x = findFromEnd(dummy, n + 1);x.next = x.next.next;return dummy.next;}public ListNode findFromEnd(ListNode head, int k) {ListNode p1 = head;for (int i = 0; i < k; i++) {p1 = p1.next;}ListNode p2 = head;while (p1 != null) {p2 = p2.next;p1 = p1.next;}return p2;}
}

10.两个链表的第一个公共节点

解题思路

分别求出两条链表的长度，并求出两天链表的差值 k
将一个指针指向较长的那一个链表的头部，然后走 k 步，让 p1 和 p2 到达尾部的距离相同
之后两指针齐头并进直到 p1 与 p2 相等，这时会有两种情况出现
- 1、要么是两条链表不相交，他俩同时走到尾部空指针
- 2、要么是两条链表相交，他俩走到两条链表的相交点

代码实现

public class Solution {public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {int lenA = 0, lenB = 0;// 计算两条链表的长度for (ListNode p1 = pHead1; p1 != null; p1 = p1.next) {lenA++;}for (ListNode p2 = pHead2; p2 != null; p2 = p2.next) {lenB++;}// 让 p1 和 p2 到达尾部的距离相同ListNode p1 = pHead1, p2 = pHead2;if (lenA > lenB) {for (int i = 0; i < lenA - lenB; i++) {p1 = p1.next;}} else {for (int i = 0; i < lenB - lenA; i++) {p2 = p2.next;}}// 看两个指针是否会相同，p1 == p2 时有两种情况：// 1、要么是两条链表不相交，他俩同时走到尾部空指针// 2、要么是两条链表相交，他俩走到两条链表的相交点while (p1 != p2) {p1 = p1.next;p2 = p2.next;}return p1;}
}

17.二分查找-1

解题思路

背下来

代码实现

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param nums int整型一维数组 * @param target int整型 * @return int整型*/public int search(int[] nums, int target) {// write code hereint lo = 0, hi = nums.length - 1 , mid;if(nums.length == 0){return -1; }if (target < nums[lo] || target > nums[hi]) {return -1;}while (lo <= hi) {mid = lo + (hi - lo) / 2;if (target > nums[mid]) {lo = mid + 1;} else if (target < nums[mid]) {hi = mid - 1;} else {return mid;}}return -1;}
}

23.二叉树的前序遍历

解题思路

先进行前序遍历，将遍历结果存入数组中
将遍历结果复制到int型数组中，然后返回该数组

代码实现

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param root TreeNode类 * @return int整型一维数组*/int[] res;public int[] preorderTraversal(TreeNode root) {// write code hereif (root == null) {return res = new int[0];}List<Integer> list = new ArrayList<>();recursionOrder(root, list);res = new int[list.size()];for (int i = 0; i < list.size(); i++) {res[i] = list.get(i);}return res;}public void recursionOrder(TreeNode root, List<Integer> list) {if (root == null) {return;}list.add(root.val);recursionOrder(root.left, list);recursionOrder(root.right, list);}
}

24.二叉树的中序遍历

解题思路

跟上题一样，记住转为int型数组就行

代码实现

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param root TreeNode类 * @return int整型一维数组*/int[] res;public int[] inorderTraversal(TreeNode root) {// write code hereif (root == null) {return res = new int[0];}List<Integer> list = new ArrayList<>();recursionOrder(root, list);res = new int[list.size()];for (int i = 0; i < list.size(); i++) {res[i] = list.get(i);}return res;}public void recursionOrder(TreeNode root, List<Integer> list) {if (root == null) {return;}recursionOrder(root.left, list);list.add(root.val);recursionOrder(root.right, list);}
}

25.二叉树的后序遍历

解题思路

跟上题一样，记住转为int型数组就行

代码实现

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param root TreeNode类 * @return int整型一维数组*/int[] res;public int[] postorderTraversal(TreeNode root) {// write code hereif (root == null) {return res = new int[0];}List<Integer> list = new ArrayList<>();recursionOrder(root, list);res = new int[list.size()];for (int i = 0; i < list.size(); i++) {res[i] = list.get(i);}return res;}public void recursionOrder(TreeNode root, List<Integer> list) {if (root == null) {return;}recursionOrder(root.left, list);recursionOrder(root.right, list);list.add(root.val);}
}

50.两数之和

解题思路

纪念一下自己狂放不羁的青春，你用你的哈希表，我用我的for循环，爱咋咋地

代码实现

public class BM50 {public int[] twoSum(int[] numbers, int target) {// write code hereint n = numbers.length;int[] res = {-1, -1};for (int i = 0; i < n; i++) {for (int j = i + 1; j < n; j++) {if (numbers[i] + numbers[j] == target) {return res = new int[]{i,j};}}}return res;}
}

51.数组中出现次数超过一半的数字

解题思路

HashMap的简单应用，记到把import java.util.HashMap;加进去，他没导包会报错，就是说很离谱

代码实现

public class Solution {public int MoreThanHalfNum_Solution(int[] array) {HashMap<Integer, Integer> hashMap = new HashMap<>();for (int i = 0; i < array.length; i++) {hashMap.put(array[i], hashMap.getOrDefault(array[i], 0) + 1);if (hashMap.get(array[i]) > array.length / 2) {return array[i];}}return -1;}
}

62.斐波那切数列

解题思路

状态转移方程给你了，思考一下 base case 是 dp[1] = 1，直接写

代码实现

public class Solution {public int Fibonacci(int n) {if(n == 0){return 0;}int[] dp = new int[n+1];//base casedp[1] = 1;for(int i=2;i<=n;i++){dp[i] = dp[i-1] + dp[i-2];}return dp[n];}
}

63.跳台阶

解题思路

首先要明白当你到达最后一级台阶的时候，只能是通过前一级台阶跳一步或者是前两级台阶跳两部的方式，因此可以写出状态转移方程dp[i] = dp[i - 1] + dp[i - 2]

代码实现

public class Solution {public int jumpFloor(int target) {if (target <= 1) {return 1;}//跳target级台阶共有dp【target】种方法int[] dp = new int[target + 1];dp[0] = 1;dp[1] = 1;for (int i = 2; i <= target; i++) {dp[i] = dp[i - 1] + dp[i - 2];}return dp[target];}
}

64.最小花费爬楼梯

解题思路

可以用一个dp数组记录每次爬到第i级台阶的最小花费
一开始可以从0和1任意位置，因此 dp[0] = 0 , dp[1] = 0
每次到一个台阶，只有两种情况，要么是前一级台阶向上一步，要么是前两级台阶向上两步，此时可以得到状态转移方程dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);

代码实现

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param cost int整型一维数组 * @return int整型*/public int minCostClimbingStairs(int[] cost) {// write code here//dp[i] : 每次爬到第 i 阶所需要的最小花费int n = cost.length;int[] dp = new int[n + 1];//base casedp[0] = 0;dp[1] = 0;for (int i = 2; i <= n; i++) {dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);}return dp[n];}
}

65.最长公共子序列-2

解题思路

首先先计算出最长公共子序列所在的位置
然后将对应位置的字符组合成字符串的形式返回

代码实现

    public String LCS(String s1, String s2) {// write code hereint len1 = s1.length();int len2 = s2.length();if (len1 == 0 || len2 == 0) {return "-1";}int[][] dp = new int[len1 + 1][len2 + 1];for (int i = 0; i <= len1; i++) {for (int j = 0; j <= len2; j++) {if (i == 0 || j == 0) {dp[i][j] = 0;continue;}if (s1.charAt(i - 1) == s2.charAt(j - 1)) {dp[i][j] = dp[i - 1][j - 1] + 1;} else {dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);}}}StringBuilder sb = new StringBuilder();int s1L = len1, s2L = len2;while (s1L != 0 && s2L != 0) {if (s1.charAt(s1L - 1) == s2.charAt(s2L - 1)) {sb.append(s1.charAt(s1L - 1));s1L--;s2L--;} else {if (dp[s1L - 1][s2L] > dp[s1L][s2L - 1]) {s1L--;} else {s2L--;}}}if (sb.length() == 0) {return "-1";}return sb.reverse().toString();}
}

83.字符串变形

解题思路

将字母大小写转换后，反转整个字符串，再反转每个单词。
注意JAVA的字符串不可变，对于字符串不可变的语言，首先得把字符串转化成其他可变的数据结构.。
注意下标不要越界。

代码实现

public class Solution {public String trans(String s, int n) {StringBuilder sb=new StringBuilder(s);//单词大小写反转int i=0;char tmp;while(i<n) {tmp=sb.charAt(i);if('A'<=tmp&&tmp<='Z') sb.setCharAt(i, (char) (tmp+32));else if('a'<=tmp&&tmp<='z') sb.setCharAt(i, (char) (tmp-32));i++;}//翻转字符串reverse(sb,0,n-1);//自定义方法//翻转每个单词reverseEachWord(sb);//自定义方法return sb.toString();}private void reverse(StringBuilder sb,int left,int right) {while(left<right) {char tmp=sb.charAt(left);sb.setCharAt(left++, sb.charAt(right));sb.setCharAt(right--, tmp);}}private void reverseEachWord(StringBuilder sb) {int n=sb.length();int start=0,end=0;while(start<n) {//循环至单词的末尾while(end<n&&sb.charAt(end)!=' ') {end++;}reverse(sb,start,end-1);//翻转单词start=end+1;//更新start，去找下一个单词++end;}}
}

84.最长公共前缀

解题思路

将字符串数组看作一个二维空间，每一次从第一列开始。
确定所有字符子串中第一列字符。
逐层扫描后面每一列，遇到不同字符停止扫描。

代码实现

public class Solution {/*** * @param strs string字符串一维数组 * @return string字符串*/public String longestCommonPrefix (String[] strs) {// //纵向扫描if(strs.length==0 || strs==null){return "";}int rows = strs.length;int cols = strs[0].length();//开始扫描for(int i=0;i<cols;i++){char firstChar = strs[0].charAt(i);for(int j=1;j<rows;j++){if(strs[j].length()==i || strs[j].charAt(i)!=firstChar){return strs[0].substring(0,i);}}}return strs[0];}
}

85.验证Ip地址

解题思路（城南亦南大神写的挺好的，我就直接搬运了）

首先需要根据分隔符，对输入字符串进行分割。含有".“的，判断是否是IPv4地址。含有”:"的，判断是否是IPv6地址。
对于IPv4的判断，分割之后，如果不是4组，返回"Neither"。如果某一组的字符不是全部由’0’-'9’范围内字符组成，返回"Neither"。如果某一组的数字大于255，或者第一位是0，而长度不止一位的，返回"Neither"。
对于IPv6的判断，分割之后，如果不是8组，返回"Neither"。如果某一组为空，或者长度大于4的，返回"Neither"。如果某一组为’0’，而该组中’0’的个数不止一个的，返回"Neither"。

代码实现

public class BM85 {/*** 验证IP地址* @param IP string字符串 一个IP地址字符串* @return string字符串*/public String solve (String IP) {//含有"."的，判断是否是IPv4地址if(IP.indexOf(".")>0){//通过"."进行分割String[] strs=IP.split("\\.");//如果不是4组，返回"Neither"if(strs.length!=4) return "Neither";//遍历每一组for(int i=0;i<strs.length;i++){//如果某一组的字符不是全部由'0'-'9'范围内字符组成，返回"Neither"for(char c:strs[i].toCharArray()){if(!(c>='0'&&c<='9')){return "Neither";}}//如果大于255，或者第一位是0，而长度不止一位的，返回"Neither"if(Integer.parseInt(strs[i])>255||(strs[i].charAt(0)=='0'&&strs[i].length()>1)) return "Neither";}return "IPv4";}//含有":"的，判断是否是IPv6地址else if(IP.indexOf(":")>0){//如果以":"开头，或者以":"结尾，返回"Neither"if(IP.charAt(0)==':'||IP.charAt(IP.length()-1)==':'){return "Neither";}//通过":"进行分割String[] strs=IP.split(":");//如果不是8组，返回"Neither"if(strs.length!=8) return "Neither";//遍历每一组for(int i=0;i<strs.length;i++){/* 如果某一组的字符不是全部由'0'-'9'范围内字符组成，或'a'-'f'字符，'A'-'F'字符范围内字符组成，返回"Neither" */for(char c:strs[i].toCharArray()){if(!(c>='0'&&c<='9')&&!(c>='a'&&c<='f')&&!(c>='A'&&c<='F')){return "Neither";}}//如果某一组为空，或者长度大于4的，返回"Neither"if(strs[i].equals("")||strs[i].length()>4) return "Neither";}return "IPv6";}else{return "Neither";}}
}

86.大数加法

解题思路

都用 Java 了，直接用大数类型直接过吧

代码实现

public class BM86 {public String solve (String s, String t) {BigInteger bigInteger1 = new BigInteger(s);BigInteger bigInteger2 = new BigInteger(t);return bigInteger1.add(bigInteger2).toString();}
}

87.合并两个有序数组

解题思路

使用三个指针，i指向数组A的最大元素，j指向数组B的最大元素，k指向数组A空间的结尾处。
从两个数组最大的元素开始遍历，直到某一个结束，每次取出较大的一个值放入数组A空间的最后，然后指针一次往前。
如果数组B先遍历结束，数组A前半部分已经存在了，不用管；但是如果数组A先遍历结束，则需要把数组B剩余的前半部分依次逆序加入数组A前半部分，类似归并排序最后的步骤。

代码实现

public class BM87 {public void merge(int A[], int m, int B[], int n) {//合并for(int i=0;i!=n;i++){A[m+i] = B[i];}//排序Arrays.sort(A);}
}

【自我救赎--牛客网Top101 4天刷题计划】第一天热身运动相关推荐

【自我救赎--牛客网Top101 4天刷题计划】第四天登峰造极
第四天声明:本系列文章仅适合二刷有经验的算法er学习,以后会出详细的每一题的讲解,这里只是简单的说明思路来帮助大家快速刷完Top101,另外博主的算法全程跟着 labuladong 大佬学习,这里特 ...
【自我救赎--牛客网Top101 4天刷题计划】第三天渐入佳境
第三天声明:本系列文章仅适合二刷有经验的算法er学习,以后会出详细的每一题的讲解,这里只是简单的说明思路来帮助大家快速刷完Top101,另外博主的算法全程跟着 labuladong 大佬学习,这里特 ...
牛客网SQL 进阶篇刷题
牛客网SQL 进阶篇刷题(1-19) 用户1001在2021年9月1日晚上10点11分12秒开始作答试卷9001,并在50分钟后提交,得了90分: 用户1002在2021年9月4日上午7点1分2秒开始 ...
为了OFFER系列 | 牛客网美团点评数据分析刷题
@Author:Runsen 对于大学的每一个阶段,都有着不同的意义,在大学期间一定要有明确的战略.打法,以及人生布局,才能最大程度的提升自己,才能在未来走的更远. 现如今大四,为了OFFER,冲啊 ...
原创牛客网产品笔试题刷题打卡——用户研究
QQ和微信的区别. 1.产品定位 QQ:"每一天,乐在沟通",是一款基于互联网的社交通讯软件.QQ是PC互联网的产物,侧重社交,更娱乐化. 微信:"一个生活方式" ...
原创牛客网产品笔试题刷题打卡——需求分析/数据分析/文档攥写
ARPU(ARPU-AverageRevenuePerUser)即每用户平均收入.用于衡量电信运营商和互联网公司业务收入的指标.ARPU注重的是一个时间段内运营商从每个用户所得到的收入.很明显,高端的 ...
string类函数和牛客网剑指offer刷题记录
1.strcat char* strcat(char *strDest,const char *strSrc){assert(strDest && strSrc);char *p = ...
牛客网产品笔试题刷题打卡——产品规划
牛客网产品笔试题刷题打卡——需求分析
互联网思维: 1．用户思维:指在价值链各个环节中都要"以用户为中心"去考虑问题.(最重要) 2．简约思维:指在产品规划和品牌定位上,力求专注.简单:在产品设计上,力求简洁.简约 ...

【自我救赎--牛客网Top101 4天刷题计划】第一天热身运动

第一天

1.反转链表

2.链表内指定区间反转

3.链表中的节点每k个一组进行翻转

4.合并两个排序的链表

5.合并 k 个已排序的链表

6.判断链表是否有环

7.链表中环的入口节点

8.链表中倒数最后k个节点

9.删除链表的倒数第n个节点

10.两个链表的第一个公共节点

17.二分查找-1

23.二叉树的前序遍历

24.二叉树的中序遍历

25.二叉树的后序遍历

50.两数之和

51.数组中出现次数超过一半的数字

62.斐波那切数列

63.跳台阶

64.最小花费爬楼梯

65.最长公共子序列-2

83.字符串变形

84.最长公共前缀

85.验证Ip地址

86.大数加法

87.合并两个有序数组

【自我救赎--牛客网Top101 4天刷题计划】第一天热身运动相关推荐

最新文章

热门文章

【自我救赎--牛客网Top101 4天刷题计划】 第一天 热身运动

第一天

1.反转链表

2.链表内指定区间反转

3.链表中的节点每k个一组进行翻转

4.合并两个排序的链表

5.合并 k 个已排序的链表

6.判断链表是否有环

7.链表中环的入口节点

8.链表中倒数最后k个节点

9.删除链表的倒数第n个节点

10.两个链表的第一个公共节点

17.二分查找-1

23.二叉树的前序遍历

24.二叉树的中序遍历

25.二叉树的后序遍历

50.两数之和

51.数组中出现次数超过一半的数字

62.斐波那切数列

63.跳台阶

64.最小花费爬楼梯

65.最长公共子序列-2

83.字符串变形

84.最长公共前缀

85.验证Ip地址

86.大数加法

87.合并两个有序数组

【自我救赎--牛客网Top101 4天刷题计划】 第一天 热身运动相关推荐

最新文章

热门文章

【自我救赎--牛客网Top101 4天刷题计划】第一天热身运动

【自我救赎--牛客网Top101 4天刷题计划】第一天热身运动相关推荐