【数据结构】链表 OJ 题训练

地址相等用“==”
谁指向谁，用“

0.把数组转为链表

思路
遍历数组，根据数组的值创建新的结点，把新的节点尾插~
创建两个引用，一个记录头结点，一个记录尾节点
需要注意当前是链表否空，（头插还是尾插）

    public static Node arrayToLinkedList(int[] array){
   
        //遍历数组，把元素依次进行尾插
        //每次尾插都需要知道当前链表的末尾结点
        //每次招末尾及诶单太麻烦，可以直接使用一个引用tail，把末尾结点记住
        Node head=null;
        Node tail=null;
        for (int i = 0; i < array.length; i++) {
   
            Node node=new Node(i);
            //使用node进行尾插
            //需要判断当前链表是否为空
            if(head==null){
   
                head=node;
                tail=node;
            }else{
   
                //如果链表不为空，再进行新的插入，直接操作tail
                tail.next=node;
                //一旦插入完成，更新tail的指向
                tail=tail.next;

            }


        }
        return head;
    }

//使用带傀儡结点

   //使用带傀儡节点的链表
    public static Node arrayToLinkedList1(int[] array) {
   
        //如果使用带傀儡的链表，后续的插入不需要分两种情况
        //创建一个傀儡结点，此时head指向傀儡结点
        Node head=new Node(100);
        //创建一个tail，保存尾结点
        Node tail=head;
        for (int i = 0; i < array.length; i++) {
   
            Node node=new Node(i);
            tail.next=node;
            tail=tail.next;

        }
        //如果返回head，head指向的是傀儡结点，不符合要求
        //返回head.next就可以
        return head.next;
    }

切记 判断非空

1.删除链表中所有等于val的节点

思路：
首先判断链表是否为空，其次看链表头结点是不是为val（这段代码放在最后，因为1123，val=1.这种情况如果放在前面，第二个1将不能被删除~）
双指针，cur找到val值所在的节点，prev记录前一个位置，依次删除，细节请看下图：

力扣网址

      public static ListNode removeElements(ListNode head, int val) {
   
        //删除操作，需要考虑待删除元素师投机诶单
        //删除操作，需要找到当前节点的前一个节点
        if(head==null){
   
            return null;
        }

        //删除操作，找到待删除及结点的前一个结点
        ListNode prev=head; //待删除结点的前一个
        ListNode cur=head.next; //待删除节点的
        while(cur!=null){
   
            if(cur.val==val){
   
                //找到了值为val的结点
                //需要删除这个节点
                prev.next=cur.next;
                cur=prev.next;
            }else{
   
                prev=prev.next;
                cur=cur.next;

            }

        }
        if(head.val==val){
   
            head=head.next;
        }
        return head;
    }

2.反转链表

思路：创建三个引用，链表反转，让cur的next指向prev，然后更新head

     class Solution {
   

    public static ListNode reverseList(ListNode head) {
   
        if(head==null){
   
            return null;
        }
        if(head.next==null){
   
            return  head;
        }
        //定义个引用
       
        ListNode prevNode=null;
        ListNode curNode=head;
        while(curNode!=null){
   
            ListNode nextNode =curNode.next;
            curNode.next=prevNode;
            //修改指针指向
            prevNode=curNode;
            curNode=nextNode;


        }

        return prevNode;
    }
   
}


   

3.给定一个带头节点的非空单链表，返回链表中间节点。如果有两个中间节点 ，则返回非第二个中间节点。

思路1：

• 1.遍历链表，求出链表的长度len；
• 2.在针对len/2，得到引用移动的步数
• 3.创建一个引用cur 从链表的头部开始，往后走len/2步

    public int getLength(ListNode head){
   
        int len=0;
        for (ListNode cur