数据结构之单链表实现多项式加和减法

前言

单链表不仅可以实现二元一次方程组的求解，也可以实现多项式的合并运算，如多项式的求和、求导、等。如两个一元多项式分别有m和n个元素，则算法复杂度为O(m+n)。

例如合并两个一元多项式,。

合并之后的结果为。具体执行代码如下：

package dataStructure;
/*
 * 单链表实现多项式加法
 */
public class Demo3 {
    public static void main(String args[]) {
    	SingleList list1 = new SingleList();
    	Node node1 = new Node(7,0);
    	Node node2 = new Node(3,1);
    	Node node3 = new Node(9,8);
    	Node node4 = new Node(5,17);
    	list1.addNode(node1);
    	list1.addNode(node2);
    	list1.addNode(node3);
    	list1.addNode(node4);
    	
    	SingleList list2 = new SingleList();
    	Node node21 = new Node(8,1);
    	Node node22 = new Node(22,7);
    	Node node23 = new Node(-9,8);
    	list2.addNode(node21);
    	list2.addNode(node22);
    	list2.addNode(node23);
    	doPlu(list1,list2);
    }
    
    public static void doPlu(SingleList list1,SingleList list2) {
    	int list1_size = list1.size;
    	int list2_size = list2.size;
    	int i=0;int j=0;
    	Node list1_preNode = list1.first;
    	Node list2_preNode = list2.first;
    	Node list1_currNode = list1_preNode.next;
    	Node list2_currNode = list2_preNode.next;
    	while(i<list1_size && j<list2_size) {
    		int list1_data = list1_currNode.exp;
    		int list2_data = list2_currNode.exp;
    		if(list1_data < list2_data) {
    			i++;
    			list1_preNode = list1_currNode;
    			list1_currNode = list1_currNode.next;
    		}else if(list1_data == list2_data){
    			list1_currNode.data = list1_currNode.data + list2_currNode.data;
    			list2_currNode = list2_currNode.next;
    			j++;
    		}else{
    			Node list2_nextNode = list2_currNode.next;
    			list1_preNode.next = list2_currNode;
    			list2_currNode.next = list1_currNode;
    		     
    			list2_preNode.next = list2_nextNode;
    			list2_currNode = list2_nextNode;
    			j++;
    		}
    	}
    	if(j==0) {
    		list1.last.next = list2_currNode;
    		list1.last = list2.last;
    	}
    	
    	System.out.println("success!");
    }
}

package dataStructure;
/*
 * 单链表的元素节点包括两个部分，一个是元素对象本身，一个是指向下一个节点的元素
 */
public class SingleList {
	int size = 0;
	Node first = new Node();// 第一个节点
	Node last;// 最后一个节点
	// 在第i个元素位置添加一个新的节点
	public void insertNode(Node node, int i) {
		Node tempNode = first;
		Node nextNode = first.next;
		for (int k = 1; k <= i; k++) {
			if (k == i) {
				Node newTemp = tempNode.next;
				tempNode.next = node;
				node.next = newTemp;
				if (i == size) {
					last = node;
				}
				size++;
			} else {
				tempNode = nextNode;
				nextNode = tempNode.next;
			}
		}
	}
	// 删除第i个元素节点
	public void deleteNode(int i) {
		Node preNode = first;
		Node tempNode = first.next;
		for (int k = 1; k <= i; k++) {
			if (k == i) {
				if (i == size) {
					preNode.next = null;
					last = preNode;
				} else {
					Node nextTemp = tempNode.next;
					preNode.next = nextTemp;
				}
				size--;
			} else {
				preNode = tempNode;
				tempNode = tempNode.next;
			}
		}
	}
	// 构造单链表，尾插法
	public void addNode(Node node) {
		if (size == 0) {
			first.next = node;
			last = node;
		} else {
			Node temp = last;
			last = node;
			temp.next = node;
		}
		// 添加元素成功，则size加1
		size++;
	}
	//构造单链表，采用头插法
	public void addHead(Node node) {
		if (size == 0) {
			first.next = node;
			last = node;
		} else {
			Node temp = first.next;
			node.next = temp;
			first.next = node;
		}
		// 添加元素成功，则size加1
		size++;
	}
}

package dataStructure;
public class Node {
	  int data;//数据本身
	  int exp;//指数
	  Node next;//下一个节点
	  public Node(int data) {
		  this.data = data;
	  }
	  public Node(int data,Node next) {
		  this.data = data;
		  this.next = next;
	  }
	  public Node(int data,int exp) {
		  this.data = data;
		  this.exp = exp;;
	  }
	public Node() {
		// TODO Auto-generated constructor stub
	}
}

总结

多项式的加法或减法，其实就是合并同类项，如果阶数相同，则系数进行相加或相减。例如以第一个一元多项式A(x)为基础，对第二个一元多项式B(x)进行遍历，如果B(x)当前遍历节点list2_currNode的指数比A(x)当前遍历元素list1_currNode元素小，则将B(x)的当前元素插入到A(x)的当前元素的前面一个位置，如果大则插入到A(x)指定元素的后面。在示例代码中还有一个点没有做，就是系数为0的节点应该删除掉，这个可以后续再完善。