数据结构——java实现顺序表

什么是顺序表

顺序表的概念

首先什么是顺序表呢？先看一下官方概念
顺序表（Sequence List）是一种线性表的实现方式，它是一种顺序存储结构，即数据元素存储在一块连续的存储空间中。顺序表通过数组实现，数组的每个元素存储一个数据元素，元素之间的顺序与其在数组中的位置相对应。
这里听着感觉非常的绕，那有没有我们现在正在使用的列子呢？有的其实我们现在用的数组就是一个顺序表。
那么我们按照数组的概念去套入一下顺序表的概念。

• 首先要是连续的空间得是顺序存储
• 其次存储元素的位置和其内存中的地址一一对应

我们可以发现其实概念上是对应上的。由此我们得出顺序表其实就是我们用的数组那么现在呢我们来模拟实现一个这样的数组。

顺序表包含哪些方法

分析

在实现之前我们要搞清楚实现这个东西需要用到哪些方法。

增删查改

首先肯定是四大方法一个都不能少了增删查改那么我们就通过这四个方法分析

增

首先是赠，也就是增加元素那么增加元素我们肯定要实现两个方法

1. 末尾增加
2. 设置位置增加

删

删除的话其实同样也是

1. 末尾删除
2. 设置位置删除

查

1. 查询某个元素的下标
2. 查询某个下标的值
3. 查询最大元素

改

1. 改动某个位置的值

实现顺序表需要注意哪些地方

说完上面需要实现的方法之后我们来说一下实现这个项目的一些细节问题

增加

增加元素，上面说到增加元素我们需要实现末尾增加和设置某一个位置增加两种方法，那么这时候我们也要思考几个问题

第一个问题

增加元素的时候发现内存空间不够该怎么办，显而易见是扩容啊，那么我们也需要实现一个扩容方法这个方法怎么实现呢？很简单，那就是之前图书管理项目写的那样直接拷贝一下就行了，其次我们应该怎么得到末尾元素的下标呢？答：可以维护一个变量新增一个元素的时候让这个变量++

 public void push_back(T val){
        if(UpSize>=MaxSize){
            Expansion();
        }
        arrayList[UpSize]=val;
        UpSize++;
    }

第二个问题

实现固定位置增加但是这个位置超出我们数组空间了怎么办？这个问题我们需要考虑的其实是两个事情那就是1我们是应该直接终止程序呢？还是抛异常，很明显这里其实直接抛个异常就可以了。

  public void pos_add(int pos,T val) throws PosErrorException{
        if(pos>UpSize){
            throw new PosErrorException("PosErrorException");
        }
        if(UpSize>=MaxSize){
            Expansion();
        }
        for(int i=UpSize;i>=pos;i--){
            arrayList[i+1]=arrayList[i];
        }
        arrayList[pos]=val;
        UpSize++;
    }

删除

删除元素要考虑的问题如下

第一个问题 如果这个顺序表本身就是空的该怎么删除

这个问题其实我们可以直接抛出一个异常来解决。并且要记住我们 维护的有一个数组因此我们删除一个元素之后要对这个类中的维护的变量–

//删除已经存在的某个值
 public boolean DeleteVal(T val) throws PosErrorException{
        int Valuei=find_value(val);
        if(Valuei==-1){
            throw new PosErrorException("No Value");
        }
        for(int i=Valuei;i<UpSize;i++){
            arrayList[i]=arrayList[i+1];
        }
        UpSize--;
        return true;
    }

第二个问题

删除的这个元素不存在怎么办？删除的这个元素不存在的话我们具体思路具体分析我的代码中是将这个情况设置为了异常抛出了。

查

查询元素其实没什么好说的就是逐个遍历需要说的就是找到最大元素但是我在泛型中说过这个问题大家可以去看看我写的泛型编程

改

修改某个位置元素的值其实就是输入一个下标然后输入你要修改的类型即可。这里也并没有什么好说的

代码实现

MyArrayList 实现的顺序表代码

import java.util.Arrays;

public class MyArrayList<T extends Comparable<T>> implements Myarray<T>{
    //泛型顺序表。
    private Object[] arrayList;
    private int UpSize=0;
    private int MaxSize=0;
    //初始化
    public MyArrayList(int n) throws RuntimeException{
        if(n<0){
            throw new RuntimeException("初始化异常");
        }
        arrayList=new Object[n];
        MaxSize=n;
        UpSize=0;
    }
    public MyArrayList() throws RuntimeException{
        this(10);
    }
    //尾插
    public void push_back(T val){
        if(UpSize>=MaxSize){
            Expansion();
        }
        arrayList[UpSize]=val;
        UpSize++;
    }
    //扩容
    private void Expansion(){
       arrayList=Arrays.copyOf(arrayList,MaxSize*2);
       MaxSize*=2;
    }
    //指定位置插入
    public void pos_add(int pos,T val) throws PosErrorException{
        if(pos>UpSize){
            throw new PosErrorException("PosErrorException");
        }
        if(UpSize>=MaxSize){
            Expansion();
        }
        for(int i=UpSize;i>=pos;i--){
            arrayList[i+1]=arrayList[i];
        }
        arrayList[pos]=val;
        UpSize++;
    }
    //查询是否存在某个元素
    public int  find_value(T val){
        int ans=-1;
        if(UpSize==0){
            return ans;
        }
        for(int i=0;i<UpSize;i++){
            if(val.equals(arrayList[i])){
                return i;
            }
        }

        return ans;
    }
    //查询当前长度
    public  int get_Upsize(){
        return UpSize;
    }

    //找出数组内的最大元素
    public T find_MaxValue() throws FullErrorException{
        if(UpSize==0){
            throw new FullErrorException("emptyErrorException");
        }
        T max=(T)arrayList[0];
        for(int i=0;i<UpSize;i++){
            if(max.compareTo((T)arrayList[i])==-1){
                max=(T)arrayList[i];
            }
        }
        return max;
    }
    //比较
    public int compareTo(T other){
        return this.compareTo(other);
    }
    //得到数组中的最大元素
    public int get_MaxSize(){
        return MaxSize;
    }
    //删除
    public boolean DeleteVal(T val) throws PosErrorException{
        int Valuei=find_value(val);
        if(Valuei==-1){
            throw new PosErrorException("No Value");
        }
        for(int i=Valuei;i<UpSize;i++){
            arrayList[i]=arrayList[i+1];
        }
        UpSize--;
        return true;
    }
    //获取某个元素是下标

    public int indexOf(T value){
        int ans=find_value(value);
        return ans;
    }
    //获取下标中的某个元素
    public T GetPosValue(int pos)throws PosErrorException,FullErrorException{
        if(pos>UpSize){
            throw new PosErrorException("PosError");
        }
        if(Empty()){
            throw new FullErrorException("if Empty");
        }
        return (T)arrayList[pos];
    }
    public boolean Empty(){
        if(UpSize==0){
            return true;
        }
        else{
            return false;
        }
    }
    public boolean clear(){
        for(int i=0;i<MaxSize;i++){
            arrayList[i]=null;
        }
        this.UpSize=0;
        return true;
    }
    public String  toString(){
        StringBuilder ans=new StringBuilder();
        for(int i=0;i<UpSize;i++){
            ans.append(arrayList[i]);
        }
        //System.out.println(arrayList[UpSize]);
        return "Mylist:"+ans;
    }
}

---

实现的抛出异常类型代码

public class PosErrorException extends RuntimeException{
    public PosErrorException(){

    }
    public PosErrorException(String measage){
        super(measage);
    }
}

public class FullErrorException extends RuntimeException {
    public FullErrorException(){

    }
    public FullErrorException(String message){
        super(message);
    }

}

---

实现的测试代码

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
public class Main {
    public static void   main(String[] args) {
        MyArrayList<Integer> n=new MyArrayList<>(10);
        try{
            n.pos_add(0,20);
            n.pos_add(1,100);
            n.push_back(1000);
            n.pos_add(3,1000);
            n.push_back(10);
            n.push_back(1);
            n.push_back(1);
            n.push_back(1);
            n.push_back(1);
            n.push_back(1);
            n.push_back(1);
            n.push_back(1);
            n.push_back(1);
            for(int i=20;i<50;i++){
                n.push_back(i);
            }
            n.DeleteVal(20);
            System.out.println(n.find_MaxValue());
            System.out.println(n.get_Upsize());
            System.out.println(n.get_MaxSize());
            System.out.println(n.GetPosValue(30));
            System.out.println(n);
            ArrayList<Integer> l1=new ArrayList<>();
            List<List<Integer>> reans=new ArrayList<>();
        }
        catch (PosErrorException e){
            System.out.println(e.fillInStackTrace());
        }
        catch (FullErrorException e){
            System.out.println(e.fillInStackTrace());
        }
        catch (Exception e){
            System.out.println(e.fillInStackTrace());
        }
    }
}

相处的过程要记住自己犯的错并为之改正