[力扣]链表

• 最后一题设计数学思想
• 其他都是链表基本操作
• [针对性复习]

代码随想录[原文指路]

概述

1.概念

• 不一定连续存储空间
• 以节点的方式存储
• 每个节点包含data,next

2.类型

• 单链表(data,next)
• 双链表(pre,data,next)
• 循环链表(尾节点next指向head)

3.存储方式

• 存储空间不连续
  

4.操作

• 删除节点
  
• 添加节点
  

5.总结

• 链表主要动笔画出链表间前后节点的关系
• 只有最后一题需要数学思想，其他就基本操作

移除链表元素[203]

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while(head!=null&&head.val==val){
            head = head.next;
        }
        if(head==null) return null;
        ListNode pre = head;
        ListNode cur = head.next;
        while(cur!=null){
            if(cur.val==val){
                pre.next = cur.next;
            }else{
                pre = pre.next;
            }
            cur = cur.next;
        }
        return head;
    }
}

设计链表[707]

class LinkedListOne{
    public int data;
    public LinkedListOne next;
    public LinkedListOne(int data,LinkedListOne next) {
        this.data = data;
        this.next = next;
    }
}

class MyLinkedList {
    public LinkedListOne head = new LinkedListOne(-1,null);

    public MyLinkedList() {}

    public int size(){
    	LinkedListOne cur = head;
        int count=0;
        while(cur.next!=null){
        	cur = cur.next;
            count++;
        }
        return count;
    }
    
    //获取链表中第 index 个节点的值。如果索引无效，则返回-1。
    public int get(int index) {
        LinkedListOne cur = this.head;
        int length = this.size();
        if(index<0 || index>=length){return -1;}
        int count=0;
        while(count!=index){
            cur = cur.next;
            count++;
        }
        return cur.next.data;
    }
    
    //在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点
    public void addAtHead(int val) {
        LinkedListOne cur = this.head;
        LinkedListOne node = new LinkedListOne(val,cur.next);
        cur.next = node;
    }
    
    //将值为 val 的节点追加到链表的最后一个元素
    public void addAtTail(int val) {
        LinkedListOne cur = this.head;
        while(cur.next!=null){
            cur = cur.next;
        }
        cur.next = new LinkedListOne(val,null);
    }
    
    //在链表中的第 index 个节点之前添加值为 val  的节点
    public void addAtIndex(int index, int val) {
        LinkedListOne cur = this.head;
        int length = this.size();
        //如果 index 等于链表的长度，则该节点将附加到链表的末尾
        if(index==length) {
        	this.addAtTail(val);
        	return;
        }
        //如果 index 大于链表长度，则不会插入节点
        if(index>length) return;
        //如果index小于0，则在头部插入节点
        if(index<0) {
        	this.addAtHead(val);
        	return;
        }

        int count=0;
        while(count!=index){
            cur = cur.next;
            count++;
        }
        LinkedListOne after = cur.next;
        cur.next = new LinkedListOne(val,after);
    }
    
    //如果索引 index 有效，则删除链表中的第 index 个节点
    public void deleteAtIndex(int index) {
        LinkedListOne cur = this.head;
        int length = this.size();
        if(index<0 || index>=length){return;}
        int count=0;
        while(count!=index){
            cur = cur.next;
            count++;
        }
        //最后一个节点        
        if(index==length-1){
            cur.next=null;
            return;
        }
        cur.next = cur.next.next;
    }
}

反转链表[206]

• new节点

class Solution {
    public ListNode reverseList(ListNode head) {
        //建立新头节点，每循环一个节点添加到新头节点的头部
        if(head==null) return head;
        ListNode newHead = new ListNode(head.val);
        while(head.next!=null){
            //保存头节点的下一个节点的值
            int curVal = head.next.val;
            head = head.next;
            ListNode cur = newHead;
            newHead = new ListNode(curVal,cur);
        }
        return newHead;
    }
}

• 不new

class Solution {
    public ListNode reverseList(ListNode head) {
        //建立新头节点，每循环一个节点添加到新头节点的头部
        if(head==null) return head;
        ListNode newHead = new ListNode(head.val);
        head = head.next;
        while(head!=null){
            //保存头节点的下一个节点的值
        	ListNode cur = head;
            head = head.next;    
            cur.next=newHead;        
            newHead = cur;
        }
        return newHead;
    }
}

两两交换链表中的节点[24]

• 普通

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head==null || head.next==null) return head;
        ListNode cur1 = head;
        ListNode cur2 = head.next;
        ListNode pre;
        
        //第一二个的交换
        cur1.next = cur2.next;
        cur2.next = cur1;
        head = cur2;

        while(cur1!=null && cur1.next!=null && cur1.next.next!=null){
            pre = cur1;
            cur1 = cur1.next;
            cur2 = cur1.next;
            cur1.next = cur2.next;
            cur2.next = cur1;
            pre.next = cur2;
        }
        return head;
    }
}

• 递归

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head==null || head.next==null) return head;

        ListNode cur1 = head.next;

        ListNode cur2 = swapPairs(cur1.next);
        head.next = cur2;
        cur1.next = head;
        return cur1;
    }
}

删除链表的倒数第 N 个结点[19]

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode cur1 = head;
		ListNode cur2 = head;
		//统计节点总数
		int count=0;
		while(cur1!=null){
			cur1 = cur1.next;
			count++;
		}
		
		//只有一个元素
		if(count==n && n==1){
			head=null;
			return head;
		}
		//删除队首元素
		if(count==n){
			head=head.next;
			return head;
		}
		
		//count-n
		for(int i=1;i<(count-n);i++){
			cur2 = cur2.next;
		}
		
		ListNode temp = cur2.next.next;
		cur2.next.next=null;
		cur2.next=temp;
		return head;
    }
}

链表相交[面试题 02.07]

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;

        while(curB!=null){
            while(curA!=null){
                if(curA==curB && curA.val==curB.val){
                    return curA;
                }
                curA = curA.next;
            }
            curA = headA;
            curB = curB.next;
        }
        return null;
    }
}

环形链表 II[142]

public class Solution {
    public ListNode detectCycle(ListNode head) {
        //快慢循环，肯定会在环内相遇
        ListNode cur1 = head;//快：走两步
        ListNode cur2 = head;//慢：走一步
        while(cur1!=null && cur1.next!=null && cur2!=null){
            cur1 = cur1.next.next;
            cur2 = cur2.next;
            if(cur1==cur2){
                //有环
                ListNode index1 = cur1;
                ListNode index2 = head;
                while(index1!=index2){
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index2;
            }
        }
        return null;
    }
}