链表/栈/队列/顺序表

一，线性表

线性表是什么？
  线性表是最基本，最简单，也是最常用的数据结构，一个线性表是n个具有相同特征的数据元素的有限排序
前驱元素是什么？
  若是A元素在B元素前面，则称为A为B的前驱元素
后继元素是什么？
  若B元素在A元素后面，则称B为A的后继元素
线性表的特征·：数据元素之间具有一种 ‘’一对一‘’的逻辑关系
  1.第一个数据元素没有前驱，这个数据元素被称为头结点
  2.最后一个元素没有后继元素，这个数据元素被称为尾结点
  3.除了第一个和最后一个节点，其他的接口有且只有一个前驱和后继节点

1.1 顺序表

联系的存储单元，，一次存储线性表的各个元素，使得线性表中再逻辑结构上响铃的数据元素，存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映元素之间逻辑上的相邻关系

1.2 链表

链表是一种物理存储单元上非连续，非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元素的逻辑顺序是通过链表的指针链接次序实现的，链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成

自定义链表 和反转双向链表

import org.w3c.dom.Node;

import java.util.Iterator;

/**
 * @Classname FengRui
 * @Description 双向列表
 * @Date 2022-02-15 15:10
 */
public class TwoWayLinkList<T> implements Iterable<T>
{
    //首节点
    private Node head;
    //尾结点
    private Node last;
    //节点长度
    private int N;


    //节点类
    private class Node{
        public T item;
        public Node pre;
        public Node next;

        public Node (T item,Node pre,Node next){
            this.item =item;
            this.pre =pre;
            this.next =next;
        }
    }

    public TwoWayLinkList() {
        this.head  = new Node(null,null,null);
        this.last  = null;
        this.N  = 0;
    }

    public void clear(){
        this.head.next = null;
        this.last = null;
        this.N = 0;
    }

    public int length(){
        return this.N;
    }

    public boolean isEmpty(){
        return length() == 0;
    }

    public T getFirst(){
        if (isEmpty()){
            return this.head.next.item;
        }else{
            return null;
        }
    }

    public T getLast(){
        if (isEmpty()){
            return this.last.item;
        }else{
            return null;
        }
    }

    public void insert(T item){
        Node node = new Node(item, null, null);
        if (isEmpty()){
            node.pre = this.head;
            this.head.next  = node;
        }else{
            Node pre = this.last;
            node.pre = pre;
            pre.next = node;
        }
        N++;
        this.last =node;
    }

    public void insert(int index,T item){
        //根据下标获取节点
        Node node = getNode(index);
        Node pre = node.pre;
        //创建一个新节点
        Node newNode = new Node(item,pre,node);
        //将 node 的1前驱节点 设置为新节点
        pre.next = newNode;
        // 将 node 的上一个节点设置为 新节点
        node.pre = newNode;
        N++;
    }

    public T get(int index){
        return getNode(index).item;
    }

    public int indexOf(T t){
        return getNodeIndex(t);
    }

    public T remove(int index){
        Node node = getNode(index);
        Node pre = node.pre;
        Node next = node.next;
        pre.next = next;
        next.pre = pre;
        N--;
        return node.item;
    }

    public void reverse(){
        if (isEmpty()){
            return;
        }
        reverse(this.head.next);
    }

    private Node reverse(Node node){
        if (node.next==null){
            node.pre = null;
            this.head.next = node;
            return node;
        }else{
            Node reverse = reverse(node.next);
            reverse.next = node;
            node.pre =reverse;
            node.next = null;
            this.last = node;
            return node;
        }
    }

    private Node getNode(int index){
        if (index<(this.N>>1)){
            Node node = this.head;
            for (int i = 1;i<=index;i++){
                node =node.next;
            }
            return node;
        }else{
            Node node = this.last;
            for (int i = 0;i<=N-index;i++){
                node =node.pre;
            }
            return node;
        }
    }


    private int getNodeIndex(T item){
            Node node = this.head;
            for (int i = 0;node.next!=null;i++){
                node =node.next;
                if (node.item.equals(item)){
                    return i;
                }
            }
            return -1;
    }

    @Override
    public Iterator<T> iterator() {
        return new TIterator();
    }


    private  class TIterator implements Iterator{

        private TwoWayLinkList.Node node;

        public TIterator() {
            this.node = head;
        }

        @Override
        public boolean hasNext() {
            return node.next!=null;
        }

        @Override
        public Object next() {
            node = node.next;
            return node.item;
        }
    }



}

栈

计算机中的栈

    我们吧生活中的栈的概念引入到计算机中，就是提供数据休息的地方，他是一种数据结构，数据既可以进入到栈中，又可以从栈中出去。
    栈是一种基于先进后出（FILO）的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。他按照先进后出的原则存储数据，先进入的数据被压入栈底，最后进入的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个存入数据被第一个读出来）
    我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈

队列

队列是一种基于先进先出的数据结构，是一种只能在一端进行插入，另一端进行铲除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据的时候先读出来