数据结构之链表

单链表学习

学习第一步：定义存放链表结点的类Node,类中包含两个字段：data字段和next字段，data字段是结点中的数值域，next是指向链表下一个结点的引用

　　　　　　

//存放单链表节点
class Node {
    private int data;
    private Node next;

    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public void displayNode() {
        System.out.println("data:" + data);
    }

}

学习第二步：学习单链表的一些操作，插入、删除、查找结点

// 单链表的一些操作
class LinkList {
    private Node head;

    public LinkList() {
        head = null;
    }

    // 链表的头部插入元素
    public void insertNode(int data) {
        Node newNode = new Node(data, null);
        newNode.setNext(head);
        head = newNode;
    }

    // 从链表的头部删除元素
    public Node deleteNode() {
        Node tempNode = head;
        head = head.getNext();
        return tempNode;
    }

    // 打印链表中的结点的数值域的值
    public void displayList() {
        Node currentLinkList = head;
        while (currentLinkList != null) {
            currentLinkList.displayNode();
            currentLinkList = currentLinkList.getNext();
        }
    }

    // 判断单链表是否为空
    public boolean isEmpty() {
        return head == null;
    }

    // 单链表查询是否有关键字为key的结点
    public Node find(int key) {
        Node current = head;
        while (current.getData() != key) {
            if (current.getNext() == null) {
                return null;
            }
            current = current.getNext();
        }
        return current;

    }

    // 单链表中删除指定关键字的结点
    public Node delete(int key) {
        // preNode要删除的结点的前一个结点
        Node preNode = head;
        // 标记要删除的结点
        Node current = head;
        while (current.getData() != key) {
            if (current == null) {
                return null;
            } else {
                preNode = current;
                current = current.getNext();
            }
        }
        // 要删除的是头head指向的结点
        if (current == head) {
            head = head.getNext();
        }
        // 删除结点，preNode指向删除结点的后继结点
        else {
            preNode.setNext(current.getNext());
        }
        return current;

    }
}

双端链表学习

可以看到我们上面的操作，在链表尾插入、删除结点的操作，虽然也可以做，但是需要从头遍历到尾部，这种方法的效率有点低，双端链表可以解决这个问题。双端链表循序我们跟操作链表头一样去操作链表尾，使得在一些特殊情况下，链表的操作更加便利。其实就是加了一个tail引用，指向链表的最后一个结点。

　　　　　　　               　

我们在将结点顺序插入到链表中

public void insertAtTail(int data) {
        Node newNode = new Node(data, null);
        tail.setNext(newNode);
        tail = newNode;
        size++;
    }

但不幸的是双端链表也不能有助于删除最后一个链结点，因为没有一个引用指向倒数第二个链结点。如果最后一个链结点被删除，倒数第二个链结点的next字段应该变为null值，为了方便进行这一操作，我们此刻就需要双向链表，稍后介绍。
链表和数组的区别：

二者都属于一种数据结构

从逻辑结构来看

1. 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费；数组可以根据下标直接存取。

2. 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项，非常繁琐）链表必须根据next指针找到
   下一个元素

   从内存存储来看

1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小

2. 链表从堆中分配空间, 自由度大但是申请管理比较麻烦 


从上面的比较可以看出，如果需要快速访问数据，很少或不插入和删除元素，就应该用数组；相反，如果需要经常插入和删除元素就需要用链表数据结构了。

双端链表的一个实际应用：模拟队列

  定义存储结点的Node类

public class Node {

    public  int data;
    public Node next;
    public Node(int data,Node next){
        this.data=data;
        this.next=next;
    }
}

定义链表操作

public class LinkList {

    private Node head;
    private Node tail;
    public LinkList(){
        head=null;
        tail=null;
    }
    public void insertLast(int data){
        Node newNode=new Node(data, null);
        if(isEmpty()){
            head=newNode;
        }
        else {
            tail.next=newNode;
        }
        tail=newNode;
    }
    public int deleteHead(){
        if(head.next==null){
            tail=null;
            return head.data;
        }
        if(head!=null){
            
            Node tempNode=head;
            head=head.next;
            return tempNode.data;
        }
        else {
            throw new RuntimeException("不能删除元素了");
        }
    }
    public boolean isEmpty(){
        return head==null;
    }
    
}

链表模拟队列

//用的是insertLast()和deleteHead()方法，即在尾部插入，在链表头删除
public class LinkQueue {

    private LinkList linkList;
    public LinkQueue(){
        linkList=new LinkList();
    }
    public void push(int data){
        linkList.insertLast(data);
    }
    public int pop(){
        return linkList.deleteHead();
    }
    public boolean isEmpty(){
        return linkList.isEmpty();
    }
}

测试类

public class QueuqTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        LinkQueue linkQueue=new LinkQueue();
        linkQueue.push(10);
        linkQueue.push(20);
        linkQueue.push(30);
        linkQueue.push(40);
        System.out.println(linkQueue.pop());
    }
}

有序链表学习

有序链表的结点插入和普通链表不同，其他操作相同，我们这里只给出往有序链表中插入结点的操作，有序列表适合用于需要频繁操作最值(最大或最小),而又不要求快速插入的场合

public void insert2SortLink(int data) {
        Node newNode = new Node(data, null);
        Node preNode = null;
        Node currenNode = head;
        //一直往后查找结点的插入位置直到链表结束或者data不大于currentNode.data
        //while循环结束，结点的插入位置可能为表头、表尾、表中间的某个位置，或者链表是空表
        while (currenNode != null && data > currenNode.data) {
            preNode = currenNode;
            currenNode = currenNode.next;
        }
        //插入点的前一个结点preNode指向结点=null，表明插入点在表头或者表是空表
        if (preNode == null) {
            head=newNode;
        }
        //插入点在表中间或者在表的尾部
        else {
            preNode.next=newNode;
        }
        //无论插入点在哪一个位置，新插入的结点的next域都指向currentNode
        newNode.next=currenNode;
    }

有序链表的一个应用：表插入排序

有序链表可以用于一种高效的排序机制。假设有一个无序的数组，如果从这个数组中取出数据，然后一个一个地插入到有序链表，他们自动的按顺序排序。把他们从有序链表中取出再放到数组中，那么数组就排好顺序了

表插入排序的效率：插入N个数据，就进行了n^2/2次比较，但移动仅进行了2*N次，效率，相对于简单排序中的插入排序的O(n2)，还是要效率高一些的。

具体代码实现：

(1)Node类:

public class Node {

    public  int data;
    public Node next;
    public Node(int data,Node next){
        this.data=data;
        this.next=next;
    }
    //显示每个结点的信息
    public void displayNode(){
        System.out.print("data:"+data+" ");
    }
}

(2)SortList类

class SortList {
    private Node head;

    public SortList() {
        head = null;
    }

    public SortList(Node[] nodes) {
        head = null;
        for (int j = 0; j < nodes.length; j++) {
            insert2SortLink(nodes[j]);
        }
    }

    public void insert2SortLink(Node newNode) {
        // Node thenewNode = newNode;
        Node preNode = null;
        Node currenNode = head;
        // 一直往后查找结点的插入位置直到链表结束或者data不大于currentNode.data
        // while循环结束，结点的插入位置可能为表头、表尾、表中间的某个位置，或者链表是空表
        while (currenNode != null && newNode.data > currenNode.data) {
            preNode = currenNode;
            currenNode = currenNode.next;
        }
        // 插入点的前一个结点preNode指向结点=null，表明插入点在表头或者表是空表
        if (preNode == null) {
            head = newNode;
        }
        // 插入点在表中间或者在表的尾部
        else {
            preNode.next = newNode;
        }
        // 无论插入点在哪一个位置，新插入的结点的next域都指向currentNode
        newNode.next = currenNode;
    }

    public Node deleteHead() {
        if (!isEmpty()) {
            Node tempNode = head;
            head = head.next;
            return tempNode;
        } else {
            throw new RuntimeException("不能删除元素了");
        }
    }

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

(3)测试类

public class SortedListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        Node nodeArray[] = new Node[10];
        int n;
        for (int j = 0; j < nodeArray.length; j++) {
            n = (int) (Math.random() * 99);
            Node newNode = new Node(n, null);
            nodeArray[j] = newNode;
        }
        System.out.println("--------Unsorted Array--------");
        for (int j = 0; j < nodeArray.length; j++) {
            nodeArray[j].displayNode();
        }
        System.out.println();
        SortList sortList = new SortList(nodeArray);
        System.out.println("--------Sorted Array-------");
        for (int j = 0; j < nodeArray.length; j++) {
            nodeArray[j] = sortList.deleteHead();
            System.out.print(nodeArray[j].data + " ");
        }
        System.out.println("---------结束线----------");

    }

}

学习双向链表

　　　　　　　　　　　　　　　　　　　　　　　　　　

双向链表提供了这样一种能力：允许向前遍历链表，也允许向后遍历链表，秘密在于每个结点存在两个指向其他链结点的引用。

双向链表的缺点：

每次插入或者删除一个结点的时候要处理四个引用，四个引用相对于两个引用，占用空间也变得大了一些，双向链表不必是双端链表，但这种方式(保留对链表最后一个元素的引用)有时候会非常的有用。

具体代码实现：

package LinkListQueue;

class DoubleLinkList {
    class Node {
        private int data;
        private Node next = null;
        private Node previous = null;

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

    private Node head = null;
    private Node tail = null;

    // 在双向链表的头部插入
    public void insertHead(int data) {
        Node newNode = new Node(data);
        // 判断链表是否为空,可以重新组织一下代码，把if-else都要执行的head=newNode这条语句移动到else代码块后面
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.next = head;
            head.previous = newNode;
            head = newNode;
        }
        // LOOP:就是这个位置
    }

    // 在双向链表的尾部插入
    public void insertTail(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            tail.next = newNode;
            newNode.previous = tail;
        }
        tail = newNode;
    }

    // 在链表的内部的某个位置的后面插入元素,我們假定链表非空
    public boolean insertAfter(int target, int data) {
        Node newNode = new Node(data);
        Node current = head;
        while (current.data != target) {
            current=current.next;
    }
            if (current == tail) {
                newNode.next=null;
                tail=newNode;
            } else {
                newNode.next=current.next;
                current.next.previous = newNode;
            }
            current.next = newNode;
            newNode.previous=current;
        return true;
}

    // 在链表的头部进行删除
    public Node deleteHead() {
        if (head == null) {
            throw new RuntimeException("不能删除节点了");
        }
        Node tmpNode = head;
        if (head.next == null) {
            head = null;
            tail = null;
        } else {
            head.next.previous = null;
            head = head.next;
        }
        return tmpNode;
    }

    // 在链表的尾部进行删除
    public void  deleteTail() {
        if (head == null) {
            throw new RuntimeException("不能删除节点了");
        }
        Node tmpNode = tail;
        //如果只有一个元素
        if (head.next == null) {
            head = null;
            tail = null;
        } else {
            tail.previous.next = null;
            tail = tail.previous;
        }
    }

    // 在链表的内部的某个位置删除指定关键字的结点元素
    public Node deleteKey(int target) {
        // 链表为空表,不能删除
        if (head == null) {
            throw new RuntimeException("不能删除元素");
        }
        Node current = head;
        while (current.data != target) {
            current = current.next;
            if (current == null) {
                return null;
            }
        }
        // 最关键的理解点，有点绕，引用变化：删除结点的前一个结点的next->删除结点的后一个结点
        // 删除结点的后一个结点的previous->删除结点的前一个结点
        if (current == head) {
            head = current.next;
        } else {
            current.previous.next = current.next;
        }
        if (current == tail) {
            tail = current.previous;
        } else {
            current.next.previous = current.previous;
        }
        return current;
    }

    public void displayList() {
        System.out.println("Head-->Tail");
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current=current.next;
        }
        System.out.println();
    }
}

public class DouLinkListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        DoubleLinkList dll = new DoubleLinkList();
        dll.insertHead(1);
        dll.insertTail(3);
        dll.insertAfter(1, 2);
        dll.insertAfter(3, 4);
        dll.insertAfter(4, 5);
        dll.displayList();
        dll.deleteHead();
        dll.displayList();
        dll.deleteTail();
        dll.displayList();
        dll.deleteKey(3);
        dll.displayList();
        dll.deleteKey(2);
        dll.displayList();
    }

}