代码随想录day03(力扣：203.移除链表元素&707.设计链表&206.反转链表)

代码随想录day03(力扣：203.移除链表元素&707.设计链表&206.反转链表 )

203移出链表元素

直接删除

	先确认头节点是目标值的情况，直接另头结点等于头结点的下一个节点
	然后确认头结点为空（即这个链表是一个空链表）直接返回头结点
	最后考虑一般情况：
		逐渐自作向右遍历整个链表直到找到目标节点。然后另目标节点的前一个节点的next指向目标节点的next

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

        ListNode a=head;
        while(a.next!=null){
            if(a.next.val==val){
                a.next=a.next.next;
            }else{
                a=a.next;
            }
        }
        return head;
    }
}

虚拟节点

在上一个方法中我们需要单独为头结点做单独考虑，所以我们可以创建一个新的头结点，使原来的头结点变为一个普通节点，而且由于新的头结点是我们创建的所以肯定不为空

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }
        
        ListNode newHead = new ListNode(-1,head);
        ListNode a=head;
        ListNode b=newHead;
        while(a != null){
            if(a.val == val){
                b.next = a.next;
            }else{
                b=a;
            }
            a=a.next;
        }
        return newHead.next;

    }
}

707设计链表

这一题基本就是链表的一些基础操作

单链表

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

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }
    
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }


    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }


    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
    
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            head = head.next;
	    return;
        }
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

双链表

class ListNode{
    int val;
    ListNode next,prev;
    ListNode() {};
    ListNode(int val){
        this.val = val;
    }
}


class MyLinkedList {  

    
    int size;

    ListNode head,tail;
    
    public MyLinkedList() {
       
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
  
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int index) {
     
        if(index<0 || index>=size){
            return -1;
        }
        ListNode cur = this.head;
        if(index >= size / 2){
            cur = tail;
            for(int i=0; i< size-index; i++){
                cur = cur.prev;
            }
        }else{
            for(int i=0; i<= index; i++){
                cur = cur.next; 
            }
        }
        return cur.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;
        }
   
        if(index<0){
            index = 0;
        }
        size++;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        if(index<0 || index>=size){
            return;
        }
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
    }

206反转链表

看到反转二字，第一时间想到的就是利用栈来实现(栈的先进后出，完美实现了倒转)

class Solution {
    public ListNode reverseList(ListNode head) {
            Stack<ListNode> stack = new Stack<>();

            //将链表中元素放入栈
            while(head != null){
                stack.push(head);
                head =head.next;
            }

            //如果栈是空的直接返回null
            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;
    }
}

在该程序中尤其要注意最后的node.next=null,如果没有该部分，将会导致该程序变为一个环