数据结构之链表

链表数据结构结点：

package list;

/**
 * @packagname:PACKAGE_NAME
 * @classname:LinkedNode
 * @date:2017/1/22
 * @author:cullinans
 * @des:链表的结点结构
 */

public class LinkedNode <T>{
    T data;//数据
    LinkedNode<T> next;//下一个结点的引用
}

利用工厂设计模式来生成链表结点实例对象：

package list;

/**
 * @packagname:PACKAGE_NAME
 * @classname:NodeFactory
 * @date:2017/1/22
 * @author:cullinans
 * @des:生成结点的工厂类
 */

public class NodeFactory {
    public static LinkedNode createLinkedNode(){
        return new LinkedNode();
    }
}

列表的一些相关操作：（以下代码在Intellij Idea 2016编译通过，可以通过以下注释的一些打印语句来验证方法的正确性）

package list;

/**
 * @packagname:PACKAGE_NAME
 * @classname:IntLinkedList
 * @date:2017/1/22
 * @author:cullinans
 * @des:
 */

public class TestLinkedList<T> {
    LinkedNode node = null;//定义一个结点指向空
    public TestLinkedList(LinkedNode node) {//初始化头结点
        this.node = node;
        node.next=null;
    }


    //=========创建链表===============
    public String createLinkedList(TestLinkedList l, int i,T[] data) {
        LinkedNode<T> tempnode=l.node;//定义一个变量，指向链表的头结点
        for(int j=0;j<i;j++){
            LinkedNode newnode = NodeFactory.createLinkedNode();//创建一个结点
            newnode.data=data[j];//给结点的数据赋值
            tempnode.next=newnode;//新结点赋值给原结点的引用
            tempnode=newnode;//将引用指向第二个结点
        }
        return "创建完毕";
    }

//========获取列表元素=======
    public T getElem(TestLinkedList l, int i) {
        if(i<0){//小于0个位置
            return null;
        }
        LinkedNode<T> p=l.node;//定义一个结点，指向链表的第一个结点
        int j=0;
        while(p!=null && j<i){//当j的位置没有移动到i的位置时
            p=p.next;//将当前结点的下一个结点的引用指向当前的引用
            ++j;//移动位置
        }
        if(j==i) {
            return p.data;
        }else{
            return null;
        }
    }


        /*
         ===============插入元素：============
         原理：
            1：如果插入的位置为负数，则表示插入不合法返回-1
        * */
    public int listInsert(TestLinkedList l, LinkedNode<T> t, int i) {
        if(i<0){
            return -1;
        }
        LinkedNode<T> tempPoint=null;//定义一个临时引用
        tempPoint=l.node;//第一个元素引用指向临时引用
        int j=0;//定义一个计数器
        while(tempPoint!=null && j<i){//如果不是最后一个元素，并且结点位置没有到指定位置时循环
            if(j==i-1){//如果移动到i个结点的上一个结点
                t.next=tempPoint.next;//将i-1的下一个结点的引用指向t的下一个引用
                tempPoint.next=t;//将t的引用赋值给当前引用的下一个结点
                break;
            }
                tempPoint = tempPoint.next;//拿到当前结点的下一个结点的引用指向临时引用
                j++;//计数器累加

        }
        if(j==i){
            t.next=tempPoint;
            l.node=t;
            return 0;
        }else{
            return -1;
        }

    }

    /**
     ========删除元素========
     原理分析：
        1：定义一个引用，指向第一个结点的元素
        2：遍历结点，直到遍历到i-1个元素
        3：记录下i-1个元素的下一个结点的引用
        4：获取到下一个结点的下一个结点
     */
    public int listDelete(TestLinkedList l, int i) {
        if(i<0){
            return -1;
        }
        int j=0;
        LinkedNode<T> tempPoint=null;
        tempPoint=l.node;
        while(tempPoint!=null && j<i){
            if(j==i-1){
                tempPoint.next=tempPoint.next.next;
                break;
            }else {
                tempPoint = tempPoint.next;
                j++;
            }
        }
        if(j==i){
            tempPoint=tempPoint.next;
        }
        return 0;
    }
   //============清空链表================
    public int clearList(TestLinkedList l) {
        LinkedNode<T> tempNode;
        tempNode=l.node;//定义一个引用指向链表的头结点
        tempNode.next=null;
        tempNode.data=null;
        return 0;
    }
    //main方法测试
     public static void main(String[] args){
        LinkedNode linkedNode = new LinkedNode();
        linkedNode.data= "one";
        linkedNode.next=null;
        TestLinkedList<String> testLinkedList=new TestLinkedList<String>(linkedNode);
        String[] test=new String[]{"a","b","c"};
        testLinkedList.createLinkedList(testLinkedList,3,test);
        //==========================插入元素=======================
        LinkedNode<String>  insertNode=new LinkedNode<String>();
        insertNode.data="insert";
        insertNode.next=null;
        System.out.println(testLinkedList.listInsert(testLinkedList,insertNode,0));
        //=========================删除元素===========================
       // System.out.println(testLinkedList.clearList(testLinkedList));
       // System.out.println(testLinkedList.listDelete(testLinkedList,0));
        System.out.println(testLinkedList.getElem(testLinkedList,0));
        System.out.println(testLinkedList.getElem(testLinkedList,1));
        System.out.println(testLinkedList.getElem(testLinkedList,2));
       System.out.println(testLinkedList.getElem(testLinkedList,3));

    }
}