java数据结构（线性表之链表）

/**
 * 
 * 1.听别人讲的时候发现很容易，但其实是很不容易，
 * 其中涉及了很多的知识，像引用，引用的理解是非常重要的
 * 可以说不能理解引用无法学习java的数据结构。
 * 
 * 2.同时对于java的数据结构的递归与迭代的两种方法，
 * 分别给予书写
 * 
 * 3.所以就是说细节很重要，有时候就是因为很多细节上的不理解导致了
 * 无法将知识点连贯起来
 * 
 * 4.遇到的问题很多都是自己当初不理解的，当理解了这些知识后，思维就会更加连贯，
 * 所以跟着别人学习的脚步，能够少走弯路
 * 
 * 5.很多时候将语法理解后，在进行算法上的思想上的理解，像数据结构，你要是理解了，
 * 就可以完全写出属于自己的代码
 * 
 * 6.记住别人的操作是没有太大意义的，关键是能够有自己的编程思想，
 * 可能需要很多时间来建立
 * 
 * 7.编程规范：当你刚开始写代码时不需要写入什么各种规范，
 * 但随着写代码的深入，时间长了，步入工作就要注意各种规范了，
 * 英语的学习可以说是非常重要的了。很多人多这样说，当然我也是这么
 * 认为的，如果想要有知识上的提升，必然还要学习较先的资源
 * 
 * 8.个人学习链表是感觉最为困难的是对正确建立链表思想的理解，其余的像查插删改，
 * 只要能够建立建立链表的思想，其实还是很容易的。
 * 
 * 
 * ==============================================================
 * bug：对于借鉴别人实现的get与geti还存在一些问题不知道问什么，感觉两种方法都是一样的，
 * 给出了能够正确执行的方法。
 */
public class MyLinkedList<E> {
    
    private class Node{
        public E e ;
        public Node next ;
        
        public Node(E e , Node next) {
            this.e = e ;
            this.next = next ;
        }
        
        public Node(E e) {
            this(e, null) ;
         }
        
        public Node() {
            this(null, null) ;
        }
        
        @Override
        public String toString() {
            return e.toString() ;
        }
        
    }
//使用虚拟头结点可以方便链表的操作    
    private Node dummyHead ;
    private int size ;
    
    public MyLinkedList() {
        dummyHead = new Node(null , null) ;
        size = 0 ;
    }
    
    //获取元素的个数
    public int getSize() {
        return size ;
    }
    
    //返回链表是否为空
    public boolean isEmpty() {
        return size ==  0 ;
    }
    
    //在中间进行元素的插入
    //插入元素索引的位置为pos
    public void add(int pos , E e) {
        if(pos < 0 || pos > size) {
            throw new IllegalArgumentException("位置异常") ;
        }
        Node node = new Node(e) ;
        Node pre = dummyHead ;

        for(int i = 0 ;  i < pos ; i ++) {
            pre = pre.next ;
        }
        node.next = pre.next ;
        pre.next = node ;
        size ++ ;
        
    }
    
    public void addFirst(E num) {

        add(0 , num) ;
    }
    public void addLast(E e) {
        add(size , e) ;
    }
    //使用递归方法进行输出
/**    
    public void out() {
        output(head) ;
    }
    //使用递归进行输出1
    public void output(Node o) {
        if(o == null) {
            return ;
        } else {
            System.out.println(o.e);
            o = o.next ;
            output(o) ;
        }
    }
    */
    
    //使用迭代进行输出
    public void print() {
        Node n = dummyHead ;
        n = n.next ;
        while(n != null) {

            System.out.print(n.e + " ");
            n = n.next ;
        }
    }
//方法1    
    public E get(int index) {
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("NULL Exception") ;
        Node cur = dummyHead.next ;
        for(int  i = 0 ; i < index; i ++)
            cur = cur.next ;
        return cur.e ;
    }
//方法2
//    public E get(int index) {
//        Node prev = dummyHead.next ;
//        return geti(prev , index) ;
//    }
//    //获得链表中第index个元素
//    public E geti(Node prev,int index) {
//
//        for(int i =0 ; i < index ; i ++) {
//            prev = prev.next ;
//        }
//        return prev.e ;
//    }
    
    public E getFirst() {
        return get(0) ;
    }
    
    public E getLast() {
        return get(size - 1) ;
    }
    
    public void set(int index ,E num) {
        Node cur = dummyHead.next ;
        for(int i = 0  ; i < index ; i ++) {
            cur = cur.next ;
        } 
        cur.e = num ;
    }
    
    public boolean contains(E e) {
        Node node = dummyHead.next ;
        while(node != null) {
            if(node.e.equals(e))
                return true ;
            node = node.next ;
        }
        return false ;
    }
    //从链表中删除index位置的元素，并返回删除的值
    public E remove(int index) {
        Node prev ;
        prev = dummyHead.next ;
        for(int i = 0 ; i < index - 1 ;i ++) {
            prev = prev.next ;
        }
        Node delNode = prev.next ;
        prev.next = delNode.next ;
        delNode.next = null ;
        size -- ;
        return delNode.e ;
    }
//    public E delete(int index) {
//        Node delNode ;
//        Node prev = dummyHead.next ;
//        for(int i = 0 ; i < index - 1; i ++) {
//            
//            prev = prev.next ;
//        }
//        
//        delNode = prev.next ;
        prev = delNode.next ;
        delNode.next  = null ;
//
//        prev.next = delNode.next ;
//
//        size -- ;
//        return delNode.e ;
//    }
//    retNode.next = null ;
//    Node retNode = prev.next ;        
    
    
    public static void main(String[] args) {
        MyLinkedList<Integer> list = new MyLinkedList<Integer>() ;
        list.addLast(1);
        list.addLast(2);
        list.addLast(3);
        list.addLast(4);
        list.addLast(5);//12345
        list.add(2, 1111);//
        list.set(2, 5555);
        for(int i = 0 ; i < list.getSize() ; i ++) {
            System.out.print("使用索引进行输出：") ;
            System.out.println(list.get(i));
        }
        System.out.println("================================");
        list.remove(1);
        for(int i = 0 ; i < list.getSize() ; i ++) {
            System.out.print("使用索引进行输出：") ;
            System.out.println(list.get(i));
        }
        System.out.println("output==========================");
        System.out.println(list.get(0));
        System.out.println(list.getSize() - 1);
    }
}