给定单向链表的头指针和一个要删除的节点的值,定义一个函数删除该节点。
返回删除后的链表的头节点。
注意:此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9.
我的思路:
public ListNode deleteNode(ListNode head, int val) {
if(head.val==val)
{
return head.next;
}
ListNode temp=head;
while(temp.val!=val)
{
temp=temp.next;
}
if(temp.next==null)
{
temp=null;
return head;
}
temp.val=temp.next.val;
temp.next=temp.next.next;
return head;
}
}
我的思路是新生成一个temp节点,初始值等于head,当值其值不等于val时。就往后移动,当temp.next为空,就让最后一个节点为空,但是这样好像行不通,当链表为3,10,99. 删除99,就会删除不掉。感觉还是得按答案来的双指针吗,时刻记录pre的值
if(head.val==val)
{
return head.next;
}
ListNode pre=head;
ListNode cur=head.next;
while(cur!=null&&cur.val!=val) //cur是空或者cur的值等于val就跳出
{
pre=cur;
cur=cur.next;
}
if(cur!=null)
{
pre.next=cur.next;
}
return head;
}
删除链表的倒数第N个节点
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
我的思路:双指针,设置一个pre,一个cur,一个计数count,初始为0,然后while循环,里面条件是当count!=length-n,但是现在问题是,这是个链表,那么链表的长度怎么求?这个得自己写
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode pre=head;
int last=length(head)-n;
if(last==0)
{
return head.next;
}
for(int i=0;i<last-1;i++)
{
pre=pre.next;
}
pre.next=pre.next.next;
return head;
}
private int length(ListNode head)
{
int len=0;
while(head!=null)
{
len++;
head=head.next;
}
return len;
}
反转链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题?
我的思路:这个没有头绪,但是这个顺序很符合出栈入栈。
//创建一个栈
Stack<ListNode> stack=new Stack<>();
//把链表的元素都压入栈中
while(head!=null)
{
stack.push(head);
head=head.next;
}
//判断栈是否是空
if(stack.isEmpty())
{
return null;
}
//取出栈中的第一个元素,即原来的尾部,并保存
ListNode node=stack.pop();
ListNode dummy=node;
//不断再栈中取出元素,存入第一个元素后面
while(!stack.isEmpty())
{
ListNode tempNode=stack.pop();
node.next=tempNode;
node=node.next;
}
node.next=null;
return dummy;
}
合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]
我的思路:
//判断链表1,链表2是否为空
if(l1==null)
{
return l2;
}
if(l2==null)
{
return l1;
}
ListNode dummy=new ListNode(0);
ListNode node=dummy;
while(l1!=null&&l2!=null)
{
if(l1.val<l2.val)
{
node.next=l1;
l1=l1.next;
node=node.next;
}
else{
node.next=l2;
l2=l2.next;
node=node.next;
}
}
node.next=l1==null?l2:l1;
return dummy.next;
回文链表
请判断一个链表是否为回文链表。
示例 1:
输入: 1->2
输出: false
输入: 1->2->2->1
输出: true
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题?
我的思路:回文一般都是双指针,一头一尾,判断是否相等。
因为这里是单向链表,只能从前往后访问,不能从后往前访问
通过找到链表的中间节点然后把链表后半部分反转
,最后再用后半部分反转的链表和前半部分一个个比较即可
class Solution {
public boolean isPalindrome(ListNode head) {
ListNode fast = head, slow = head;
//通过快慢指针找到中点
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
}
//如果fast不为空,说明链表的长度是奇数个
if (fast != null) {
slow = slow.next;
}
//反转后半部分链表
slow = reverse(slow);
fast = head;
while (slow != null) {
//然后比较,判断节点值是否相等
if (fast.val != slow.val)
return false;
fast = fast.next;
slow = slow.next;
}
return true;
}
public ListNode reverse(ListNode head) {
//新链表
ListNode newHead = null;
while (head != null) {
//先保存访问的节点的下一个节点,保存起来
//留着下一步访问的
ListNode temp = head.next;
//每次访问的原链表节点都会成为新链表的头结点,
//其实就是把新链表挂到访问的原链表节点的
//后面就行了
head.next = newHead;
//更新新链表
newHead = head;
//重新赋值,继续访问
head = temp;
}
//返回新链表
return newHead;
}
环形链表
给定一个链表,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。
如果链表中存在环,则返回 true 。 否则,返回 false 。
我的思路:利用快慢指针来解决。
public boolean hasCycle(ListNode head) {
ListNode fast=head;
ListNode slow=head;
while(fast!=null&&fast.next!=null)
{
fast=fast.next.next;
slow=slow.next;
if(fast==slow)
{
return true;
}
}
return false;
}