数据结构基础

数据结构：计算机存储、组织数据的方式，它用来反映一个数据的内部构成。

数据：信息的载体，是能够被计算机识别、存储、计算（处理）的符号集合，是计算机处理对象的总称。
    数据含义在计算机语言中，十分广泛，除了通常使用的数字、字符串以外，任何能输入到并能被计算机处理的符号都可称为数据。
    例如，声音，图片等。

数据元素：也称节点，组成数据的基本单位。可以由若干个数据项（也称字段、域、属性）组成。
    例如，短信箱中的一条短信。
    
数据项：数据的最小单位，具有原子性，不可分割。
    例如，一个联系人中的姓名和手机号等。

数据对象：具有相同特征的数据元素的集合，是数据的子集。
    例如，短信箱，通讯录等

数据结构：逻辑结构 + 存储结构 + 数据运算
    1.逻辑结构：从逻辑关系上描述数据，与数据的存储（内存中的存储位置，存储方式等）无关，且独立于语言。
    2.存储结构：也称物理结构，指数据元素及其关系在计算机存储式如何表示，依赖语言。
    3.数据运算：通常定义在逻辑结构上，每种逻辑结构都有一个运算的集合，但运算的具体实现要在存储结构上进行。
        例如，数据对象的增删改查。
        
逻辑结构按数据元素之间的相互关系分为线性结构和非线性结构
    1.线性结构
        有且只有一个开始节点和一个终端节点，并且所有节点最多只有一个直接前驱和一个直接后继节点。
    2.非线性结构
        一个节点可能有多个直接前驱和直接后继节点。常见的非线性结构，树和图。

算法：为求解一个问题需要遵循的、被清晰地指定的简单指令的集合。通常以某一个数据集合作为输入，执行完一组特定的指令后，返回唯一的数据集合作为输出。
    特点：
        1.用待处理问题的信息作为输入数据。
        2.对一个既定的合法输入，多次执行同一算法，总是返回同一个结果（出随机算法除外）。
        3.算法中的指令都是可行的，即每个指令都可实现，并在有限的时间内完成。
        4.算法中的指令数量有限，即在有限的时间内，算法可以正确结束。
        5.算法执行完毕，能够输出正确的数据集合
    算法是一个指令集和，包括控制结构指令和操作指令。即，算法是循环、跳转、判断指令、和数据的操作指令的集合。
        
算法分析：判断算法的执行效率。复杂度是判断算法优劣的标准，分为时间复杂度和空间复杂度。
    1.时间复杂度：算法执行的时间长短
    2.空间复杂度：算法在执行过程中所要占用的存储空间。它是额外消耗的存储空间，并不包括算法加载占用的存储空间。越复杂，算法越差。
    
线性数据结构：线性表、栈、队列等
非线性数据结构：树、图等
    
============线性表============
线性表：
    1.数据元素之间是一对一关系
    2.以字符串、数组、栈、队列等形式使用

特点：
    1.有且只有一个开始节点和一个终端节点
    2.内部节点均有且一个直接前驱和直接后继节点
    3.均匀性：不同线性表的数据元素可以多样，但是同一个线性表的数据元素必定是相同的类型
    4.有序性：数据元素在线性表中的位置只取决于序列，数据元素间的相对位置是线性的
    5.线性表具有增删改查操作。如果需要自定义线性表操作，那么一定要先定义线性表操作的接口，然后在接口中定义线性表的基本操作
    
线性表的存储的数据在结构中的相对位置是随机的，即和数据的关键字不存在确定的关系，在结构中查找一条数据时，需要进行一系列和关键字做比较的动作。
    
范例：

public interface LinearList {
//    判断线性表是否为空
    public boolean isEmpty();
//    返回线性表的长度
    public int size();
//    返回指定索引为index的对象
    public Object get(int index);
//    用指定元素替换线性表中指定位置的元素
    public void set(int index,Object element);
//    在线性表的指定位置插入指定元素
    public Boolean add(int index,Object element);
//    在线性表的末尾插入指定元素
    public Boolean add(Object element);
//    删除线性表中指定位置的元素
    public Object remove(int index);
//    清空线性表
    public void clear();
}

存储方式：
    1.顺序存储：用一组连续的内存单元依次存放数据元素，数据元素在内存中的物理储存次序和在线性表中的逻辑次序相同。（数组）
        优点：存储密度大。因为存储单位的位置是连续的，几乎不浪费空间。
        缺点：插入，删除等不方便。
    2.链式存储：用一组地址分散的存储单元存储数据元素，逻辑上相邻的数据元素在物理位置不一定相邻。（单链表）
        特点：
            1.每个元素节点都有一个指针。（产生原因：存储单元地址是分散的，逻辑关系是连续的。它需要一个指针指向元素的后续节点的地址位置）
        分类：
            a.单链表：也称线性链表，有一个个节点链接而成。每个节点都有一个数据域(nodeValue)和指针域(next)。指针域指向下一个节点的内存存储地址。
            b.循环链表：在单链表的基础上，将表尾节点的指针域指向表头节点，整个链表形成环状结构。
            c.双链表：可同时向前和向后查找数据元素的单链表。每个节点都有一个数据域和previous和next指针域，分别指向直接前驱节点和直接后继节点。
范例：
1.顺序存储，实现线性表操作的接口LinearList - SequenceList

public class SequenceList implements LinearList {

    // 声明对象数组
    private Object[] slist;
    // 声明线性表的长度
    private int size;

    /**
     * 调用带参构造方法
     */
    public SequenceList() {
        this(10);
    }

    public SequenceList(int length) {
        if (length <= 0) {
            this.slist = new Object[10];
        }
        this.slist = new Object[length];
        size = 0;
    }

    @Override
    public boolean isEmpty() {
        if (size == 0) {
            return true;
        } else {
            return false;
        }
        
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int index) {
        checkIndex(index);
        return (Object)slist[index];
    }

    @Override
    public void set(int index, Object element) {
        checkIndex(index);
        slist[index] = element;

    }

    @Override
    public Boolean add(int index, Object element) {
        checkIndex(index);
        if (size == slist.length) {
            Object[] temp = slist;
            this.slist = new Object[temp.length * 2];
            for (int j = 0; j < temp.length; j++) {
                slist[j] = temp[j];
            }
        }
        for (int i = size - 1; i >= index; i--) {
            slist[i + 1] = slist[i];
        }
        slist[index] = element;
        size++;
        return true;
    }

    @Override
    public Boolean add(Object element) {
        return add(size,element);
    }

    @Override
    public Object remove(int index) {
        checkIndex(index);
        Object old = (Object)slist[index];
        for (int i = index; i < size - 1; i++) {
            slist[i] = slist[i + 1];
        }
        slist[size--] = null;
        return old;
    }

    @Override
    public void clear() {
        if (size != 0) {
            for (int i = 0; i < size; i++) {
                slist[i] = null;
            }
            size = 0;
        }

    }
    
    /**
     * @Description: 判断传入的索引值对于当前的线性表是否合法
     * @param index
     */
    public void checkIndex(int index) {
        if (index >= size || index < 0) {
            throw  new IndexOutOfBoundsException("index" + index + "size" + size);
        }
    }

}

2.单链表
a.节点类 - Node

public class Node {
    // 节点值
    private Object nodeValue;
    // 指针
    private Node next;

    public Node() {
        nodeValue = null;
        next = null;
    }

    /**
     * 初始化节点值
     * @param item
     */
    public Node(Object item) {
        nodeValue = item;
        next = null;
    }

    /**
     * 初始化节点值和指针
     * @param item
     * @param next
     */
    public Node(Object item,Node next) {
        nodeValue = item;
        this.next = next;
    }

    public Object getNodeValue() {
        return nodeValue;
    }

    public void setNodeValue(Object nodeValue) {
        this.nodeValue = nodeValue;
    }

    public Node getNext() {
        return next;
    }

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

b.SingleLinkedList

public class SingleLinkedList implements LinearList {

    private Node head;
    
    /**
     * 初始化head为空
     */
    public SingleLinkedList(){
        head = null;
    }
    
    /**
     * 初始化head
     */
    public SingleLinkedList(Node head){
        this.head = head;
    }
    
    @Override
    public boolean isEmpty() {
        return head == null;
    }

    @Override
    public int size() {
        int size = 0;
        Node p = this.head;
        while (p != null) {
            size++;
            p = p.getNext();
        }
        return size;
    }

    @Override
    public Object get(int index) {
        checkIndex(index);
        Node p = this.head;
        for (int i = 0; i < index; i++) {
            p = p.getNext();
        }
        return (Object)p.getNodeValue();
    }

    @Override
    public void set(int index, Object element) {
        checkIndex(index);
        Node p = this.head;
        for (int i = 0; i < index; i++) {
            p = p.getNext();
        }
        p.setNodeValue(element);

    }

    @Override
    public Boolean add(int index, Object element) {
        if (index < 0) {
            throw new IndexOutOfBoundsException("index" + index);
        }
        if (head == null) {
            head = new Node(element);
        } else {
            Node p = this.head;
            if (index == 0) {
                this.head = new Node(element,p);
            } else {
                int i = 0;
                while (p.getNext() != null && i < index - 1) {
                    i++;
                    p = p.getNext();
                }
                p.setNext(new Node(element,p.getNext()));
            }
        }
        return false;
    }

    @Override
    public Boolean add(Object element) {
        return add(Integer.MAX_VALUE, element);
    }

    @Override
    public Object remove(int index) {
        checkIndex(index);
        Object old = null;
        Node p = this.head;
        if (index == 0) {
            old = (Object)this.head.getNodeValue();
            head = p.getNext();
            p = null;
        } else {
            int i = 0;
            while (p.getNext() != null && i < index - 1) {
                i++;
                p = p.getNext();
            }
            Node temp = p.getNext();
            old = (Object)temp.getNodeValue();
            p.setNext(temp.getNext());
            temp = null;
        }
        return old;
    }

    @Override
    public void clear() {
        head = null;

    }
    
    public void checkIndex(int index) {
        if (index < 0 || index > this.size() - 1) {
            throw new IndexOutOfBoundsException("index" + index);
        }
    }

}

线性表的顺序查找
    除了增删查改等基本操作外，还有一些常见的操作，例如从线性表中获取数据的位置
范例：有一个线性表，表中数据域存储A-G7个大写英文字母，查找“F”的位置。
1.查找类

/**
 * @Description: 查找类
 * @author Ivy
 */
public class Search {
    public static int search_seq(LinearList ST,String key) {
        int i = 0;
        while (!ST.get(i).equals(key)) {
            i++;
        }
        return i;
    }
}

2.测试类

public class Test {
    public static void main(String[] args) {
        LinearList ST = new SequenceList();
        String key = "F";
        ST.add("A");
        ST.add("B");
        ST.add("C");
        ST.add("D");
        ST.add("E");
        ST.add("F");
        ST.add("G");
        int i = Search.search_seq(ST, key);
        System.out.println("关键字F的位置：" + i);
    }
}