数据结构线性表的应用实现数据的倒序显示，实现两个数组的合并，从小到大排序

基于《数据结构Java语言描述》
案例：实现数据的倒序显示，如数据{30,56，74,87,23,90}显示为{90,23,87,74,56,30}

实现两个数组的合并。要求数据从小到大排序。

A:{23,45,46,67,89}

B:{12,56,87,99}

合并以后为：{12,23,45,46,56,67,87,89,99}。（笔记2.0）

Seqlist类

public class SeqList extends LinearList<Integer> {
    protected Integer[] data; // 对象数组存储顺序表的数据元素
    protected int n; // 顺序表数据元素个数（长度）

    public SeqList(int length) { // 构造容量为length的空表
        this.data = new Integer[length];// 创建长度为length的数组，元素均为null
        this.n = 0; // 空表长度为0
    }

    public SeqList(Integer[] values) { // 由values数组构造顺序表
        this(values.length); // 创建容量为values.length的空表
        for (int i = 0; i < values.length; i++) {// 复制数组元素
            this.data[i] = values[i]; // 对象引用赋值
        }
        this.n = values.length; // 顺序表长度
    }

    public SeqList() { // 创建默认容量的空表
        this(10); // 构造方法重载，调用本类已声明的指定参数列表的构造方法
    }



    public int insert(Integer t) {// 在顺序表的最后插入元素t，返回t序号
        return this.insert(this.n, t);
    }


    public int insert(int i, Integer t) { // 在顺序表的位置i处插入元素t,返回t序号
        if (t == null)
            throw new NullPointerException("t==null"); // 抛出空对象异常
        if (i >= 0 && i <= this.n) {
            Integer src[] = this.data; // 保存原数组
            if (this.n == data.length) { // 若数组满，则扩充顺序表的数组容量
                this.data = new Integer[src.length * 2]; // 重新申请一个容量为原来2倍的数组
                for (int j = 0; j < i; j++) {
                    this.data[j] = src[j]; // 复制当前数组前i个元素
                }
            }
            for (int j = this.n - 1; j >= i; j--) { // 从最后一个位置开始到位置i处，每一个元素向后移动1位
                this.data[j + 1] = src[j];
            }
            this.data[i] = t; // 把要插入的元素t存放在位置i处
            this.n++;
            return i; // 返回下标
        } else {
            throw new IndexOutOfBoundsException(i + "下标越界");// 抛出下标越界异常
        }

    }


    @Override
    public int size() { // 返回顺序表的长度
        return this.n;
    }


    public void clear() { // 清空顺序表
        this.n = 0;
    }

    @Override
    public void printList() { // 遍历顺序表所有元素
        for (int i = 0; i < this.n; i++) {
            System.out.print(this.data[i] + " ");
        }
    }

    // 顺序表逆置
    public void reverse(SeqList list) {
        int t;
        // i下标从头开始往后,j下标从尾开始往前
        for (int i = 0, j = list.size() - 1; i < j; i++, j--) {
            t = list.data[i];
            list.data[i] = list.data[j];
            list.data[j] = t;
        }
    }

    //实现数组合并
    public void and(int[] int1, int[] int2) {
        int[] int3 = new int[int1.length + int2.length];
        System.arraycopy(int1, 0, int3, 0, int1.length);
        System.arraycopy(int2, 0, int3, int1.length, int2.length);
        for (int i = 0; i < int3.length; i++) {
            this.insert(int3[i]);
        }
    }

    //冒泡排序
    public void sort() {
        int temp;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (data[j + 1] < data[j]) {
                    temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
    }
}

LinearList类

public class LinearList<I extends Number> {
    public int insert(Student t) {
        return 0;
    }

    public int insert(int i, Student t) {
        return 0;
    }


    public int size() {
        return 0;
    }

    public void printList() {

    }
}

Demo类

public class Demo {
    public static void main(String[] args) {
        SeqList seqList = new SeqList();
        int[] A={30, 56, 74, 87, 23, 90};
        for (int i = 0; i < A.length; i++) {
            seqList.insert(A[i]);
        }

        System.out.println("倒序显示\t");
        seqList.reverse(seqList);
        seqList.printList();
        seqList.clear();

        System.out.println("\n数组的合并\t");
        int[] a={12,34,56,78,90};
        int[] b={23,34,45,56};
        seqList.and(a,b);
        seqList.printList();
        System.out.println("\n排序后的");
        seqList.sort();
        seqList.printList();

    }
}

结果