Java算法练习3
Java算法练习3
-
- 12.18 [Leetcode203 移除链表元素](https://leetcode.cn/problems/remove-linked-list-elements/)
- 12.19 [链表的中间结点](https://leetcode.cn/problems/middle-of-the-linked-list/)
- 12.20 [ 两数相加](https://leetcode.cn/problems/add-two-numbers/)
- 12.21 [234. 回文链表](https://leetcode.cn/problems/palindrome-linked-list/)
- 12.22 [21. 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists/)
- 12.23 [23. 合并 K 个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists/)
12.18 Leetcode203 移除链表元素
给你一个链表的头节点
head和一个整数val，请你删除链表中所有满足Node.val == val的节点，并返回 新的头节点 。示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]示例 2：
输入：head = [], val = 1 输出：[]示例 3：
输入：head = [7,7,7,7], val = 7 输出：[]
/**
* 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 removeElements(ListNode head, int val) {
//设置头节点用来处理删除首节点的情况
//如果不设置头节点则需要单独考虑删除首元节点情况
ListNode a = new ListNode();
//让头节点指向head
a.next = head;
//设置指针b用来循环遍历
ListNode b = a;
while(b.next != null){
//如果b的下一个节点的值是要删除的节点
if(b.next.val == val){
//则让b的下一个节点指向要删除的节点的下一个节点，来代替删除
b.next = b.next.next;
}else{
//如果不成立，则往后继续遍历
b = b.next;
}
}
return a.next;
}
}
12.19 链表的中间结点
给你单链表的头结点
head，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
示例 1：
输入：head = [1,2,3,4,5] 输出：[3,4,5] 解释：链表只有一个中间结点，值为 3 。示例 2：
输入：head = [1,2,3,4,5,6] 输出：[4,5,6] 解释：该链表有两个中间结点，值分别为 3 和 4 ，返回第二个结点。
/**
* 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 middleNode(ListNode head) {
ListNode first= new ListNode();
first.next = head;
int len = 0;
//循环遍历链表计算链表长度
while(first.next != null){
len++;
first = first.next;
}
first = head;
int i = 1;
while(i < len /2){
first = first.next;
i++;
}
return first.next == null ? first : first.next;
}
}
12.20 两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807.示例 2：
输入：l1 = [0], l2 = [0] 输出：[0]示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9] 输出：[8,9,9,9,0,0,0,1]
/**
* 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 addTwoNumbers(ListNode l1, ListNode l2) {
int flag = 0; //用来记录进位
ListNode l = new ListNode(); //创建新的链表，用来记录两个链表之和
ListNode b = l; //初始化指针指向头节点
while(l1 != null || l2 != null || flag == 1){
int n = -1; //用来记录两个链表的每位数之和
if(l1 == null && l2 == null){ //如果两个链表都遍历结束，证明还有进位要处理
n = flag;
}else if(l1 == null){ //如果l1遍历结束，l2没遍历结束，则需考虑l2和进位
n = l2.val + flag;
l2 = l2.next;
}else if(l2 == null){ //如果l2遍历结束，l1没遍历结束，则需考虑l1和进位
n = l1.val + flag;
l1 = l1.next;
}else{ //两者都没遍历结束
n = l1.val + l2.val + flag;
l1 = l1.next;
l2 = l2.next;
}
if(n >= 10){
ListNode a = new ListNode(n - 10); //创建大于10的节点，记录多余10的部分
b.next = a; //将节点添加到链表尾部
b = b.next;
flag = 1;
}else{
ListNode a = new ListNode(n); //创建小于10的节点
b.next = a; //将节点添加到链表尾部
b = b.next;
flag = 0;
}
}
return l.next;
}
}
12.21 234. 回文链表
给你一个单链表的头节点
head，请你判断该链表是否为回文链表。如果是，返回true；否则，返回false。示例 1：
输入：head = [1,2,2,1] 输出：true示例 2：
输入：head = [1,2] 输出：false
/**
* 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 boolean isPalindrome(ListNode head) {
StringBuilder s = new StringBuilder();
while(head != null){
s.append(head.val);
head = head.next;
}
return s.toString().equals(s.reverse().toString());
}
}
12.22 21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4]示例 2：
输入：l1 = [], l2 = [] 输出：[]示例 3：
输入：l1 = [], l2 = [0] 输出：[0]
/**
* 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 l1 = list1; //用来在链表list1上移动的指针
ListNode pre1 = new ListNode(); //创建list1链表的头节点，方便处理插入到第一个位置
pre1.next = list1;
ListNode l = pre1;//用来记录返回的链表
ListNode l2 = list2;
ListNode pre2 = list2;
if( list1 ==null) return list2;
while(l2 != null){
if(l1 == null){ //表示到链表list1结尾，即直接将剩余的list2链表中的节点直接拼接到list1结尾
pre1.next = l2;
return l.next;
}else if(l1.val > l2.val){ //判断是否为插入位置
pre2 = l2; //指向要插入的节点
l2 = l2.next; //先让l2向后移一位防止断链
pre2.next = l1;
pre1.next = pre2;
pre1 = pre1.next;
}else{
l1 = l1.next;
pre1 = pre1.next;
}
}
return l.next;
}
}
12.23 23. 合并 K 个升序链表
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]] 输出：[1,1,2,3,4,4,5,6] 解释：链表数组如下： [ 1->4->5, 1->3->4, 2->6 ] 将它们合并到一个有序链表中得到。 1->1->2->3->4->4->5->6示例 2：
输入：lists = [] 输出：[]示例 3：
输入：lists = [[]] 输出：[]
/**
* 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 mergeKLists(ListNode[] lists) {
int k = lists.length;
return merge(lists , 0 , k -1); //用分治方法来算
}
public ListNode merge(ListNode[] lists, int left, int right) {
if (left == right) {
return lists[left];
}
if (left > right) {
return null;
}
int mid = (left + right) / 2;
return mergeTwoLists(merge(lists, left, mid), merge(lists, mid + 1, right));
}
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
ListNode l1 = list1; //用来在链表list1上移动的指针
ListNode pre1 = new ListNode(); //创建list1链表的头节点，方便处理插入到第一个位置
pre1.next = list1;
ListNode l = pre1;//用来记录返回的链表
ListNode l2 = list2;
ListNode pre2 = list2;
if( list1 ==null) return list2;
while(l2 != null){
if(l1 == null){ //表示到链表list1结尾，即直接将剩余的list2链表中的节点直接拼接到list1结尾
pre1.next = l2;
return l.next;
}else if(l1.val > l2.val){ //判断是否为插入位置
pre2 = l2; //指向要插入的节点
l2 = l2.next; //先让l2向后移一位防止断链
pre2.next = l1;
pre1.next = pre2;
pre1 = pre1.next;
}else{
l1 = l1.next;
pre1 = pre1.next;
}
}
return l.next;
}
}