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.24 [328. 奇偶链表](https://leetcode.cn/problems/odd-even-linked-list/)
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;
}
}
12.24 328. 奇偶链表
给定单链表的头节点
head
,将所有索引为奇数的节点和索引为偶数的节点分别组合在一起,然后返回重新排序的列表。第一个节点的索引被认为是 奇数 , 第二个节点的索引为 偶数 ,以此类推。
请注意,偶数组和奇数组内部的相对顺序应该与输入时保持一致。
你必须在
O(1)
的额外空间复杂度和O(n)
的时间复杂度下解决这个问题。示例 1:
输入: head = [1,2,3,4,5] 输出: [1,3,5,2,4]
示例 2:
输入: head = [2,1,3,5,6,4,7] 输出: [2,3,6,7,1,5,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 oddEvenList(ListNode head) {
ListNode l1 = head; //用来指向链表的最后一个元素,方便向后添加节点
int len = 1;
if(l1 == null) return null;
while(l1.next != null){ //让l1指向最后一个元素
l1 = l1.next;
len++;
}
if(len == 2) return head;
int flag = 0; //记录该节点是否添加到链表最后,1为添加,0为不添加
ListNode l2 = head;
ListNode pre = new ListNode();//记录节点的前一个节,防止断链
pre.next = head;
ListNode l = l1; //用来记录尾指针元素
int i = 1;
while(i <= len){ //当遍历到尾指针位置时结束循环
if(flag == 1){
pre.next = l2.next;
l1.next = l2;
l2 = l2.next;
l1 = l1.next;
l1.next = null;
flag = 0;
i++;
}else{
i++;
flag = 1;
l2 = l2.next;
pre = pre.next;
}
}
return head;
}
}