【java】数据结构---顺序表

数据结构是计算机存储数据的方式，数组，栈，二叉树，线性表等等都是数据结构，不同的数据结构有不同的优缺点，本篇博客主要说的是最简单的线性表—顺序表。
顺序表的结构如图
由于顺序表比较简单，所以我们直接来看代码

public interface IMySquence {//定义顺序表接口
    boolean add(int pos,Object obj);//在指定位置插入元素
    Object remove(Object key);//删除指定元素
    int search(Object key);//查找元素，找到了返回下表
    boolean contain(Object key);//查找元素是否存在
    Object getPos(int pos);//获取指定下表的元素
    int size();//返回顺序表的大小
    void display();//打印顺序表
    void clear();//清空顺序表
}

import java.util.Arrays;

public class MySquence implements IMySquence {//实现顺序表接口
    private Object[]elem;
    private int usedSize;//
    private static final int DEFAULT_SIZE = 10;//默认顺序表大小
    public MySquence(){
        this.elem=new Object[DEFAULT_SIZE];
        this.usedSize=0;
    }
    public boolean isFull(){//判断顺序表是否满了
        return (usedSize==elem.length-1);
    }
    public boolean isEmpty(){//判断顺序表是否为空
        return (usedSize==0);
    }
    @Override
    public boolean add(int pos, Object obj) {
        if(pos<0||pos>usedSize){//判断指定的位置是否合法
            return false;
        }
        if(isFull()){//判断顺序表是否为满，满了扩容二倍
            this.elem=Arrays.copyOf(elem,elem.length*2);
        }
        for(int i=usedSize;i>=pos;i--){
            elem[i+1]=elem[i];//将指定位置以及后面的元素后移
        }
        elem[pos]=obj;
        usedSize++;
        return true;
    }

    @Override
    public Object remove(Object key) {
        if(isEmpty()){//判断顺序表是否为空，为空抛出异常
            throw new UnsupportedOperationException("顺序表为空");
        }
        Object object=key;//将要删除的数据保留下来
        for(int i=0;i<usedSize;i++){
            if(key.equals(elem[i])){
                for(int j=i;j<=usedSize;j++){
                    elem[j]=elem[j+1];//后面的元素前移，覆盖需要删除的元素
                }
                elem[usedSize]=null;//将最后面的元素置空
            }
        }
        usedSize--;//更新顺序表大小
        return object;
    }

    @Override
    public int search(Object key) {
        if(isEmpty()){//顺序表为空，则说明找不到
            return -1;
        }
        for(int i=0;i<usedSize;i++){
            if(key.equals(elem[i])){//找到了返回下标
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contain(Object key) {
        if(isEmpty()){//顺序表为空，则说明不包含元素。
            return false;
        }
        for(int i=0;i<usedSize;i++){
            if(key.equals(elem[i])){//如果包含，返回true
                return true;
            }
        }
        return false;
    }

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

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

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

    @Override
    public void clear() {
        for (int i=0;i<usedSize;i++){
            this.elem[i]=null;
        }
    usedSize=0;
    }
}

测试代码

public class TestDemo {
    public static void main(String[] args) {
        MySquence mySquence=new MySquence();
        mySquence.add(0,"A");
        mySquence.add(1,"B");
        mySquence.add(2,"C");
        mySquence.add(3,"D");
        mySquence.add(3,"Hello");
        mySquence.remove("D");
        mySquence.display();
        System.out.println(mySquence.search("C"));
        System.out.println(mySquence.contain("Hello"));
        mySquence.clear();
        System.out.println(mySquence.size());
    }
}

注意，书写代码时进行增加或者删除元素时，要及时更新顺序表大小。以及在判断是否找到时候不能用==来检测。需要使用.equals方法。