LinkedList 实现

 

 

public class ListNode {
    public int val ;
    public ListNode next;
    public ListNode(int val) {
        this.val = val;
        this.next = null ;
    }

}

 

 

public class MyLinkedList {

    //hide from direct access. only expose the methods
    public ListNode head ;
    public ListNode tail ;
    public int length;

    public MyLinkedList() {
        this.head = null ;
        this.tail = null ;
        this.length = 0 ;
    }
    //=== since the head and tail are encapsulated, very improtant dont loose the head===
    //1
    public void appendHead(int value){
        ListNode node = new ListNode(value) ;
        node.next = head ;
        head = node ;
        length++ ;
        syncHeadAndTail();
    }

    //2:  3->4->null  5
    public void appendTail(int value){
        if (head==null){
            this.appendHead(value);
        } else{
            tail.next = new ListNode(value) ;
            tail = tail.next ;
            length++ ;
        }
    }

    //=== assume there is no duplicate values
    //corner case: no matching value
    //3: 3->4-> null
    public void removeValue(int value){
        if (head == null) return ;
        if (head.val == value){
            head = head.next ; //corner case: 3-> null removeValue 3
            length--;
            syncHeadAndTail();
        }
        //1->3->null  3
        else{
            ListNode curr = head ;
            ListNode pre = null ;
            while (curr != null ){
                pre = curr ;
                curr = curr.next ;
                if (curr.val == value){
                    pre.next = curr.next ;
                    length--;
                    tail = pre ;
                    return;
                }
            }
        }
    }

    //4: note here the length is length
    public void removeIndex(int index){
        //index >= length also covers the head == null case
        if (index < 0 || index >= length) return;
        //if removeValue at the head:
        if (index == 0){
            head = head.next ;
        } else{
            ListNode curr = head ;
            for (int i = 0; i < index -1 ; i++) {
                curr = curr.next ;
            }
            //special case for tail
            if (index == length - 1){
                tail = curr ;
            }
            curr.next = curr.next.next ;
        }
        length--;
        syncHeadAndTail();
        //if removeValue at the end: update the tail
    }

    private void syncHeadAndTail(){
        if (length == 0){
            head = null ;
            tail = null ;
        }
        if (length == 1){
            tail = head ;
        }
    }

    //5: Integer get(int index): there would be chance return null. thats the reason we return wrapper
    public Integer get(int index){
        if (index < 0 || index >= length) return null;
        ListNode curr = head ;
        //one step short
        for (int i = 0; i < index; i++) {
            curr = curr.next ;
        }
        return curr.val ;
    }
    //6: Integer set(int index, int value): update by index. return the previous value
    public Integer set(int index, int value){
        if (index < 0 || index >= length) return null;
        ListNode curr = head ;
        //one step short
        for (int i = 0; i < index; i++) {
            curr = curr.next ;
        }
        int temp = curr.val ;
        curr.val = value ;
        return temp ;
    }
    //7: return the length: eager computation
    public int size(){
        return this.length;
    }

    //8:
    public boolean isEmpty(){
        return this.length <0;
    }
    //9: removeValue head
    public void clear(){
        head = null ;
        tail = null ;
    }
    //31524
    public static void main(String[] args) {
        MyLinkedList list = new MyLinkedList();
        list.appendHead(1);
        list.appendHead(3);
        list.appendTail(5);
        list.appendTail(2);
        list.appendTail(4);
        ListNode curr = list.head ;
        //3->1->5->2->4->
        while (curr !=null){
            System.out.print(curr.val + "->");
            curr = curr.next ;
        }
        System.out.println("head:" + list.head.val + " ; tail:" + list.tail.val);
        System.out.println(list.get(2));
        System.out.println("is empty:" + list.isEmpty());
        list.removeIndex(2);
        //list.removeValue(4);
        list.removeIndex(list.size()-1);
        System.out.println("head:" + list.head.val + " ; tail:" + list.tail.val);
        list.removeValue(2);
        //list.removeIndex(0);
        curr = list.head ;
        while (curr !=null){
            System.out.print(curr.val + "->");
            curr = curr.next ;
        }
        System.out.println("head:" + list.head.val + " ; tail:" + list.tail.val);

        /*
        the test result:
        3->1->5->2->4->head:3 ; tail:4
        5
        is empty:false
        head:3 ; tail:2
        3->1->   head:3 ; tail:1
        * */
    }
}