Java数据结构——顺序表

一、线性表

线性表是数据结构中最基本、也是最简单的数据存储结构，可以理解为"线性的表"。

在线性表中数据元素之间的关系是线性的，所谓的"线性关系"，是指数据一个挨着一个，中间没有空隙，除第一个和最后一个数据元素外，每个数据元素只有一个前驱数据元素和一个后继数据元素。

数据在逻辑结构呈线性分布，称这样的存储结构为线性表

1.1 线性表特点

• 存储的元素数据类型相同
• 各个数据元素之间的相对位置固定

1.2 线性表分类

逻辑结构上相邻的数据在实际的物理存储中有两种形式：集中存储和分散存储

• 采用顺序的存储方式存储的线性表称为：顺序表
• 采用链式的存储方式存储的线性表称为：链表

1.3线性表抽象数据类型

首先说说什么是抽象数据类型：在Java中基本数据类型(int、double、float)，都支持基本运算，例如加、减法等，系统已经实现了这些基本数据类型的基本运算，但是对于那些自定义的数据类型（如自定义类）就需要自己利用系统提供的基本运算来实现它们的相关运算。

这些自定义的数据类型(如自定义类)和在这个数据类型上定义的相关操作就称为抽象数据类型(ADT,Abstract Data Type)

一个ADT会包含数据声明和运算声明。常用的ADT包含链表、栈、队列、优先队列、二叉树、散列表、图等

二、顺序表

2.1 顺序表概念

1）顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构

2）顺序表的底层是数组实现的，在数组上完成数据的增删查改。

3）顺序表一般可以分为：

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

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表存储的数据大小固定，空间开多了浪费，开少了不够用。

所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小

2. 2 顺序表结构分析

定义一个Object类引用数据类型的数组elem,存放数据元素，另外定义一个整型变量usedSize保存数组中有效的数据个数，在遍历数组时，可以作为判断遍历停止的条件，使遍历更高效。

                   

顺序表的类定义：

class MySequence implements ISequence{

private Object[] elem;
    
private int usedSize;//有效数据个数

}

顺序表接口：

public interface ISequence {
    //在pos位置插入val
    boolean add(int pos,Object data);
    //查找关键字key 找到返回key的下标，没有返回-1;
    int search(Object key);
    //查找是否包含关键字key是否在顺序表当中(这个和search有点冲突)
    boolean contains(Object key);
    //得到pos位置的值
    Object getPos(int pos);
    //删除第一次出现的关键字key
    Object remove(Object key);
    //得到顺序表的长度
    int size();
    //打印顺序表
    void display();
    //清空顺序表以防内存泄漏
    void clear();
}

3. 顺序表实现

在这里，重点分析一下插入方法和移除方法

3.1 在pos位置插入元素data：

boolean add(int pos,Object data);

 首先，我们需要判断插入的位置pos是否合法（pos<0或者pos>usedSize都不合法）

        —如果合法，还需要判断数组是否已满

                        —数组已满，2倍扩容

                        —数组未满，无需扩容

                  

插入操作：移动元素时，要从后往前操作，不能从前往后操作，不然元素会被覆盖。 

3.2 删除第一次出现的关键字key ：

Object remove(Object key);

首先判断要删除的元素是否存在于数组中        

         —如果存在，将要删除元素之后的元素依次向前赋值，之前最后一个位置的元素赋值为null

                  

删除操作：移动元素时，要从前往后操作。           

import java.util.Arrays;
public class MySequence implements ISequence {

    private Object[] elem;
    private int usedSize;   //有效数据个数
    private static final int DEFAULT_SIZE = 10;//数组初始长度

    public MySequence() {   //构造函数
        this.elem = new Object[DEFAULT_SIZE];//数组动态初始化
        this.usedSize = 0;
    }
   //判断数组是否存满
    private boolean isFull() {

        return this.usedSize == this.elem.length;
    }

    @Override
    public boolean add(int pos, Object data) {
        //1、pos位置的合法性进行判断
        if(pos < 0 || pos > this.usedSize) {
            return false;
        }
        //2、判断是否为满。
        if(isFull()){
            //2倍扩容
            this.elem = Arrays.copyOf(this.elem,
                    2*this.elem.length);
        }
        for (int i = this.usedSize-1; i >= pos; i--) {
            this.elem[i+1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
        return true;
    }

    private boolean isEmpty() {

        return this.usedSize == 0;
    }
    @Override
    public int search(Object key) {
        if(isEmpty()){
            return -1;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if(this.elem[i].equals(key)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(Object key) {
        if(isEmpty()){
            return false;
        }
        for (int i = 0; i < this.usedSize; i++) {
            //此时是Object类型，使用equals方法比较内容
            if(this.elem[i].equals(key)){
                return true;
            }
        }
        return false;
    }

    @Override
    public Object getPos(int pos) {
        //判断位置合法性
        if(pos < 0 || pos >= this.usedSize){
            return null;
        }
        return this.elem[pos];
    }

    @Override
    public Object remove(Object key) {
        int index = search(key);//要删除元素的下标
        if(index == -1) {
            return null;
        }
        Object data = this.elem[index];
        int i;
        for ( i = index; i < this.usedSize-1; i++) {
            this.elem[i] = this.elem[i+1];
        }
        this.usedSize--;
        this.elem[i+1] = null;
        return data;
    }

    @Override
    public int size() {
        return this.usedSize;
    }

    @Override
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println();
    }

    @Override
    //防止内存泄漏
    public void clear() {
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
    }
}

测试顺序表：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MySequence mySequence = new MySequence();
        mySequence.add(0,54);
        mySequence.add(1,24);
        mySequence.add(2,86);
        mySequence.display();
        System.out.println(mySequence.contains(25));
        System.out.println(mySequence.getPos(2));
    }
}