轻松认清顺序表和链表-------------快乐人的java初学日记[6]

一.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

二.顺序表

2.1什么是顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般可以分为：
静态顺序表：使用定长数组存储。
动态顺序表：使用动态开辟的数组存储。
静态顺序表适用于确定知道需要存多少数据的场景.静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用，相比之下动态顺序表更灵活, 根据需要动态的分配空间大小.

2.2如何实现顺序表

我们可以在idea里面的src下创建两个类一个是Testdome另外一个是ArrList类如图

其实顺序表就如同用类搞了一个数组我们简单举例

public class ArrList {
    public  int[] arr=new int[10];
    public int sum=10;
    public void add(int pos,int date){
        if(pos<0||pos>sum){
            return;
        }
        arr[pos]=date;
    }
    public void display(){
        for(int i=0;i<sum;i++){
            System.out.print(arr[i]);
        }

    }

}

public class Testdome {
    public static void main(String[] args) {
        ArrList arrList=new ArrList();
        arrList.add(0,2);
        arrList.add(1,2);
        arrList.add(2,2);
        arrList.add(3,2);
        arrList.display();

    }


    }

结果是2222000000

2.3关于顺序表的猜想

1. 顺序表中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

三.链表

3.1 链表的概念

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。如果说顺序表是一个数组去存储数的话，链表就是一个由节点组成的表。（由两部分组成一个是值域另一个是存储下一个节点的位置）。

链表总共有八种，但是我们主讲，无头单向非循环链表和无头双向链表。
无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
例如：

这个就是单链表的构造形式

class List {
    public  int val;
    public List next;
     public List(int val) {
         this.val=val;
     }
}
public class ArrList{
   public List head;
    public void FirstAdd(int date ){
        List pre =new List(date);
        if(head==null){
            head=pre;
            return;
        }
        pre.next=head;
        head=pre;
    }
public void display(){
        List cur =this.head;
        while (cur!=null){
            System.out.print(cur.val+" ");
             cur=cur.next;

        }
    System.out.println(" ");
    }

         }

public class Testdome {
    public static void main(String[] args) {
        ArrList arrList=new ArrList();
        arrList.FirstAdd(30);
        arrList.FirstAdd(15);
        arrList.display();
    }


    }

结果是15 30
因为先插入了15然后插入了30

此外还有一些功能我们留一个课下作业。
1、无头单向非循环链表实现
public class SingleLinkedList {
//头插法
public void addFirst(int data);
//尾插法
public void addLast(int data);
//任意位置插入,第一个数据节点为0号下标
public boolean addIndex(int index,int data);
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key);
//删除第一次出现关键字为key的节点
public void remove(int key);
//删除所有值为key的节点
public void removeAllKey(int key);
//得到单链表的长度
public int size();

public void display();
public void clear(); }

无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

class DoubleList{
    public int val;
    public DoubleList prev;//是定义Doublefangfa；
    public DoubleList next;
    public  DoubleList(int val){
        this.val=val;
    }
}
public class DoubleLink {
    public DoubleList head;//用DoubleList方法定义一个head和list对象；
    public DoubleList last;

    public void display() {
        if (head == null) {
            return;
        }
        DoubleList cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    public int sizeof() {
        DoubleList cur = this.head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    public boolean countain(int date) {
        DoubleList cur = this.head;
        while (cur != null) {
            if (cur.val == date) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    public void First(int date) {
        DoubleList node = new DoubleList(date);
        if (head == null) {
            this.head = node;
            this.last = node;
            return;
        }
        node.next = head;
        head.prev = node;
        head = node;
    }

    public void Last(int date) {
        DoubleList node = new DoubleList(date);
        if (last == null) {
            this.last = node;
            this.head = node;
        }
        DoubleList cur = this.last;
        last.next = node;
        node.prev = last;
        last = node;
    }

    public void remove(int date) {
        DoubleList node = new DoubleList(date);
        DoubleList cur = this.head;
        while (cur != null) {
            cur = cur.next;
            if (cur.val == date) {
                if (head == cur) {
                    head = head.next;
                    if (head!=null){
                    }else {
                        last=null;
                    }
                    head.prev = null;
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        last = last.prev;
                    }
                }
                return;
            }
        }
    }
}

public class Text {
    public static void main(String[] args) {
        DoubleLink doubleLink=new DoubleLink();
        doubleLink.First(1);

        doubleLink.display();
    }
}

四.顺序表和链表的区别和联系

链表的优点：1.任意位置插入删除时间复杂度为O(1) 2.没有增容问题，插入一个开辟一个空间。
链表的缺点：以节点为单位存储，不支持随机访问。’
顺序表的优点：空间连续、支持随机访问
顺序表的缺点：1.中间或前面部分的插入删除时间复杂度O(N) 2.增容的代价比较大。