算法学习之七：链表

链表的概念：

链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

链表有单链表和双端链表

代码实现单链表：

//先设计一个单链表的数据结构
public class SingleLink {
    public int data;
    public  SingleLink next;

    public SingleLink(int data){
        this.data = data;
    }

    public void displaySingleLink(){
        System.out.println("linkdata="+data);
    }
}


/**
 * Created by Administrator on 2018/3/26.
 * 这个是链表的集合
 */
public class SingleLinkList {
    private SingleLink first;

    public SingleLinkList(){
        first = null;
    }

    public void insertFirst(SingleLink newLink){
        if(first==null){//说明是第一次插入元素,集合中都是空的
            first = newLink;
            newLink.next = null;
        }else{//已经有插入的元素了，新元素要作为第一元素插入
            newLink.next = first;//先把first的元素保存下来
            first = newLink;//第一个元素的位置放置插入来的元素
        }
    }

    public boolean isEmpty(){
        return first==null;
    }

    //获取删除的那个节点
    public SingleLink deleteFirst(){
        if(first==null){
            return null;
        }
        SingleLink current = first;
        //指针往下移动
        first = first.next;
        return current;
    }

    public void displayList(){
        SingleLink current = first;//指针指向first
        while (current!=null){
            current.displaySingleLink();
            current = current.next;
        }
    }

}


 //删除指定元素
    public SingleLink deleteLink(int data) {
        SingleLink current = first;
        SingleLink previous = first;
        if(current==null){
            return null;
        }
        while(current.data!=data){//没有遍历到
            previous = current;
            current =current.next;
            if(current==null){
                return null;
            }
        }

        //处理循环完毕之后的结果：
        if(current==null){
            return null;
        }else{
            if(current==first){//说明就是第一个元素：那就把第一元素去掉
                first = first.next;
            }else{//current 不是第一个元素：
                previous.next = current.next;
            }
            return current;
        }
    }

 /**
     * 查找某个Link
     *
     * @param data
     * @return
     */
    public SingleLink finkLink(int data) {
        if (first == null) {
            return null;
        }
        SingleLink current = first;
        while (current != null) {
            if (current.data == data) {
                break;
            }
            current = current.next;
        }

        return current;
    }

现在来看插入元素的结果显示：每当有一个元素插入进来，都要是放在第一位的，那么这次的结果应该是：5《-4《-3《-2《-1

public static void  main(String[] args){

        SingleLinkList linkList = new SingleLinkList();
        SingleLink link1  = new SingleLink(1);
        SingleLink link2  = new SingleLink(2);
        SingleLink link3  = new SingleLink(3);
        SingleLink link4  = new SingleLink(4);
        SingleLink link5   = new SingleLink(5);
        linkList.insertFirst(link1);
        linkList.insertFirst(link2);
        linkList.insertFirst(link3);
        linkList.insertFirst(link4);
        linkList.insertFirst(link5);
        linkList.displayList();
    }

//再来做删除的操作：

       //删除第第一个元素：
        SingleLink link = linkList.deleteFirst();
        System.out.println("打印删除的元素：");
        link.displaySingleLink();
        System.out.println("删除之后的元素打印：");
        linkList.displayList();

至此，单链表的练习就到此结束。

代码实现双端链表：

现在再介绍一个双端链表：和单链表的不同是，有一个指针会始终指向最后一个元素：

//设计双链表的数据结构
public class DoubleLinkList {

    private SingleLink first;
    private SingleLink last;

    public DoubleLinkList(){
        first = last = null;
    }


    /**
     * 总是往前面插入元素
     */
    public void insertFirst(SingleLink newLink){
        if(first==null){//说明list是空的,last永远是指向第一个节点
            first = last =newLink;
        }else{//list中已经有元素了
            newLink.next = first;
            first = newLink;
        }
    }

    /**
     * 总是往后面插入元素，需要注意最后一个元素永远要指向第一个
     * @param newLink
     */
    public void insertLast(SingleLink newLink){
        if(first==null){
            first = last =newLink;
        }else{//已经有元素的情况下：从last往前插入
            last.next = newLink;
        }

        last = newLink;//将last的指针往后移动
    }


    /**
     * 删除第一个元素
     * @return
     */
    public SingleLink deleteFirst(){
        if(first ==null){
            return null;
        }
        //在有元素的情况下，删除第一个元素
        SingleLink current = first;
        first = first.next;
        return current;
    }


    /**
     * 删除最后一个元素。
     * @return
     */
    public void deleteLast(){
        if(first ==null){//一个元素都没有
            return;
        }else if(first.next==null){//只有一个元素
            first = null;
            last = null;
        }else{//采用遍历的方式：遍历到最后一个元素
            SingleLink current = first;
            while(current.next!=null){
                if(current.next==last){//如果已经查找到最后一个元素
                    last = current;
                    last.next = null;
                    break;
                }
                current = current.next;
            }

        }
    }

    public void displayList() {
        SingleLink current = first;//指针指向first
        while (current != null) {
            current.displaySingleLink();
            current = current.next;
        }
    }

    public void displayLast(){
        if(first==null){
            System.out.println("list 为空");
        }else{
            last.displaySingleLink();
        }

    }

再来验证设计的数据结构：

 public static void main(String[] args) {

        DoubleLinkList linkList = new DoubleLinkList();
        linkList.insertFirst(new SingleLink(1));
        linkList.insertFirst(new SingleLink(2));
        linkList.insertFirst(new SingleLink(3));
        linkList.insertFirst(new SingleLink(4));
        linkList.insertFirst(new SingleLink(5));

        linkList.displayList();
        linkList.displayLast();

    }

数据最后插入的排放在最前面并且知道最后一个元素就是第一个插入的元素

再来看混合插入和删除：
 public static void main(String[] args) {
         DoubleLinkList linkList = new DoubleLinkList();
        linkList.insertLast(new SingleLink(1));
        linkList.insertLast(new SingleLink(2));
        linkList.insertLast(new SingleLink(3));
        linkList.insertLast(new SingleLink(4));
        linkList.insertFirst(new SingleLink(6));
        linkList.insertLast(new SingleLink(5));

        System.out.println("删除之前的集合元素是：");
        linkList.displayList();

        System.out.println("删除之后的集合元素是：");
        linkList.deleteLast();
        linkList.displayList();

        System.out.println("最后一个元素：");
        linkList.displayLast();
}

再次查看结果：