一、线性表

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

二、顺序表

1.概念及结构

（1）顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。其实顺序表就是一个数组，但是为什么还要有顺序表呢？因为顺序表写到类里面，将来就可以面向对象。

（2）顺序表一般可以分为：

静态顺序表：使用定长数组存储。

动态顺序表：使用动态开辟的数组存储。

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

2.接口实现

我们来实现一个动态顺序表

import java.util.Arrays;
class MyArrayList{
     public int[] elem;
     public int usedSized;//有效数据长度   不用初始化，因为它默认为0

     public MyArrayList(){
        this.elem = new int[10];
     }
     //打印顺序表
     public void display(){
        for(int i = 0; i < usedSize; i++){
           System.out.print(this.elem[i]);
        }
        System.out.println();
     }
     //获取顺序表有效数据长度
     public int size(){
        return this.usedSize;
     }
     //在pos位置新增元素
     public void add(int pos,int data){
        if(pos < 0 || pos > this.usedSize){
            System.out.println("pos位置不合法！");
            return;
        }
        if(isFull()){
           this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        for(int i = usedSize - 1; i >= pos; i--){
           this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
     }
     //判断顺序表中元素位置满不满
     public boolean isFull(){
        return this.usedSize == this.elem.length;
     }
     // 判定是否包含某个元素
     public boolean contains(int toFind){
        for(int i = 0; i < this.usedSize; i++){
            if(this.elem[i] == toFind){
                 return true;
             }
        }
         return False;
     }
     // 查找某个元素对应的位置
     public int search(int toFind){
         for(int i = 0; i < this.usedSize; i++){
             if(this.elem[i] == toFind){
                return i;
             }
         }
         return -1;//因为数组下标没有-1
     }
     // 获取 pos 位置的元素
     public int getPos(int pos) {
        if(pos < 0 || pos >= this.usedSize){
            System.out.println("pos位置不合法！");
            return -1;//业务上的处理不考虑
        }
        return this.elem[pos];
     }
     // 给 pos 位置的元素设为 value
     public void setPos(int pos, int value) {
       if(pos < 0 || pos >= this.usedSize){
            System.out.println("pos位置不合法！");
            return;
        }
        this.elem[pos] = value;
     }
     //删除第一次出现的关键字key
     public void remove(int toRemove) {
        if(isEmpty()){
           System.out.println("顺序表为空");
           return;
        }
        int index = search(toRemove);
        if(index = -1){
           System.out.println("没有你要删除的位置");
           return;
        }
        for(int i = index; i < this.usedSize - 1; i++){
           this.elem[i] = this.elem[i+1];
        }
        usedSize--;
        //this.elem[usedSize] = null;  如果数组当中是引用类型
     }
     //顺序表是否为空
     public boolean isEmpty(){
         return this.elem.length == 0;
     }
     //清空顺序表
     public void clear(){
        this.usedSize = 0;
        /*  for(int i = 0; i < this.usedSize; i++){
            this.elem[i] = null;
        }*/  //如果数组当中是引用类型
     }
}
public class TestDemo{
   public static void main(String[] args){
       MyArrayList myArrayList = new MyArrayList();
       //这里可以调用方法看看自己的代码是否有问题
   }
}

下面我们分析一下部分方法的思路：

从以上代码来看，我们会发现一些有关顺序表的问题：

（1）顺序表中间 / 头部的插入删除，时间复杂度为 O(N)

（2）增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

（3）增容一般是呈 2 倍的增长，势必会有一定的空间浪费。例如当前容量为 100 ，满了以后增容到 200 ，我们再继续插入了5 个数据，后面没有数据插入了，那么就浪费了 95 个数据空间。

但是这些问题都可以通过链表来解决

三、链表

1.概念及结构

（1）链表是一种 物理存储结构上非连续 存储结构，数据元素的 逻辑顺序 是通过链表中的 引用链接次序实现的。链表由若干个同一个结构类型的“节点”（“结点”）依次串接而成。

（2）链表的结构非常多样，以下情况组合起来就有 8 种链表结构：

①单向、双向 ②带头、不带头 ③循环、非循环

单向带头循环、单向不带头循环、单向带头非循环、单向不带头非循环

双向带头循环、双向不带头循环、双向带头非循环、双向不带头非循环

但是我们现在重点掌握两种就好：

（i）无头单向非循环链表： 结构简单 ，一般不会单独用来存数据。实际中更多是作为 其他数据结构的子结构 ，如哈希桶、图的邻接表等等

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

单链表：链表变量一般用head表示，用来存放链表首结点的地址，链表中的每个结点由数据部分（数据域）和下一个结点的地址部分组成，即每个结点都指向下一个结点，链表中的最后一个结点称为表尾，其下一个结点的地址部分的值为null

双链表：它的每个数据节点中都有两个引用，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点

2.链表的实现

（1）无头单向非循环链表

//代表一个结点
class ListNode{
    public int val;
    public ListNode next;//存储的是节点的地址，所以它的类型是节点类型
  
    public ListNode(){
       this.val = val;
    }
}
public class MyLinkedList{
   //穷举法实现一个链表,其实实现一个链表最好用头插或尾插
   public MyLinkedList head;
   public void createlist(){
        ListNode listNode1 = new ListNode(12);
        ListNode listNode2 = new ListNode(23);
        ListNode listNode3 = new ListNode(34);
        ListNode listNode4 = new ListNode(45);
        ListNode listNode5 = new ListNode(56);

        listNode1.next=listNode2;
        listNode2.next=listNode3;
        listNode3.next=listNode4;
        listNode4.next=listNode5;
        //listNode5.next没有赋初值，相当于默认为null
        this.head=listNode1;//head指向liatNode1所指向的对象
    }
    //打印链表  利用head，head去一个位置我们打印一个数，但是为了打印完后仍能找到头，我们要定义一个临时的头
    public void display(){
        ListNode cur = this.head;
        while(cur != null){
            System.put.println(cur.val+" ");
            cur = cur.next;
        }
        System.put.println();
    }
    //查找单链表中是否包含关键字key
    public boolean contains(int key){
       ListNode cur = this.head;
       whilr(cur != null){
          if(cur.val == key){
              return true;
          }
          cur = cur.next;
       }
       return false;
    }
    //得到单链表的长度
    public int size(){
       listNode cur = this.head;
       int count = 0;
       while(cur != null){
          count++;
          cur = cur.next; 
       }
       return count;
    }
}                                                                                                                                                                                                                                                                                                                                                                                   
    public static void main(String[] args){
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.createlist();
        myLinkedList.display();
        boolean flg = myLinkedList.contains(56);
        System.out.println(flg);
        System.out.println(myLinkedList.size());
    }
}

相信这个穷举法已经帮我们很好的理解好链表的结构，现在我们头插实现一个链表

class ListNode{
    public int val;
    public ListNode next;//存储的是节点的地址，所以它的类型是节点类型
  
    public ListNode(){
       this.val = val;
    }
}
public class MyLinkedList{
   public MyLinkedList head;
   public void display(){
       ListNode cur = this.head;
       while(cur != null){
           System.put.println(cur.val+" ");
           cur = cur.next;
       }
       System.put.println();
   }
   //头插法
   public void addFirst(int data){
       listNode node = new listNode(data);//data是一个数据，但是我们要插入的是一个结点，所以我们先new一个结点
       /*if(this.head == null){
            this.head = node;
          }else{
            node.next = this.head;
            this.head = node;
          }*/
        //其实是不用分开写的
        node.next = this.head;
        this.head = node;
    }
}         
   public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(12);
        myLinkedList.addFirst(123);
        myLinkedList.display();
   }
}

为什么不是12 23？因为它是头插法，23在12的前头插入的

我们还可以用尾插法实现一个链表

class ListNode{
    public int val;
    public ListNode next;//存储的是节点的地址，所以它的类型是节点类型
  
    public ListNode(){
       this.val = val;
    }
}
public class MyLinkedList{
   public MyLinkedList head;
   public void display(){
       ListNode cur = this.head;
       while(cur != null){
           System.put.println(cur.val+" ");
           cur = cur.next;
       }
       System.put.println();
   }
   //尾插法
   public void addLast(int data){
      ListNode node = new listNode(data);
      ListNode cur = this.head;
      if(this.head == null){
          this.head = node;
      }else{
         while(cur.next != null){
            cur = cur.next;
         }
         cur.next = node;
   }
}         
   public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addLast(56);
        myLinkedList.addLast(123);
        myLinkedList.display();
   }
}

这回的顺序是我们想要的了，因为23是在12的后头插的

接下来我们再来看看单链表的其他操作

class ListNode{
    public int val;
    public ListNode next;//存储的是节点的地址，所以它的类型是节点类型
  
    public ListNode(){
       this.val = val;
    }
}
public class MyLinkedList{
   public MyLinkedList head;
   public listNode findIndex(int index){
       listNode cur = this.head;
       while(index - 1 != 0){
          cur = cur.next;
          index--;
       }
       return cur;
   }
   //任意位置插入,第一个数据节点为0号下标
   public void addIndex(int index,int data){
      if(index < 0 || index > size()){
          return;
      }
      if(index == 0){
          addFirst();
      }
      if(index == size()){
          addLast();
      }
      listNode node = new listNode(data);
      listNode cur = findIndex(index);
      node.next = cur.next;
      cur.next = node;
   } 
   //删除第一次出现关键字为key的节点
   public void remove(int key){
       if(this.head == null){
          System.out.println("单链表为空，不能删除");
          return;
       }
       if(this.head.next == key){
          this.head = this.head.next;
          return;
       }
       ListNode cur = searchPerv(key);
       if(cur == null){
          System.out.println("没有你要找的节点");
          return;
       }
       ListNode del = cur.next;
       cur.next = del.next; 
   }
   public ListNode searchPerv(int key){
        ListNode cur = this.head;
        while(cur.next != null){
            if(cur.next.val == key){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
   //删除所有值为key的节点
    public ListNode removeAllKey(int key){
        if(this.head == null){
            return null;
        }
        ListNode prev = this.head;
        ListNode cur = this.head.next;
        while(cur != null){
            if(cur.val == key){
               prev.next = cur.next;
               cur = cur.next;
            }else{
               prev = cur;
               cur =cur.next;
            }
        }
         if(this.head.val == key){
            this.head = this.head.naxt;
         }
        return this.head;
     }
     //清除链表
     public void clear() {
        //法一：（粗暴）
        //this.head = null;
        //法二（温柔）
        while(this.head != null){
            ListNode curNext = head.next;
            this.head.next = null;
            this.head = curNext;
        }
    }
}                                                                                                                                                                                                                                                                                                                                                                                   
    public static void main(String[] args){
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.createlist();
        myLinkedList.display();
        boolean flg = myLinkedList.contains(56);
        System.out.println(flg);
        System.out.println(myLinkedList.size());
    }
}

下面我们分析一下部分方法的思路：

（2）无头双向链表实现

class ListNode{
    public int val;
    public ListNode prev;
    public ListNode next;

    public ListNode(int val){
        this.val = val;
    }
}
public class TestDemo {
    public ListNode head;
    public ListNode last;
    //打印双向链表
     public void display(){
         ListNode cur = this.head;
         while(cur != null){
             System.out.print(cur.val+" ");
             cur = cur.next;
         }
         System.out.println();
     }
    //得到双链表的长度
     public int size(){
         ListNode cur = this.head;
         int count = 0;
         while(cur != null){
             count++;
             cur = cur.next;
         }
         return count;
     }
    //查找是否包含关键字key是否在双链表当中
    public boolean contains(int key){
         ListNode cur = this.head;
         while(cur != null){
             if(cur.val == key){
                 return true;
             }
             cur = cur.next;
         }
         return false;
    }
    //头插法
     public void addFirst(int data){
         ListNode node = new ListNode(data);
         if(this.head == null){
             this.head = node;
             this.last = node;
         }else{
             node.next = this.head;
             this.head.prev = node;
             this.head = node;
         }
     }
     //尾插法
     public void addLast(int data){
         ListNode node = new ListNode(data);
         if(this.head == null) {
             this.head = node;
             this.last = node;
         }else{
             this.last.next = node;
             node.prev = this.last;
             this.last = node;
         }
     }
    //任意位置插入,第一个数据节点为0号下标
     public void addIndex(int index,int data){
         ListNode node = new ListNode(data);
         if(index < 0 || index > size()){
             return;
         }
         if(index == 0){
             addFirst(data);
             return;
         }
         if(index == size()){
             addLast(data);
             return;
         }
         ListNode cur = searchIndex(index);
         node.next = cur.prev.next;
         cur.prev.next = node;
         node.prev = cur.prev;
         cur.prev = node;
     }
     public ListNode searchIndex(int index){
         ListNode cur = this.head;
         while(index != 0){
             cur = cur.next;
             index--;
         }
         return cur;
     }
     //删除第一次出现关键字为key的节点
     public void remove(int key){
         ListNode cur = this.head;
         while(cur != null){
             if(cur.val == key){
                  //头结点
                 if(cur == this.head){
                     this.head = this.head.next;
                     //如果只有一个结点
                     if(this.head != null) {
                         this.head.prev = null;
                     }else{
                         last = null;
                     }
                 }else{
                     cur.prev.next = cur.next;
                     //尾结点
                     if(cur == this.last){
                         last = last.next;
                     }else{
                         cur.next.prev = cur.prev;//中间结点
                     }
                 }
                 return;
             }
             cur = cur.next;

         }
     }
     //删除所有值为key的节点
     public void removeAllKey(int key){
         ListNode cur = this.head;
         while(cur != null){
             if(cur.val == key){
                 if(cur == head){
                     this.head = this.head.next;
                     if(head != null) {
                         this.head.prev = null;
                     }else{
                         last = null;
                     }
                 }else{
                     cur.prev.next = cur.next;
                     if(cur == last){
                         last = last.next;
                     }else{
                         cur.next.prev = cur.prev;
                     }
                 }
             }
             cur = cur.next;
         }
     }
     public void clear(){
         //法一：
         /*this.head = null;
         this.last = null;*/
         //法二：
         while(this.head != null){
             ListNode curNext = this.head.next;
             this.head.next = null;
             this.head.prev = null;
             this.head = curNext;
         }
         this.last = null;
     }
     public static void main(String[] args) {
         TestDemo testDemo = new TestDemo();
         //下面我们可以自己调用方法运行一下
     }
}

分析部分方法的实现的思路：