單鏈表實現多項式的表示及運算

單鏈表實現多項式的加法運算

最近學習數據結構的線性表，有順序存儲和鏈表兩種，多項式的表示和運算，最能鞏固學習成果，現在提供詳細代碼，來實現多項式的加法運算。

多項式用單鏈表最為合適，不會造成更多的資源浪費。

如果你恰好用的這本書--數據結構（Java版）（第4版）（葉核亞），推薦你去下面這個鏈接下載書本源代碼，將更助你學的輕松。

http://download.csdn.net/detail/wang______jing/9907538

//單鏈表類，實現一些基本單鏈表的操作
public class SinglyList<T> extends Object {
    public Node<T> head; // 頭指針，指向單鏈表的頭結點

    public SinglyList() {
        this.head = new Node<T>();
    }

    public SinglyList(T[] values) { // values數組中的值構成結點
        this();
        Node<T> rear = this.head;
        for (int i = 0; i < values.length; i++) {
            rear.next = new Node<T>(values[i], null);
            rear = rear.next;
        }
    }

    public boolean isEmpty() {
        return this.head.next == null;
    }

    public T get(int i) {
        Node<T> p = this.head.next;
        for (int j = 0; p != null && j < i; j++) {
            p = p.next;
        }
        return (i >= 0 && p != null) ? p.data : null;
    }

    public void set(int i, T x) {
        if (i < 0 || i > size())
            throw new IndexOutOfBoundsException(i + "");
        if (x == null)
            throw new NullPointerException("x==null");
        Node<T> p = this.head.next;
        for (int j = 0; p != null && j < i; j++) {
            p = p.next;
        }
        p.data = x;

    }

    public int size() {
        int len = 0;
        Node<T> p = this.head.next;
        if (p == null)
            return -1;
        while (p != null) {
            len++;
            p = p.next;

        }
        return len;
    }

    public Node<T> insert(int i, T x) {
        if (x == null)
            throw new NullPointerException("x==null");
        Node<T> front = this.head;
        for (int j = 0; front.next != null && j < i; j++) {
            front = front.next;
        }
        front.next = new Node<T>(x, front.next);
        return front.next;

    }

    public Node<T> insert(T t) {
        return insert(Integer.MAX_VALUE, t);
    }

    public T remove(int i) {
        Node<T> front = this.head;
        for (int j = 0; front.next != null && j < i; j++) {
            front = front.next;
        }
        if (i >= 0 && front.next != null) {
            T old = front.next.data;
            front.next = front.next.next;
            return old;
        }
        return null;

    }

    public void clear() {
        this.head.next = null;
    }

}
// 排序單鏈表，對於一些結點可以實現按順序插入排序
public class SortedSinglyList<T extends Comparable<? super T>> extends
        SinglyList<T> {
    public SortedSinglyList() {
        super();
    }

    public SortedSinglyList(T[] values) { // values的數組中的對象按值插入
        super();
        for (int i = 0; i < values.length; i++) {
            this.insert(values[i]);
        }
    }

    public SortedSinglyList(SinglyList<T> list) { // 單鏈表的深拷貝
        super();
        for (Node<T> p = list.head.next; p != null; p = p.next)
            this.insert(p.data);
    }

    public Node<T> insert(T x) { // 覆蓋父類的insert方法
        Node<T> front = this.head, p = front.next;
        while (p != null && x.compareTo(p.data) > 0) {
            front = p;
            p = p.next;
        }
        front.next = new Node<T>(x, p); // 在front之后，p之前插入x節點
        return front.next;
    }

}

//可相加接口
public interface Addible<T> {
    public void add(T t); // 兩元素相加

    public boolean removable(); // 刪除元素

}
//比較大小接口
public interface Comparable<T> {
    int compareTo(T obj);

}

/*
 * 一元多項式節點類 存儲多項式的系數(coefficient)和指數(exponential)
 */
public class PolyNode implements Comparable<PolyNode>, Addible<PolyNode> {
    private int coef;// 系數
    private int expo;// 指數

    protected PolyNode next;

    public PolyNode() {
        this(0, 0);
    }

    public PolyNode(int coef, int expo) { // 帶參數的構造函數

        this.coef = coef;
        this.expo = expo;
        // this.next = null;
    }

    public PolyNode(PolyNode po) { // 拷貝構造函數
        this(po.coef, po.expo);
    }

    public boolean equals(Object obj) // 比較兩項是否相等
    {
        if (this == obj)
            return true;
        if (!(obj instanceof PolyNode))
            return false;
        PolyNode term = (PolyNode) obj;
        return this.coef == term.coef && this.expo == term.expo;
    }

    public PolyNode(String str) { // 參數為一個項時，得到項的系數和指數
        if (str.charAt(0) == '+')
            str = str.substring(1); // 去掉‘+’號
        int i = str.indexOf('x');
        if (i == -1) {
            this.coef = Integer.parseInt(str); // 沒有x,指數就為0
            this.expo = 0;
        } else {
            if (i == 0) { // x在開頭，系數為1
                this.coef = 1;
            } else {
                String str1 = str.substring(0, i);// 截取x符號之前的系數
                if (str1.equals("-")) { // 為‘-’，系數為-1
                    this.coef = -1;
                } else {
                    this.coef = Integer.parseInt(str1);
                }
                i = str.indexOf('^');// 找^符號
                if (i == -1)
                    this.expo = 1;
                else
                    this.expo = Integer.parseInt(str.substring(i + 1));
            }
        }
    }

    public String toString() { // 顯示多項式的樣式
        String sy = this.coef > 0 ? "+" : "-";
        if (this.expo == 0 || this.expo > 0 && this.coef != 1
                && this.coef != -1) {
            sy += Math.abs(this.coef); // 系數絕對值，系數為-1或1不能顯示
        }
        if (this.expo > 0)
            sy += "x";// 指數為0不能輸出x
        if (this.expo > 1)
            sy += "^" + this.expo;// 指數為1不能輸出^
        return sy;
    }

    public int compareTo(PolyNode a) { // 比較兩項的大小
        return (this.expo < a.expo ? -1 : (this.expo == a.expo ? 0 : 1));
    }

    public void add(PolyNode po) { // 相加
        if (this.compareTo(po) == 0)
            this.coef += po.coef;

    }

    public boolean removable() { // 刪除
        return this.coef == 0;
    }

    public int getCoef() {
        return coef;
    }

    public void setCoef(int coef) {
        this.coef = coef;
    }

    public int getExpo() {
        return expo;
    }

    public void setExpo(int expo) {
        this.expo = expo;
    }

}
/*
 * 一元多項式排序鏈表類，提供排序單鏈表的多項式相加運算；
 */
public class PolySort<T extends Comparable<? super T> & Addible<T>> extends
        SortedSinglyList<T> {

    public PolySort() {
        super(); // 構造空單鏈表
    }

    public PolySort(T value[]) { // 構造方法，項的組來指定各項的值
        super(value);
    }

    public PolySort(PolySort<T> list) {// 調用父類的深拷貝函數，復制所有結點
        super(list);
    }

    // 多項式相加函數
    public void addAll(PolySort<T> list) {
        Node<T> front = this.head, p = front.next;
        Node<T> q = list.head.next;
        while (p != null && q != null) {
            if (p.data.compareTo(q.data) == 0) { // 兩項大小相同
                p.data.add(q.data);
                if (p.data.removable()) { // 刪除系數為0的結點
                    front.next = p.next;
                    p = front.next;
                } else {
                    front = p;
                    p = p.next;

                }
                q = q.next;
            } else if (p.data.compareTo(q.data) < 0) {
                front = p;
                p = p.next;
            } else {
                front.next = new Node<T>(q.data, p);
                q = q.next;
            }
        }
        while (q != null) // 將list單鏈表中剩余結點復制並插入到當前鏈表尾
        {
            front.next = new Node<T>(q.data, null);
            front = front.next;
            q = q.next;
        }
    }

}
// 多項式類，使用多項式排序單鏈表類作為成員變量，提供多項式相加運算
public class Polynomial {
    private PolySort<PolyNode> list; // 多項式排序單鏈表

    public Polynomial() // 構造方法
    {
        this.list = new PolySort<PolyNode>(); // 創建空單鏈表，執行排序單鏈表默認構造方法
    }

    public Polynomial(PolyNode terms[]) // 構造方法，由項數組指定多項式各項值
    {
        this.list = new PolySort<PolyNode>(terms);
    }

    public Polynomial(String polystr) // 構造方法，參數指定多項式表達式字符串
    {
        this();
        if (polystr == null || polystr.length() == 0)
            return;
        Node<PolyNode> rear = this.list.head;
        int start = 0, end = 0; // 序號start～end的子串為一項
        while (start < polystr.length() && end < polystr.length()) {
            int i = polystr.indexOf('+', end + 1); // 返回字符+在字符串中從end+1開始的序號
            if (i == -1) // 未找到指定字符
                i = polystr.length();
            int j = polystr.indexOf('-', end + 1);
            if (j == -1)
                j = polystr.length();
            end = i < j ? i : j; // end為下一個+或-號的序號
            rear.next = new Node<PolyNode>(new PolyNode(polystr.substring(
                    start, end)), null);
            // 尾插入，以序號start～end的子串作為一項，創建結點，創建元素對象
            rear = rear.next;
            start = end;
        }
    }

    public Polynomial(Polynomial poly) // 深度拷貝構造方法，復制所有結點和對象
    {
        this(); // 創建空單鏈表，只有頭結點
        Node<PolyNode> rear = this.list.head;
        for (Node<PolyNode> p = poly.list.head.next; p != null; p = p.next) // p遍歷poly單鏈表
        {
            rear.next = new Node<PolyNode>(new PolyNode(p.data), null);// 復制結點，復制對象
            rear = rear.next;
        }
    }

    public String toString() // 返回多項式的描述字符串
    {
        String str = "";
        for (Node<PolyNode> p = this.list.head.next; p != null; p = p.next)
            str += p.data.toString();
        return str;
    }

    public void addAll(Polynomial poly) // 多項式相加，this＋=poly
    {
        this.list.addAll(poly.list);
    }

    public Polynomial union(Polynomial poly) // 加法＋，C=this＋poly
    {
        Polynomial polyc = new Polynomial(this); // 深度拷貝，復制所有結點和對象
        polyc.addAll(poly); // polyc＋=poly
        return polyc; // 返回對象引用
    }

    public boolean equals(Object obj) // 比較兩個多項式是否相等
    {
        return this == obj || obj instanceof Polynomial
                && this.list.equals(((Polynomial) obj).list);
        // 比較兩條單鏈表是否相等
    }
}
// 測試類，完成多項式的相加結果並顯示
public class Poly extends PolySort {

    public static void main(String[] args) {

        System.out.println("//一元多項式");
        PolyNode aterms[] = { new PolyNode(-7, 9), new PolyNode(2, 7),
                new PolyNode(-9, 4), new PolyNode(1, 2), new PolyNode(-1, 1),
                new PolyNode(2, 0) };
        Polynomial apoly = new Polynomial(aterms);

        PolyNode bterms[] = { new PolyNode(9, 11), new PolyNode(5, 10),
                new PolyNode(-3, 8), new PolyNode(10, 4), new PolyNode(-1, 2),
                new PolyNode(1, 1), new PolyNode(-1, 0) };
        Polynomial bpoly = new Polynomial(bterms);

        // Polynomial bpoly = new Polynomial("-1+x-x^2+10x^4-3x^8+5x^10+9x^11");
        System.out.println("A=" + apoly.toString() + "\nB=" + bpoly.toString());

        Polynomial cpoly = apoly.union(bpoly);
        System.out.println("C=A+B，C=" + cpoly.toString());
        apoly.addAll(bpoly);
        System.out.println("A+=B，A=" + apoly.toString());

    }
}