Java - 自己动手写顺序表

顺序表类：SequenceList

package top.blackvon04.code01SequenceList;

/*
 * 顺序表
 * */

public class SequenceList<T> {
    //顺序表中一维数组的初始长度
    private final int maxSize = 10;
    //存储元素的数组对象
    private T[] listArray;
    //保存顺序表的当前长度
    private int length;

    //构造一个空的线性表
    public SequenceList() {
        length = 0;//初始线性表为空
        listArray = (T[]) new Object[maxSize];//由于不能实例化一个泛型对象，所以在构造器中可以先实例化一个Object数组，再把它转换成一个泛型数组。
    }

    public SequenceList(int n) {
        if (n <= 0) {
            System.out.println("错误：顺序表长度需大于零");
            System.exit(1);
        }
        length = 0;//初始线性表为空
        listArray = (T[]) new Object[n];
    }

    //在线性表中插入一个元素
    /*
     * 顺序表的插入是指在顺序表的第pos-1个元素和第pos个元素之间插入一个新的元素，此时，顺序表中插入位置前后的元素之间的逻辑关系将发生变化，
     * 因此，除非pos=n+1，否则必须通过顺序移动数据元素的存储位置才能体现逻辑关系的变化。
     * pos(位置)是从1开始数，listArray的下标是从0开始
     *
     * 线性表的插入算法需注意以下几点。
     * （1）要检验插入位置的有效性，这里pos的有效范围是：1≤pos≤length+1，其中length为原表长。
     * （2）顺序表中数据区域有listArray.length个存储单元，所以在向顺序表中做插入时先检查表空间是否满了，
     *     在表满的情况下需要重新分配2倍的存储空间，并进行原有数据的复制。
     * （3）注意数据的移动方向。从表尾开始依次向前，一个一个地往后移动数据元素，最后把要插入的元素obj放到数组下标为pos-1的地方。
     * （4）顺序表的长度加1，插入成功返回true。
     * */
    public boolean add(T obj, int pos) {
        //判断待插入位置是否合法
        if (pos < 1 || pos > length + 1) {
            System.out.println("pos值不合法");
            return false;
        }
        //判断当前线性表是否已经占满
        if (length == listArray.length) {
            //如果占满，则扩大一倍
            T[] p = (T[]) new Object[length * 2];
            //将listArray的值赋值给p
            for (int i = 0; i < length; i++) {
                p[i] = listArray[i];
            }
            //再将P赋值给listArray，p是中间量
            listArray = p;
        }
        //遍历待插入位置之后的元素，并且往后移动一位
        for (int i = length; i >= pos; i--) {
            listArray[i] = listArray[i - 1];
        }
        //插入obj元素
        listArray[pos - 1] = obj;
        //顺序表当前长度加一
        length++;

        return true;
    }

    //删除线性表中某个元素
    /*
     * 顺序表的删除是指删除顺序表中的第pos个元素，删除操作也会导致被删除位置前后的元素之间的逻辑关系发生变化，
     * 因此，除非删除位置是表中的最后一个元素，否则也必须通过顺序移动数据元素的存储位置才能体现逻辑关系上的变化。
     * pos(位置)是从1开始数，listArray的下标是从0开始
     *
     * 线性表的删除算法需注意以下几点。
     * （1）当表空时不能做删除。
     * （2）删除第pos个元素，pos的取值为1≤pos≤length，否则第pos个元素不存在，因此，要检查删除位置的有效性。
     * （3）注意数据移动的方向。把删除位置pos之后的数据依次前移一个位置，最后顺序表的长度减1。
     * （4）返回已做备份的被删除元素。
     * */
    public T remove(int pos) {
        if (isEmpty()) {
            System.out.println("顺序表为空，无法执行删除操作");
            return null;
        } else {
            //判断待插入位置是否合法
            if (pos < 1 || pos > length + 1) {
                System.out.println("pos值不合法");
                return null;
            }
            //将待删除的元素赋值给x
            T x = listArray[pos - 1];
            //将pos位置之后的元素向前移动
            for (int i = pos; i <= length; i++) {
                listArray[i - 1] = listArray[i];
            }
            //顺序表当前长度减一
            length--;
            return x;
        }
    }

    //在线性表中查找一个元素
    /*
     * 顺序表的查找是指在顺序表中查找某个值等于给定值的元素位置。
     * 在顺序表中查找是否存在和obj相同的数据元素的最简便的方法是：令obj和顺序表中的数据元素逐个比较
     *
     * 本算法的基本操作是“元素值比较”，若顺序表中存在和obj相同的元素，则比较次数为i（1≤i≤length），
     * 否则为length，即算法find的时间复杂度为O(n)，n为表长的一般性表示。
     * */
    public int find(T obj) {
        if (isEmpty()) {
            System.out.println("顺序表为空");
            return -1;
        } else {
            //遍历顺序表，找到对应元素
            for (int i = 0; i < length; i++) {
                if (listArray[i].equals(obj)) {
                    //找到该元素对应的序列号，返回其位置（序列号+1）
                    return i + 1;
                }
            }
            //遍历完毕，没有找到，返回-1
            return -1;
        }
    }

    //获取线性表中的第pos位置元素
    /*
    * 顺序表中第pos个元素存放在数组listArray下标为pos-1的位置，也就是当位置转换为下标时要进行一个减一的运算。算法中1≤pos≤length，
    * 当pos值有效时返回listArray[pos-1]，否则返回null
    * */
    public T value(int pos) {
        if (isEmpty()) {
            System.out.println("顺序表为空");
            return null;
        } else {
            //判断待插入位置是否合法
            if (pos < 1 || pos > length + 1) {
                System.out.println("pos值不合法");
                return null;
            }
            //返回pos位置对应的元素
            return listArray[pos - 1];
        }
    }

    //更新线性表中的一个元素
    /*
    * 首先检查参数pos的合法性，当1≤pos≤length时，用参数obj的值替换顺序表中第pos个元素，当pos取值超出合法范围时，算法返回false，表示修改失败
    * */
    public boolean modify(T obj, int pos) {
        if (isEmpty()) {
            System.out.println("顺序表为空");
            return false;
        } else {
            //判断待插入位置是否合法
            if (pos < 1 || pos > length + 1) {
                System.out.println("pos值不合法");
                return false;
            }
            //更改pos位置对应的元素
            listArray[pos - 1] = obj;
            return true;
        }
    }

    //判断是否为空
    /*
    * 根据顺序表中表示长度的length的取值进行判断，当顺序表的长度为0时为空表，否则不空
    * */
    public boolean isEmpty() {
        return length==0;
    }

    //求线性表中数据元素的个数
    /*
    * 返回当前顺序表的长度即length的值
    * */
    public int size() {
        return length;
    }

    //依次访问栈中每个元素并输出
    /*
    * 按照逻辑次序依次访问顺序表中每一个数据元素，并进行按格式返回结果
    * */
    public String nextOrder() {
        String strResult = "[";
        for (int i = 0; i < length; i++) {
            //遍历到最后一个元素，不需要添加逗号
            if(i==length-1){
                strResult += listArray[i];
            }else{
                strResult +=listArray[i] +",";
            }
        }
        strResult += "]";
        return strResult;
    }

    //销毁一个已经存在的线索
    /*
    * 把length的值设置为0，listArray为null，即清空顺序表
    * */
    public void clear() {
        length=0;
        listArray =null;
    }
}

测试类：DemoMain

package top.blackvon04.code01SequenceList;

import java.util.Arrays;

public class DemoMain {
    public static void main(String[] args) {
        //实例化默认长度的顺序表
        SequenceList<Integer> seqlst = new SequenceList<>();

        int[] arr = {20,25,62,35,10,9,3,50};
        System.out.println("将此数组中的元素插入到顺序表中："+ Arrays.toString(arr));
        for (int i = 0; i < arr.length; i++) {
            seqlst.add(arr[i],i+1);
        }
        System.out.println("当前顺序表为："+ seqlst.nextOrder());
        System.out.println("=========================");

        System.out.println("将元素“30”添加到第4个位置:");
        seqlst.add(30,4);
        System.out.println("执行插入操作后的顺序表为："+seqlst.nextOrder());
        System.out.println("=========================");

        System.out.println("删除第5个元素：");
        int e = seqlst.remove(5);
        System.out.println("执行删除操作后的顺序表为："+seqlst.nextOrder());
        System.out.println("=========================");

        System.out.println("查询顺序表中元素10的位序");
        int i = seqlst.find(10);
        System.out.println("元素10的位序："+i);
        System.out.println("=========================");

        System.out.println("查询顺序表中第6位元素");
        int v = seqlst.value(6);
        System.out.println("第6位元素："+v);
    }
}

运行结果：

将此数组中的元素插入到顺序表中：[20, 25, 62, 35, 10, 9, 3, 50]
当前顺序表为：[20,25,62,35,10,9,3,50]
=========================
将元素“30”添加到第4个位置:
执行插入操作后的顺序表为：[20,25,62,30,35,10,9,3,50]
=========================
删除第5个元素：
执行删除操作后的顺序表为：[20,25,62,30,10,9,3,50]
=========================
查询顺序表中元素10的位序
元素10的位序：5
=========================
查询顺序表中第6位元素
第6位元素：9