2020-10-26

一、集合框架

有关LinkedList的集合的，它是一个链表结构的集合

1、链表结构

1.1 单链表的结构

所谓单链表（Linked）在内存中不连续的一端内存空间， 链表的每一个元素是一个节点，每一个结点由数据元素和下一个结点的存储位置组成，链表结构与数组结构最大区别是链接结构的存储内存是不连续的，而数组结构的内存是连续的，链表结构不能与数组结构一样快速查找，

​ 链表结构操作特点是 添加，删除元素效率高，查询效率低；

​ 数组结构操作特点： 添加，删除效率低，查询效率高

​ 链表结构的示意图

前驱： 该节点的上一个元素的地址

后继： 该节点的下一个元素的地址

链表结构中最后一个元素的”后继“为null

1.2 单链表的实现

链表实现添加元素：

  /**
     * 添加到最后元素
     * @param obj
     */
     public void addLast(Object obj){
         //将节点添加到最后
         //add(obj , this.size);
         // 创建节点
//         Node node = new Node(obj);
//         // 找到最后一个元素的地址
//         Node lastNode = this.header;
//         for(int i = 0;i<this.size-1 ;i++){
//             lastNode  = lastNode.next;
//         }
//
//           lastNode.next=node;
         // 找最后一个结点 （由于最后一个结点的next是null）
         Node node = new Node(obj);
           Node lastNode = this.header;
           while(lastNode.next!=null){
               lastNode = lastNode.next;
           }
           lastNode.next = node;

           this.size++;

     }

  /**
     * 删除第一个节点
     * @param index
     * @return
     */
    public void removeFirst(){
        //删除第一个节点
        if(this.size==0){
            throw new IllegalArgumentException("没有需要删除的原始");
        }
        //  获取当前连接的“后继”
        Node node =  this.header.next;
        // 并让后继作为头
        this.header = node;
        this.size--;
    }

    /**
     * 删除最后节点
     */
    public void removeLast(){
        //删除是否存在数据
        if(this.size==0){
            throw new IllegalArgumentException("没有需要删除的原始");
        }
        // 找最后一个元素的前一个 地址   ，并将该地址的next 改为null
        Node cur  = this.header;
        Node pre = this.header;
        while(cur.next!=null){
               pre = cur;
                // 下一个变为当前
               cur =  cur.next;
        }
         // 最后一个元素  就是 当前
        pre.next = null;
        size--;
    }

2、队列结构

队列结构（Queue）： 在基于链表结构的基础上 ，实现的一种“先进先出”的结构， 常用操作 入队（put），出队（pop） ，设置队列的头结点 和 尾结点

package com.j2008.dataStruct;

/**
 * ClassName: MyQueue
 * Description:
 * date: 2020/10/26 16:41
 *
 * @author wuyafeng
 * @version 1.0   softeem.com
 */
public class MyQueue<T> {
    // 头结点
    private Node front;
    //  尾结点
    private Node tail;
    // 大小
    private int size;

    public MyQueue(){
        //  头，尾为空
        this.front= this.tail=null;
    }

    class Node{
        private T obj;
        private Node next;
        public Node(T obj){
            this.obj = obj;
        }

        public T getObj() {
            return obj;
        }

        public void setObj(T obj) {
            this.obj = obj;
        }

        public Node getNext() {
            return next;
        }

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

    /**
     * 入队 ： 将元素添加到队列的尾部
     */
    public void put(T obj){
        // 创建节点
        Node node = new Node(obj);
        // 如果元素为空 则头就尾，尾就是头
        if(isEmpty()){
            this.front = this.tail = node;
            return ;
        }
        // 将新元素的地址 作为尾的next
        this.tail.next=node;
        //将新元素的结点 作为尾节点
        this.tail = node;

        this.size++;
    }

    /**
     * 出队： 将元素从队列的头部移除 （保持与队列脱离关系）
     * @return
     */
    public T pop(){
        if(isEmpty()){
            throw new IllegalArgumentException("没有弹出的原始");
        }
        // 移除头部元素
        Node popNode = this.front;
        // 设置现在的头元素是下一个
        this.front = popNode.next;
        //  将弹出的元素next 设置null，与队列脱离关系
        popNode.next=null;
        this.size--;
        // 如果没有元素了 则需要 设置头尾都是null
        if(this.size<0){
            this.front=this.tail=null;
        }
        return  popNode.getObj();
    }

    /**
     * 判断元素是否为空
     * @return
     */
    public boolean isEmpty(){
        if(this.front==null && this.tail==null){
            return true;
        }
        return false;
    }

}

3、栈结构

栈（Stack）结构也是常用数据结构之一，它具有 “后进先出” 的特点

public class MyStack<T> {
    // 定义一个数组 ，用于存储元素
    private Object[] obj;
    private int size;
    public MyStack(){
        obj = new Object[10];
        size=0;
    }

    /**
     * 入栈： 压入栈顶元素
     * @param t
     */
    public void push(T t){
        expandCapacity(size+1);
        obj[size]=t;
        size++;
    }

    /**
     *  返回栈顶元素：peek
     */
    public T peek(){

        if(size>0) {
            return (T) obj[size - 1];
        }
        return  null;
    }

    /**
     * 出栈： 返回栈顶的元素，并删除该元素
     * @return
     */
    public T pop(){
        T t = peek();
        if(size>0) {
            // 将最后一个元素 删除
            obj[size - 1] = null;
            size--;
        }
        return t;
    }

    /**
     * 是否为空元素
     * @return
     */
    public boolean  isEmpty(){
        return  size==0;
    }
    /**
     * 扩容数组大小 ： 扩容1.5倍
     */
    public void expandCapacity(int size){
        if(obj.length< size){
            // 需要扩容
            int length = size*3/2 + 1;
           this.obj =  Arrays.copyOf(this.obj,length);
        }
    }

}