蒜香法棍--链表

1.如何定义一个链表
其中有next属性和val属性

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

2.删除链表–双指针
一般如果对链表有改动的操作都需要是使用到双指针

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //虚拟头节点
        ListNode cur=new ListNode(-1,head);
        //也是双指针当前节点
        ListNode temp=cur;
        //下一个节点
        ListNode tempNext=temp.next;
        while(tempNext!=null){
            if(tempNext.val==val){
                temp.next=tempNext.next;
            }else{
                temp=tempNext;
            }
            tempNext=tempNext.next;
        }
        return cur.next;
    }
}

3.定义自己的单向链表—链表最重要的东西双指针

class ListNode{
    int val;
    ListNode next;
   public ListNode(){ 
   }
     public ListNode(int val){
         this.val=val; 
   }
     public ListNode(int val,ListNode next){
         this.val=val;
         this.next=next; 
   }
}
class MyLinkedList {
    int size;

    ListNode head;    

    public MyLinkedList() {
        head=new ListNode(0);
        size=0;
    }
    
    public int get(int index) {
        if(index<0||index>=size){
            return -1;
        }
        ListNode temp=head.next;
        while(temp!=null&&index>0){
                temp=temp.next;
                index--;
        }
        return temp.val;
    }

    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }else if(index<0){
            ListNode next=head.next;
            head.next=new ListNode(val,next);
            size++;
        }else{
            ListNode cur=head;
            ListNode temp=head.next;
            while(temp!=null&&index>0){
                cur=cur.next;
                temp=temp.next;
                index--;
            }
            cur.next=new ListNode(val,temp);
                        size++;
        }

    }
    
    public void deleteAtIndex(int index) {
        if(index<0||index>=size){
            return;
        }
            ListNode cur=head;
            ListNode temp=head.next;
            while(temp!=null&&index>0){
                cur=cur.next;
                temp=temp.next;
                index--;
            }
            cur.next=temp.next;
            size--;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

反转链表
其实就是把next反转下

class Solution {
    public ListNode reverseList2(ListNode head) {
      //迭代法
      return reverseList(head,null);
    }
    public ListNode reverseList(ListNode head,ListNode cur){
        if(head==null){
            return cur;
        }
        //将当前的节点的下一个节点单提取出来
        ListNode temp=head.next;
        //将当前节点的指针指向另外反转测
        head.next=cur;
        return reverseList(temp,head);
    }

    public ListNode reverseList(ListNode head) {
        ListNode l1=head;
        ListNode cur=null;
        while(l1!=null){
            ListNode next=l1.next;
            l1.next=cur;
            cur=l1;
            l1=next;
        }
        return cur;
    }
}

两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

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

}