2021-4-9-链表

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 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;

        
    }