链表实现

单链表

package com.zhuang.lianbian;

public class Node {
    public Node next=null; //默认新加的结点指针为null
    public int data;
    public Node(int data){
        this.data=data;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "这个节点数据为：" +this.data;
    }
}

package com.zhuang.lianbian;

public class LinkedList {

    Node head =null; //表头的引用

    /*
     * 添加节点，默认在最后添加
     */
    public void addNode(int data){
        Node node = new Node(data);
        if(head==null){
            head=node;
            return;
        }
        Node temp = head;
        while(temp.next!=null){
            temp=temp.next;
        }
        temp.next=node;
    }

    /*
     * 计算长度
     */
    public int length(){
        int length = 0;
        Node temp = head;
        while(temp != null){
            length++;
            temp = temp.next;
        }
        return length;
    }

    /*
     * 删除指定位置的节点,成功返回true，失败返回false
     */
    public boolean deleteNode(int index){
        if(index < 1 && index > length()){
            return false;
        }
        if(index == 1){
            head = head.next;
            return true;
        }

        int i = 2;
        Node preNode = head; 
        Node curNode = preNode.next;
        while(curNode != null){
            if(index == i){
                preNode.next = curNode.next;
                return true;
            }
            preNode = curNode;
            curNode = curNode.next;
            i++;
        }
        return true;
    }

    /*
     * 输出链表
     */
    public void printList(){
        Node temp = head;
        System.out.print("链表顺序为：");
        while(temp != null){
            System.out.print(temp.data + "、");
            temp = temp.next;
        } 
    }

    /*
     * 对链表排序,并返回头节点
     */
    public Node orderList(){
        Node curNode = head;
        int temp;
        while(curNode != null){
            Node nextNode = curNode.next;
            while(nextNode != null){
                if(curNode.data > nextNode.data){
                    temp = curNode.data;
                    curNode.data = nextNode.data;
                    nextNode.data = temp;               
                }
                nextNode = nextNode.next;
            }
            curNode = curNode.next;
        }

        return head;
    }

    /*
     * 在指定位置加入节点,成功返回true
     */
    public boolean addNode(int index , int data){
        if(index < 1 && index > length()){
            return false;
        }
        Node insertNode = new Node(data);

        if(index == 1){
            insertNode.next = head;
            head = insertNode;

            return true;
        }
        Node preNode = head;
        Node curNode = head.next;
        int i = 2;
        while(curNode != null){
            if(i == index){
                preNode.next = insertNode;
                insertNode.next = curNode;
                return true;
            }
            preNode = curNode;
            curNode = curNode.next;
            i++;        
        }
        return true;
    }

    /*
     * 删除重复节点
     */
    public void deleteDuplecate(Node head){
        Node p = head;
        while(p != null){
            Node q = p;
            while(q.next != null){
                if(p.data == q.next.data){
                    q.next = q.next.next;
                }else
                    q=q.next;
            }
            p = p.next;
        }

    }

    /*
     * 找到倒数第K个数据
     */
    public Node findRevK(Node head,int k){
        if(k<1 || k > length()){
            return null;
        }
        Node p = head;
        Node q = head;
        for(int i=0;i<k-1;i++){
            q = q.next;
        }
        while(q.next != null){
            p = p.next;
            q = q.next;
        }
        return p;
    }

    /*
     * 找到中间位置的节点
     */
    public Node findMedia(Node head){
        Node fast = head;
        Node slow = head;
        while(fast != null && fast.next!=null&&fast.next.next!=null){
            fast = fast.next.next;
            slow = slow.next;           
        }
        return slow;
    }

    /*
     * 判段是否有环
     */
    public boolean isLoop(Node head){
        Node fast = head;
        Node slow = head;

        if(fast == null){
            return false; 
        }
        while(fast != null && fast.next != null ){
            fast = fast.next.next;  //走两步
            slow = slow.next;  //走一步
            if(fast == slow){
                return true;
            }
        }
        return !(fast==null || fast.next == null );
    }

    /*
     * 找到链表的环入口
     */
    public Node findLoopPort(Node head){
        Node slow = head;
        Node fast = head;
        if(slow == null){
            return null;
        }

        while(fast != null && fast.next != null){
            slow = slow .next;
            fast = fast.next.next;
            if(slow == fast){ //第一次相遇
                //求环的长度
                Node firstMeet = slow;
                int LoopLength = 1;
                while(firstMeet.next != slow){
                    firstMeet = firstMeet.next;
                    LoopLength++;
                }
                //求第一个入口点
                slow = head;
                fast = head;
                for(int i = 0;i < LoopLength;i++){
                    fast = fast.next;
                }
                while(slow != fast){
                    slow = slow.next;
                    fast = fast.next;
                }
                return slow;
            }
        }   

        return null;
    }



}

双链表

/**
 * Java 实现的双向链表。 
 */
public class DoubleLink<T> {

    // 表头
    private DNode<T> mHead;
    // 节点个数
    private int mCount;

    // 双向链表“节点”对应的结构体
    private class DNode<T> {
        public DNode prev;
        public DNode next;
        public T value;

        public DNode(T value) {
            this.value = value;
        }
    }

    // 构造函数
    public DoubleLink() {
        // 创建“表头”。注意：表头没有存储数据！
        mHead = new DNode<T>(null);
        mHead.prev = mHead.next = mHead;
        // 初始化“节点个数”为0
        mCount = 0;
    }

    // 返回节点数目
    public int size() {
        return mCount;
    }

    // 返回链表是否为空
    public boolean isEmpty() {
        return mCount==0;
    }

    // 获取第index位置的节点
    private DNode<T> getNode(int index) {
        if (index<0 || index>=mCount)
            throw new IndexOutOfBoundsException();

        // 正向查找
        if (index <= mCount/2) {
            DNode<T> node = mHead.next;
            for (int i=0; i<index; i++)
                node = node.next;

            return node;
        }

        // 反向查找
        DNode<T> rnode = mHead.prev;
        int rindex = mCount - index -1;
        for (int j=0; j<rindex; j++)
            rnode = rnode.prev;

        return rnode;
    }

    // 获取第index位置的节点的值
    public T get(int index) {
        return getNode(index).value;
    }

    // 获取第1个节点的值
    public T getFirst() {
        return getNode(0).value;
    }

    // 获取最后一个节点的值
    public T getLast() {
        return getNode(mCount-1).value;
    }

    // 将节点插入到第index位置之前
    public void insert(int index, T t) {
        if (index==0) {
            DNode<T> node = new DNode<T>(t);
            //以箭头方向赋值，先搞定插入节点的前驱和后记，最后一步才是前节点的后继
            node.next = mHead.next;
            node.prev = mHead;
            mHead.next.prev = node;
            mHead.next = node;

            mCount++;
            return ;
        }

        DNode<T> inode = getNode(index);
        DNode<T> tnode = new DNode<T>(t);
        tnode.next = inode.next;
        tnode.prev = inode;
        inode.next.prev = tnode;
        inode.next = tnode;
        mCount++;
        return ;
    }

    // 将节点插入第一个节点处。
    public void insertFirst(T t) {
        insert(0, t);
    }

    // 将节点追加到链表的末尾
    public void appendLast(T t) {
        DNode<T> node = new DNode<T>(t);
        node.next = mHead;
        node.prev = mHead.prev;
        mHead.next = node;
        mHead.prev.next = node;
        mCount++;
    }

    // 删除index位置的节点
    public void del(int index) {
        DNode<T> inode = getNode(index);
        inode.prev.next = inode.next;
        inode.next.prev = inode.prev;
        inode = null;
        mCount--;
    }

    // 删除第一个节点
    public void deleteFirst() {
        del(0);
    }

    // 删除最后一个节点
    public void deleteLast() {
        del(mCount-1);
    }
}