2021-07-04学习笔记—数据结构（栈、单向链表）

数据结构

数据结构是以某种特定的布局方式存储数据的【容器】。这种布局方局决定了数据结构对于某些操作是高效的，而对于其他

操作则是低效的。所以我们需要理解理解，才能在处理实际问题时选取最合适的数据结构

• 数据结构 = 逻辑结构 + 物理结构(顺序、链式、索引、散列)
  • 逻辑结构：数据元素间抽象化的相互关系
  • 物理结构：(存储结构)，在计算机存储器中的存储形式（数组、链表等）

数据结构逻辑分类

线性结构

• 数据结构中的元素存在一对一的相互关系
• 常见的线性结构：线性表，栈，队列，串(一维数组)等
• 顺序结构、链式结构

树形结构

• 数据结构中的元素存在一对多的相互关系
• 常见树形结构：二叉树，红黑树，B树，哈夫曼树等

图形结构

• 数据结构中的元素存在多对多的相互关系
• 常见图形结构：有向图，无向图，简单图等

栈结构

【定义】栈是一种只能从一端存取数据且遵循【后进先出(LIFO)】原则的线性存储结构

实现栈容器

创建栈容器类

package com.java.cyf;

/**
 * mystack容器
 */
public class MyStack<E> {

    /*
    创建类时采用了泛型，定义数组时可以使用泛型，但创建数组时必须给定类型，还不如直接给个Object类型
     */
    private Object[] arr;//存放元素的物理结构

    private int stackLength = 5;//数组的默认长度

    private int size;//记录栈容器的元素个数

    private int index = -1;//操作数组下标位置的指针

    /**
     * 判断栈容器是否为空
     * @return
     */
    public boolean empty(){
        return false;
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public E pop(){
        return null;
    }

    /**
     * 向栈容器中添加元素
     * @param item
     * @return
     */
    public E push(E item){
        return null;
    }

    public static void main(String[] args) {

    }
}

实现添加元素

public E push(E item){
        //初始化数组
        this.capacity();
        //向数组中添加元素
        this.arr[++index] = item;
        //记录元素个数
        this.size++;
        return item;
    }

    /**
     * 数组初始化或以1.5倍对数组扩容
     * @param
     */
    private void capacity(){
        //数组初始化
        if (this.arr == null){
            this.arr = new Object[this.stackLength];
        }
        //以1.5倍对数组扩容
        if (this.size - (this.stackLength-1) >= 0){
            this.stackLength = this.stackLength + (this.stackLength >>1 );
            this.arr = Arrays.copyOf(this.arr,this.stackLength);
        }
    }

实现获取元素

/**
     * 返回栈顶元素
     * @return
     */
    public E pop(){
        //如果栈容器中没有元素，则抛出空栈异常；
        if (this.index == -1){
            throw new EmptyStackException();
        }
        //记录元素个数
        this.size--;
        //如果有，则返回栈顶元素
        return (E) this.arr[index--];
         /*
        关于此处为什么是--？
        取出一个栈顶元素还会有一个新的栈顶元素（如果栈容器还有元素）
        因为pop方法的目的是取出当前栈顶元素，且pop方法要能够重复使用
         */
    }

判断栈容器是否为空

 /**
     * 判断栈容器是否为空
     * @return
     */
    public boolean empty(){
        return this.size == 0;
    }

链表结构

链表结构是由许多节点构成的，每个节点都包含两部分：

• 数据部分∶保存该节点的实际数据
• 地址部分:保存的是上一个或下一个节点的地址

链表分类：单向链表、双向链表、双向循环链表

【特点】

• 节点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻
• 访问时只能通过头或者尾指针进入链表,并通过每个结点的【指针域】向后或向前扫描其余节点，所以寻找第一个结点和最后一个结点所花费的时间不等

【优缺点】

• 优点：数据元素的个数可以自由扩充，插入、删除等操作不必移动数据，只需修改链接指针，修改效率较高
• 缺点：必须采用顺序存取，即存取数据元素时，只能按链表的顺序进行访问，访问节点效率较低

单向链表

单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过从头部开始顺序读取

实现单向链表

创建链表接口

/*
接口
基于链表结构存取元素的方法API定义
 */
public interface MyList<E> {
    void add(E element);
    E get(int index);
    int size();
    E remove(int index);
}

创建单向链表类

package com.java.cyf;

/**
 * 基于单向链表实现元素存取的容器类
 * @param <E>
 */
public class MySinglyLinkedList<E> implements MyList<E>{

    /**
     * 向链表中添加元素
     * @param element
     */
    @Override
    public void add(E element) {

    }

    /**
     * 根据位置获取元素
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        return null;
    }

    /**
     * 获取元素个数
     * @return
     */
    @Override
    public int size() {
        return 0;
    }

    /**
     * 根据位置删除元素
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        return null;
    }

    public static void main(String[] args) {
        
    }
}

创建节点类

内部类，在一个类不具备通用性时，为了做到更好的隐藏

例子【飞机发动机】

/**
     * 定义单向链表中的节点对象/节点类
     */
    class Node<E>{
        private E item;//记录元素
        private Node next;//记录下一个节点的地址
        Node(E item,Node next){
            this.item = item;
            this.next = next;
        }
    }

实现添加元素方法

 private Node head;//存放单向链表中的头节点
    private int size;//记录元素个数
    /**
     * 向链表中添加元素
     * @param element
     */
    @Override
    public void add(E element) {
        //创建节点
        Node<E> node = new Node<>(element,null);
        //获取尾节点
        Node tail = getTail();
        //节点的挂接
        if (tail == null){
            this.head = node;
        }else{
            tail.next = node;//新添加的元素所在节点node挂接到tail
        }
        //记录元素个数
        this.size++;
    }

    /**
     * 获取尾节点的方法
     * 一个锥子固定头节点，一个锥子用于寻找尾节点
     * 先判断头节点是否存在
     * 有头节点的前提下，依头节点去寻找尾节点
     * next为空的节点就是尾节点
     * @return
     */

    private Node getTail(){
        if (this.head == null){
            return null;
        }
        Node node = this.head;
        while(true){
            if (node.next == null)
                break;
            node = node.next;//移动指针，指向下一个节点（这里看着比较奇怪，但next返回的也是一个Node类型，表示当前节点的下一个节点）
        }
        return node;
    }

实现获取元素的方法

/**
     * 根据位置获取元素
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        //校验index合法性
        this.checkIndex(index);
        //根据index获取指定节点
        Node<E> node = this.getNode(index);
        //返回该节点中的元素
        return node.item;
    }

    /**
     * 校验index
     */
    private void checkIndex(int index){
        if (!(index >= 0 && index < this.size)){
            throw new IndexOutOfBoundsException("Index: "+ index +" Size:" + size);
        }
    }

    /**
     * 根据index获取指定节点
     */
    private Node getNode(int index){
        Node<E> node = this.head;//给一个从头节点开始移动的指针
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

实现删除元素的方法

保证始终有头节点（除非不存放任何元素），在不增删头节点的情况下，就锁死头节点不动！

/**
     * 根据位置删除元素
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        //校验index合法性
        this.checkIndex(index);
        //根据index获取指定节点
        Node<E> node = this.getNode(index);
        //通过节点获取元素
        E item = node.item;
        //删除节点：先判断删除的是否头节点；如果不是头节点，，当前节点指向null
        if (this.head == node){
            this.head = node.next;//指针后移，让原来头节点的下一个节点变成新的头节点
        }else{
            Node<E> temp = this.head;
            for (int i = 0; i < index-1; i++) {
                temp = temp.next;
            }
            //node.next = temp.next;
            temp.next = node.next;//使当前的上一个节点指向当前的下一个节点
        }
        node.next = null;//断开当前节点对下一节点的指向
        //记录元素个数
        this.size--;
        //返回该删除的元素
        return item;
    }

/*
 Node<E> temp = this.head;
            for (int i = 0; i < index-1; i++) {
                temp = temp.next;
            }
            此处寻找指定节点的上一个节点，可使用定义的getNode(index-1)
 Node<E> temp = getNode(index -1);
 */

实现获取元素的个数

/**
     * 获取元素个数
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }