JAVA之链表源码

    class TLinkNode<T extends Comparable<T>>{
        int size = 0;
        TNode<T> root = null;
        TNode<T> reverseRoot = null;
        TNode<T> reverseRootStack = null;

        //查找链表中的结点
        public TNode<T> findNode(T data){
            TNode<T> p = root;
            while(p != null){
                if (p.getData() == data){
                    return p;
                }
                else{
                    p = p.getTail();
                }
            }
            return null;
        }

        //返回根结点
        public TNode<T> findRoot(){
            return root;
        }

        //返回使用递归反转后的根结点
        public TNode<T> findReverseRoot(){
            return reverseRoot;
        }

        //返回使用栈反转结点的根结点
        public TNode<T> findReverseStackRoot(){
            return reverseRootStack;
        }

        //链表使用栈进行反转（非循环链表）
        public void ReverseRootStack(TNode<T> node) {
            TNode<T> p = node;
            Stack<TNode<T>> stack = new Stack<TNode<T>>();
            while(p != null){
                stack.push(p);
                p = p.getTail();
            }
            while (!stack.isEmpty()){
                TNode<T> t = stack.pop();
                t.setHead(null);
                t.setTail(null);
                if (reverseRootStack == null){
                    reverseRootStack = t;
                }
                else{
                    if (reverseRootStack.getTail() == null){
                        reverseRootStack.setTail(t);
                        t.setHead(reverseRootStack);
                    }
                    else{
                        TNode<T> tt = null;
                        TNode<T> pp = reverseRootStack;
                        while(pp != null){
                            tt = pp;
                            pp = pp.getTail();
                        }

                        tt.setTail(t);
                        t.setHead(tt);
                    }
                }
            }
        }

        //链表使用递归的方式进行反转（非循环链表）
        public void printNodeDesc(TNode<T> node){
            int count = 0;
            TNode<T> p = node;
            TNode<T> t = null;
            TNode<T> tt = null;
            while (p != null){
                t = p;
                p = p.getTail();
                count++;
            }
            if (count == 0) {
                return;
            }
            if (reverseRoot == null) {
                t.getHead().setTail(null);
                t.setHead(null);

                reverseRoot = t;
            }
            else{
                if (reverseRoot.getTail() == null){
                    t.getHead().setTail(null);
                    t.setHead(null);
                    reverseRoot.setTail(t);
                    t.setHead(reverseRoot);
                }
                else{
                    TNode<T> pp = reverseRoot;
                    while (pp != null){
                        tt = pp;
                        pp = pp.getTail();
                    }

                    if (t.getHead() != null) {
                        t.getHead().setTail(null);
                    }
                    else{
                        node = null;
                    }
                    t.setHead(null);
                    tt.setTail(t);
                    t.setHead(tt);
                }
            }
            printNodeDesc(node);
        }

        //打印链表中的每个结点
        public void printNode(TNode<T> node){
            TNode<T> p = node;
            if (p != null){
                //顺序输出
                System.out.println("=== p.data ==>> " + p.getData() + ", p.head ==>> " + p.getHead() + ", p.tail ==>> " + p.getTail() + ", size ==>> " + size);

                printNode(p.getTail());
                //逆序输出
                /*
                System.out.println("=== p.data ==>> " + p.getData() + ", p.head ==>> " + p.getHead() + ", p.tail ==>> " + p.getTail() + ", size ==>> " + size);
                */
            }
        }
        //判断链表中是否有循环结点
        public T findCircle(TNode<T> node){
            TNode<T> p = node;
            TNode<T> t = node;
            while (p.getTail() != null){
                p = p.getTail();
                if (t.getTail().getTail() != null) {
                    t = t.getTail().getTail();
                }
                else{
                    return null;
                }

                if (p == t){
                    System.out.println("=== p.getData ==>> " + p.getData());
                    return p.getData();
                }
            }
            return null;
        }

        //查找链表中的循环起点
        public TNode<T> findCircleData(TNode<T> node){
            TNode<T> p = node;
            List<TNode<T>> list = new ArrayList<>();
            while (p != null){
                list.add(p);
                for (int i = 0; i < list.size(); i ++){
                    if (list.get(i) == p.getTail()){
                        System.out.println("=== p.getTail.getData ==>> " + p.getTail().getData());
                        return p.getTail();
                    }
                }
                p = p.getTail();
            }
            return null;
        }

        /**
          * 向链表中放入数据，此处只在链表尾端放入数据;
          * 往链表头和链表中间插入数据逻辑都差不多，都是先查找到需要放入数据的结点,再改变新增数据前后的结点指针的指向；
          * @param data
          * @return
          */
        public boolean putData(T data){
            size ++;
            TNode<T> node = root;
            if(node == null){
                //新建头节点，将第一个插入进来的数据作为链表的头结点
                node = new TNode<T>(data, null, null);
                root = node;
            }
            else{
                TNode<T> p = node;
                TNode<T> t = node;
                while(p != null){
                    t = p;
                    p = p.getTail();
                }

                TNode<T> newData = new TNode<T>(data, null, null);
                t.setTail(newData);
                newData.setHead(t);

                /**
                  * 以下代码是将链表设置为循环链表，作测试使用
                  */
                /*
                TNode<T> pp = root;
                if(size == 10){
                    while (pp != null){
                        if (pp.getData() == "banana"){
                            newData.setTail(pp);
                            break;
                        }
                        pp = pp.getTail();
                    }
                }
                */
            }
            return true;
        }

        //从链表中更新结点
        public boolean upData(T data, T newData){
            TNode<T> node = root;
            while(node != null){
                if (node.getData() == data){
                    node.setData(newData);
                    return true;
                }
                node = node.getTail();
            }
            return false;
        }
        //从链表中删除结点
        public boolean delData(T data){
            TNode<T> node = root;
            while(node != null){
                if (node.getData() == data){
                    size --;
                    if (node == root){
                        if (node.getTail() != null){
                            root = node.getTail();
                        }
                        else{
                            root = null;
                        }
                    }
                    else{
                        //删除node结点
                        node.getHead().setTail(node.getTail());
                        node.getTail().setHead(node.getHead());
                    }
                    node.setHead(null);
                    node.setTail(null);
                    return true;
                }
                node = node.getTail();
            }
            return false;
        }
    }

    //结点类
    class TNode<T extends Comparable<T>>{
        private T data;    //结点存储的数据
        private TNode<T> head;   //结点头指针
        private TNode<T> tail;   //结点尾指针
        public TNode(T data, TNode<T> head, TNode<T> tail){
            this.data = data;
            this.head = head;
            this.tail = tail;
        }
        public void setData(T data) {  this.data = data;  }
        public void setHead(TNode<T> head){  this.head = head;  }
        public void setTail(TNode<T> tail){  this.tail = tail;  }
        public T getData(){  return this.data;  }
        public TNode<T> getHead(){ return this.head;  }
        public TNode<T> getTail(){  return this.tail; }
    }