数据结构实验一元稀疏多项式

算法实现

该程序共包含了一个接口、一个类和一个主类。Listter接口定义了顺序表中的方法名称。在类ArrayList中继承了该接口并实现了每一个方法。在Text类中实现一元稀疏多项式相加的方法，在主函数中构建实现多项式计算的过程。在完善创建多项式、加、减和乘的方法，最后在改写toString方法实现输出。

源码如下

import java.util.Scanner;

public class Test {
    static ArrayList<Integer> CalculationA;
    static ArrayList<Integer> CalculationB;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        CalculationA = new ArrayList<Integer>();
        CalculationB = new ArrayList<Integer>();
        init();
        System.out.print("输入一元多项式A");
        String A = in.next();
        System.out.print("输入一元多项式B");
        String B = in.next();
        transformationA(A);//将A式子存储到顺序表
        transformationB(B);//将B式子存储到顺序表
        System.out.println(add());
        System.out.println(subtract());
        System.out.println(multiplicate());
    }

    private static void init() {
        for (int i = 0; i < 1000; i++) {
            CalculationA.add(0);
            CalculationB.add(0);
        }
    }

    private static void transformationA(String a) {
        a = a.replaceAll("-", "+-");
        String []s1 = a.split("[+]");
        for (int i = 0; i < s1.length; i++) {
            String temp = s1[i];
            if (temp.equals("")) continue;
            String []s2 = temp.split("\\^");
            String []s3 = temp.split("x");
            int index = Integer.parseInt(s2[1]);
            int number = Integer.parseInt(s3[0]);
            CalculationA.set(index, number + CalculationA.get(index));
        }
    }

    private static void transformationB(String a) {
        a = a.replaceAll("-", "+-");
        String []s1 = a.split("[+]");
        for (int i = 0; i < s1.length; i++) {
            String temp = s1[i];
            if (temp.equals("")) continue;
            String []s2 = temp.split("\\^");
            String []s3 = temp.split("x");
            int index = Integer.parseInt(s2[1]);
            int number = Integer.parseInt(s3[0]);
            CalculationB.set(index, number + CalculationB.get(index));
        }

    }

    public static String add() {
        StringBuilder ans = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            if (CalculationA.get(i) != 0 || CalculationB.get(i) != 0) {
                int temp = CalculationA.get(i) + CalculationB.get(i);
                if (temp != 0) {
                    if (temp < 0) {
                        ans.append(temp + "x^" + i);
                    }else {
                        ans.append("+" + temp + "x^" + i);
                    }

                }

            }
        }
        System.out.println("该两个式子相加：");
        return ans.toString();
    }

    public static String subtract() {
        StringBuilder ans = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            if (CalculationA.get(i) != 0 || CalculationB.get(i) != 0) {
                int temp = CalculationA.get(i) - CalculationB.get(i);
                if (temp != 0) {
                    if (temp < 0) {
                        ans.append(temp + "x^" + i);
                    }else {
                        ans.append("+" + temp + "x^" + i);
                    }
                }

            }
        }
        System.out.println("该两个式子相减：");
        return ans.toString();
    }

    public static String multiplicate() {
        ArrayList<Integer> temp = new ArrayList<Integer>();
        for (int i = 0; i < 2000; i++) {
            temp.add(0);
        }
        for (int i = 0; i < 1000; i++) {
            for (int j = 0; j < 1000; j++) {
                int x1 = CalculationA.get(i);
                int x2 = CalculationB.get(j);
                int num = x1*x2;
                    int index = i + j;
                    temp.set(index, temp.get(index) + num);
                    if (num != 0) {
                }
            }
        }
        StringBuilder ans = new StringBuilder();
        for (int i = 0; i < 2000; i++) {
            if (temp.get(i) != 0) {
                if (temp.get(i) > 0) {
                    ans.append("+" + temp.get(i) + "x^" + i);
                }else {
                    ans.append(temp.get(i) + "x^" + i);
                }
            }
        }
        System.out.println("该两个式子相乘:");
        return ans.toString();
    }

}

import java.util.Comparator;

public class ArrayList<E> {

    //设置线性表的默认容量
    private static int DEFAULT_CAPACITY = 10;
    private E[] data;
    private int size;

    public ArrayList() {
        this(DEFAULT_CAPACITY);
    }

    public ArrayList(int capacity) {
        if (capacity < 0) {
            throw new IllegalArgumentException("位置不合法");
        }
        data = (E[])new Object[capacity];
        size = 0;
    }

    public void add(E element) {
        add(size ,element);
    }

    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("位置不合法");
        }
        if (size == data.length) {
            resize (data.length*2);
        }
        for (int i = size - 1; i >= index ;i++) {
            data[i+1] = data[i];
        }
        data[index] = element;
        size++;
    }

    private void resize(int newLength) {
        E[] newData = (E[])new Object[newLength];
        for (int i = 0;i < data.length;i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    public void remove(E element) {
        int index = indexOf(element);
        if (index != -1) {
            remove(index);
        }
    }

    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("位置不合法");
        }
        E ret = data[index];
        for (int i = index + 1;i<size;i++) {
            data[i-1] = data[i];
        }
        size--;
        if (size == data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize (data.length / 2);
        }
        return ret;
    }

    public E get(int index) {
        if (index < 0 || index >=size) {
            throw new IndexOutOfBoundsException("角标不合法");
        }
        return data[index];
    }

    public E set(int index, E element) {
        if (index < 0 || index >=size) {
            throw new IndexOutOfBoundsException("角标不合法");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

    public int size() {
        return size;
    }

    public int indexOf(E element) {
        for (int i = 0;i < data.length ;i++) {
            if (data[i].equals(element)) {
                return i;
            }
        }
        return -1;
    }

    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void clear() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("角标不合发");
        }
        int j = 0;
        E e = null;
        //O(n)
        for (int i = 1; i < size; i++) {
            e = data[i];
            for(j = i; j > 0 && c.compare(data[j - 1], e) > 0; j--) {
                data[j] = data[j - 1];
            }
            data[j] = e;
        }
    }
}