链表与顺序表

---

顺序表:

顺序表是用一组地址连续的存储单元来保存数据的，使用之前必须指定其长度，一但内存分配，不可动态改变大小。所以它具有随机存取，查找快速的特点，但是做插入或删除动作是，需要移动大量元素，效率较低。

• 长度固定，必须在分配内存之前确定数组的长度。
• 存储空间连续，即允许元素的随机访问。
• 存储密度大，内存中存储的全部是数据元素。
• 要访问特定元素，可以使用索引访问，时间复杂度为 O(1)。
• 要想在顺序表中插入或删除一个元素，都涉及到之后所有元素的移动，因此时间复杂度为 O(n)。
  
• 顺序表实现主要是是使用数组的扩容实现的，System.arraycopy（）

　　　　　　

链表 :

链表，是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。每个数据结点单元有两部分组成，一个是数据域，存储数据值；另一个是指针域，指向下一个数据单元。

当多个结点通过指针指向，关联起来，就形成了一个链，即链表（java没有指针概念，指针是指对象，即结点）。

链表可分为单链表、双链表、循环链表。

单链表就是沿着单方向的链表。例如a->b->c->d…  只能顺序往下连接下去，即只可以从A往下找元素，但是反之则不行。

对比：

链表是线性表的链式存储结构，它相比于顺序表，在插入和删除元素时，效率要高很多。

数组线性表类ArrayList 和链表类LinkedList 是实现List接口的两个具体类。ArrayList 数组储存元素，这个数组是动态创建的。如果元素个数超过了数组的容量，就创建一个更大的新数组，并将当前所有元素都复制到新数组中。LinkedList在一个链表中储存元素。

如果需要通过下标来随机访问元素，但是除了在末尾处之外，不能在其他位置插入或删除元素，那么使用ArrayList更高效。

需要在线性表任意位置上插入或删除元素，就应该选择LinkedList。线性表的大小可动态增大或减小，但数组一旦被创建，大小就是固定的。如不需要在线性表中插入或删除元素，那么数组是效率最高的数据结构。

ArrayList是一个实现List接口的大小可变的数组，向ArrayList中添加元素，容量自动增大，但不能自动减小，需使用trimToSize（）将数组容量减小到线性表的大小

若要提取元素或者在线性表的尾部插入和删除元素，ArrayList的效率比较高，若要在线性表任意位置上插入和删除元素，LinkedList效率较高。

链表基本算法

插入结点

假设要在单链表的a结点和b结点之间插入一个值为x的新结点。

如下图所示，指针s指向一个值为x的结点，为了插入s。

首先让s的next指针指向b，即s->next = p->next;

然后，让a的next指针指向s，即p->next = s;

 

删除结点

假设要删除单链表中的b结点。

首先，找到b结点前面的结点a。

如下图所示，p指针指向a结点。b的下一个结点就是p->next->next。

所以，只要让p的next指针跳过b结点，指向b的下一个结点就OK了，即p->next = p->next->next;

链表代码实现

package structure.link;
/**
 * 
 * Description: 定义结点
 * @author 
 */
public class Node {
    protected Node next;// 指针
    protected int data;// 数据数值

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

    // 显示
    public void display() {
        System.out.print(data + " ");
    }

}

package structure.link;
/**
 * 
 * Description: LinkList方法
 * @author 
 */
public class LinkList {
    private Node first; // 头节点
    private int pos = 0; // 节点位置

    public LinkList() {
        this.first = null;

    }

    // 插入一个头节点
    public void addFirstNode(int data) {
        Node node = new Node(data);
        node.next = first;
        first = node;
    }

    // 删除一个头结点,并返回头结点
    public Node deleteFirstNode() {
        Node tempNode = first;
        first = tempNode.next;
        return tempNode;
    }

    // 在任意位置插入节点 在index的后面插入 (插入在原链表index之前)
    public void add(int index, int data) {
        Node node = new Node(data);
        Node current = first; // 现在的
        Node previous = first; // 之前的（现在的前一个）

        while (index != pos++) {
            previous = current;
            current = current.next;
        }
        node.next = current;
        previous.next = node;
        pos = 0;
    }

    // 删除任意位置的节点
    public Node deleteByPos(int index) {
        Node current = first; // 现在的
        Node previous = first; // 之前的（现在的前一个）
        while (index != pos++) {
            if (current.next == null) {
                break;
            }
            previous = current;
            current = current.next;
        }
        if (current == previous) {
            first = first.next;
        } else {
            previous.next = current.next;
            pos = 0;
        }
        return current;
    }

    // 根据节点的data删除节点(仅仅删除第一个)
    public Node deleteByData(int data) {
        Node current = first;
        Node previous = first;
        while (data != current.data) {
            if (current.next == null) {
                break;
            }
            previous = current;
            current = current.next;
        }
        if (current.data == data) {
            first = first.next;
        } else {
            previous.next = current.next;
        }
        return current;
    }

    // 显示出所有的节点信息
    public void displayAllNodes() {
        Node current = first;
        while (current != null) {
            current.display();
            current = current.next;
        }
        System.out.println();
    }

    // 根据位置查找节点信息
    public Node findByPos(int index) {
        Node current = first;
        while (index != pos++) {
            current = current.next;
        }
        return current;
    }

    // 根据数据查找节点信息
    public Node findByData(int data) {
        Node current = first;
        while (data != current.data) {
            if (current.next == null)
                break;
            current = current.next;
        }
        return current;

    }

}