剑指 Offer 18. 删除链表的节点
给定单向链表的头指针和一个要删除的节点的值,定义一个函数删除该节点。
返回删除后的链表的头节点。
注意:此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点,那么在调用了你的函数之后,该链表应变为 4 -> 5 -> 9.
说明:
题目保证链表中节点的值互不相同
若使用 C 或 C++ 语言,你不需要 free 或 delete 被删除的节点
class Solution {
public ListNode deleteNode(ListNode head, int val) {
ListNode temp=head;
if(head.val == val){
return head.next;
}
while(temp.next!=null){
if(temp.next.val==val){
temp.next=temp.next.next;
break;
}
temp=temp.next;
}
return head;
}
}
剑指 Offer 22. 链表中倒数第k个节点
输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。
例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
示例:
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
List<ListNode>list=new ArrayList<ListNode>();
ListNode temp=head;
while(temp!=null)
{
list.add(temp);
temp=temp.next;
}
return list.get(list.size()-k);
}
}
剑指 Offer 25. 合并两个排序的链表
输入两个递增排序的链表,合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1:
输入:1->2->4, 1->3->4
输出:1->1->2->3->4->4
限制:
0 <= 链表长度 <= 1000
注意:本题与主站 21 题相同
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if(l1 == null && l2 == null){
return null;
}
if(l1 == null){
return l2;
}
if(l2 == null){
return l1;
}
ListNode head;
if(l1.val > l2.val){
head = l2;
l2=l2.next;
}
else{
head = l1;
l1=l1.next;
}
ListNode temp = head;
while(l1!=null || l2 !=null){
if(l1==null){
temp.next =l2;
break;
}
if(l2==null){
temp.next=l1;
break;
}
if(l1.val<l2.val){
temp.next=l1;
l1=l1.next;
}
else if(l1.val >= l2.val){
temp.next =l2;
l2=l2.next;
}
temp=temp.next;
}
return head;
}
}
剑指 Offer 52. 两个链表的第一个公共节点
输入两个链表,找出它们的第一个公共节点。
如下面的两个链表:
在节点 c1 开始相交。
示例 1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Reference of the node with value = 8
输入解释:相交节点的值为 8 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
示例 2:
输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出:Reference of the node with value = 2
输入解释:相交节点的值为 2 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。
示例 3:
输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出:null
输入解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。
解释:这两个链表不相交,因此返回 null。
注意:
如果两个链表没有交点,返回 null.
在返回结果后,两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度,且仅用 O(1) 内存。
本题与主站 160 题相同:https://leetcode-cn.com/problems/intersection-of-two-linked-lists/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA == null || headB==null ){
return null;
}
ListNode tempA = headA;
ListNode tempB = headB;
while(tempA != null || tempB != null){
if(tempA == null){
tempA = headB;
}
if(tempB == null){
tempB = headA;
}
if(tempB == tempA){
return tempA;
}
tempA = tempA.next;
tempB = tempB.next;
}
return null;
}
}
今天的最有价值的一道题。
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有奇数在数组的前半部分,所有偶数在数组的后半部分。
示例:
输入:nums = [1,2,3,4]
输出:[1,3,2,4]
注:[3,1,2,4] 也是正确的答案之一。
提示:
0 <= nums.length <= 50000
0 <= nums[i] <= 10000
class Solution {
public int[] exchange(int[] nums) {
int slow=0;
int fast=nums.length-1;
while( slow < fast){
while(slow <fast && nums[slow] % 2 !=0){ //找到第一个偶数
slow++;
}
while(slow<fast && nums[fast] % 2 ==0){ //找到第一个奇数
fast--;
}
int x = nums[slow];
nums[slow] = nums[fast];
nums[fast] = x;
}
return nums;
}
}
剑指 Offer 57. 和为s的两个数字
输入一个递增排序的数组和一个数字s,在数组中查找两个数,使得它们的和正好是s。如果有多对数字的和等于s,则输出任意一对即可。
示例 1:
输入:nums = [2,7,11,15], target = 9
输出:[2,7] 或者 [7,2]
示例 2:
输入:nums = [10,26,30,31,47,60], target = 40
输出:[10,30] 或者 [30,10]
限制:
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^6
class Solution {
public int[] twoSum(int[] nums, int target) {
int result[] = new int[2];
int right=nums.length - 1;
int left=0;
while( left < right ){
if(nums[left] + nums[right] == target){
result[0] =nums[left];
result[1] =nums[right];
return result;
}
if(nums[left] + nums[right] > target){
right--;
}
if(nums[left] + nums[right] < target){
left++;
}
}
return result;
}
}
剑指 Offer 58 - I. 翻转单词顺序
输入一个英文句子,翻转句子中单词的顺序,但单词内字符的顺序不变。为简单起见,标点符号和普通字母一样处理。例如输入字符串"I am a student. “,则输出"student. a am I”。
示例 1:
输入: “the sky is blue”
输出: “blue is sky the”
示例 2:
输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
示例 3:
输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。
说明:
无空格字符构成一个单词。
输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。
class Solution {
public String reverseWords(String s) {
StringBuilder sb = new StringBuilder();
s = s.trim();
int right =s.length();
int left=right-1;
while(left >= 0){
while(left >=0 && s.charAt(left)!= ' '){
left--;
}
sb.append( s.substring(left+1,right) );
while( left>=0 && s.charAt(left) == ' '){
left--;
}
right=left+1;
if(left!=-1){
sb.append(" ");
}
}
return sb.toString();
}
}