单链表以及虚拟头节点的使用 Leecode82+83

单链表

定义

 //当前火车中车厢的节点个数（具体元素个数）
    private int size;
    // 当前的火车头
    private Node head;


     class Node{
    // 存储具体数据
    int val;
    Node next;
    public Node(int val){
        this.val = val;
    }




private boolean rangeCheck(int index) {
       if(index < 0 || index >size){
           return false;
       }else{
           return true;
       }
    }



    public String toString(){
        String ret = "";
        Node node = head;
        while (node != null){
            ret += node.val;
            ret += "--->";
            node = node.next;
        }
        ret += "Null";
        return ret;
    }
    }

头插

public void addFirst(int val){
        //新建一个火车节点
        Node node = new Node(val);
        //判断当前火车是否为空
        if(head == null){
            head = node;
        }else{
            node.next = head;
            head = node;
        }
        size ++;

任意位置插入

public void addIndex(int index,int val){
        //1.合法性
        if(index < 0 || index > size){
            System.out.println("add index illegal");
            return;
        }
        //头插
        if(index == 0){
            addFirst(val);
            return;
        }
        //2.任意位置插入
        Node node = new Node(val);
            //找到插入位置的前驱节点，从头结点开始向后依次走index - 1步
            Node prev = head;
        for (int i = 0; i < index - 1; i++) {
            //找到前驱节点index - 1
            prev = prev.next;
        }
        //此时prev指向待插入节点
        node.next = prev.next;
        prev.next = node;
        size++;
    }
    //在链表尾部插入
    public void addLast(int val){
        addIndex(size,val);
    }

查找(根据输入的index值，查找对应的值val)

 public int get(int index){
       //1.判断合法性
       if(rangeCheck(index)){
           //从头结点开始遍历
           Node node =head;
           //找到index
           for (int i = 0; i < index; i++) {
               node = node.next;
           }
           return node.val;
   }else{
           //index不合法
           System.err.println("get index illegal!");
           return -1;
       }
}

判断当前链表是否包含val值的index

 /**
     * 判断当前链表是否包含值为val的节点
     * @param val
     * @return
     */
    public  boolean contains(int val){
        for(Node temp = head;temp != null;temp = temp.next){
            if(temp.val == val){
                return true;
            }
        }
        return false;
    }

修改index的值val为newVal

 /**
     * 将index的值修改为newVal
      * @param index
     * @param newVal
     * @return
     */
    public int set(int index,int newVal){
        if(rangeCheck(index)){
            //索引合法
           Node node = head;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            int oldVal = node.val;
            node.val = newVal;
            return oldVal;
        }else{
            System.err.println("index is illegal!");
            return -1;
        }

    }

删除操作

/**
     * 删除任意索引节点
     * @param index
     */
    public void removeIndex(int index){
        if(rangeCheck(index)){
            //索引合法
            Node prev = head;
            //找前驱
            for (int i = 0; i < index- 1 ; i++) {
                prev = prev.next;
            }
            //找索引后继节点
            Node node = head;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            Node houji = node.next;
            prev.next = houji;//断前
            node.next=null;//断后
            size --;
        }else{
            System.err.println("remove index illegal!");
        }

    }

//删除头节点
    public void removeFirst(){
        removeIndex(0);
    }
    //删除尾节点
    public void removeLast(){
        removeIndex(size - 1);
    }

    //删除val对应的节点
    public void removeValueOnce(int val){
        if(head!=null && head.val == val){
            //删除头节点
            Node temp = head;
            head = temp.next;//断前
            temp.next = null;//断后
            size --;
        }else{
            //头节点不是待删除的节点，寻找待删除的节点
            Node prev = head;
            while(prev.next != null){
                if(prev.next.val == val){
                    Node cur = prev.next;
                    //删除cur
                    prev.next = cur.next;
                    cur.next = null;
                    size --;
                    return;
                }else{
                    //如果prev.next不是待删除节点
                    prev = prev.next;
                }

            }
        }

    }

Leecode82 删除所有重复节点（含虚拟头节点）

package seqlist.leecode;
//删除链表中所有重复元素
public class Num82 {
    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;
        }

    }
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        ListNode temp = dummyHead;
        ListNode node = temp.next;
        while (node != null) {
            //判断头节点是否存在
            ListNode cur = node.next;
            if (cur == null) { //!!!!!非常重要，首先判断head之后还有没有节点！！！
                return dummyHead.next;
            }else{
                if(cur.val == node.val){
                    while (cur != null && cur.val == node.val){
                        //判断后面的值是否还是和node的值相同
                        cur = cur.next;
                    }
                    //找到了第一个与node值不相同的节点cur
                    node = cur;
                    temp.next = cur;
                }else {
                    //前后两个值不相同
                    temp = temp.next;
                    node = node.next;
                }
            }
        }
        return dummyHead.next;

        }
}

Leecode83 删除重复节点，只保留一个（含虚拟头节点）

在这里插入代码片package seqlist.leecode;
//给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。
// 输入：head = [1,1,2]
//输出：[1,2]
//注意：链表中节点数目在范围 [0, 300] 内
//-100 <= Node.val <= 100
//题目数据保证链表已经按升序 排列
public class Num83 {
    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; }
  }
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummyHead = new ListNode(-101);
        dummyHead.next = head;
        ListNode prev = dummyHead;
        ListNode cur = prev.next;
        while (cur != null){
            if(prev.val == cur.val){
                //prev和cur是重复元素
                prev.next = cur.next;

            }else{
                prev = prev.next;
            }
            cur = cur.next;

        }
        return dummyHead.next;
    }
}