数据结构实验2：用链表和顺序表实现两个多项式的加法运算

实现多项式求和运算简单，但是这个输入格式，让简单的加法变得不好实现了。
几个步骤：

1. 建线性表，注意使用模板参数后，不能把.h和.cpp文件分开实现，否则链接会出现错误。

class SeqList
{
public:
    SeqList() { length = 0; }            //无参数构造方法
    SeqList(vector<DataType>a, int n);    //有参数构造方法
    ~SeqList() {}                    //析构函数
    int Length() { return length; }
    //线性表长度
    void Insert(int i, DataType x);  //插入
    void PrintList(); 
    DataType data[MaxSize];         //顺序表使用数组实现
    int length;                     //存储顺序表的长度
};

template <class DataType>
SeqList<DataType>::SeqList(vector<DataType> a, int n)
{
	if (n > MaxSize) throw "wrong parameter";
	for (int i = 0; i < n; i++)
		data[i] = a[i];
	length = n;
}

2. 偶数位保存系数，奇数位保存项数。
3. 建两个线性表，s1和s2，双重循环遍历，s2中寻找和s1线性表中相同的偶数位，如果相同，s2中data[i-1]加s1的代表合并同类项，如果没找到，则把这个点插入s2。
4. 最后对s2的遍历输出，如果要按项高低拍就建个结构体，排序后输出。

vector<Num_Exp>nes;
	for (int i = 0; i < s2.length; i = i + 2) {
		Num_Exp ne;
		if (s2.data[i] == 0) {
			continue;
		}
		ne.num = s2.data[i];
		ne.expnum = s2.data[i + 1];
		ne.exp = "x^";
		nes.push_back(ne);
		cout << nes.back().num << endl;
	}
	for (int i = 0; i < nes.size(); i++) {
		for (int j = nes.size() - 1; j >= i; j--) {
			if (nes[i].expnum > nes[j].expnum) {
				Num_Exp temp = nes[i];
				nes[i] = nes[j];
				nes[j] = temp;
			}
			cout << nes.back().num << endl;
		}
	}

全部代码

/*
使用线性表结构实现多项式求和运算
要求：
1、请分别使用顺序表和链表实现两个多项式的加法运算，其中多项式的项按指
数从高到低排列。例如，3𝑥2 − 𝑥 + 2输入形式为 3 2 -1 1 2 0。
2、比较以上两种实现方法的时间开销和空间开销。
测试样例：
样例 1：
输入样例：
3 4 2 3 1 2（第一个多项式）
-2 3 4 2 5 1 6 0（第二个多项式）
3 4 2 3 1 2
-2 3 4 2 5 1 6 0
3 4 2 3 1 2
-2 3 4 2 5 1 6 0 #
输出样例：
3 4 5 2 5 1 6 0（求和结果
*/

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Num_Exp {
	int num;
	string exp;
	int expnum;
};
const int MaxSize = 100;
template <class DataType>
class SeqList
{
public:
    SeqList() { length = 0; }            //无参数构造方法
    SeqList(vector<DataType>a, int n);    //有参数构造方法
    ~SeqList() {}                    //析构函数
    int Length() { return length; }
    //线性表长度
    DataType Get(int i);            //按位查找
    int Locate(DataType x);         //按值查找
    void Insert(int i, DataType x);  //插入
    DataType Delete(int i);         //删除
    void PrintList(); 
	void addList();//求和
    DataType data[MaxSize];         //顺序表使用数组实现
    int length;                     //存储顺序表的长度
};

template <class DataType>
SeqList<DataType>::SeqList(vector<DataType> a, int n)
{
	if (n > MaxSize) throw "wrong parameter";
	for (int i = 0; i < n; i++)
		data[i] = a[i];
	length = n;
}
template<class DataType>
DataType SeqList<DataType>::Get(int i)
{
	if (i<1 && i>length) throw "wrong Location";
	else return data[i - 1];
}

template<class DataType>
int SeqList<DataType>::Locate(DataType x)
{
	for (int i = 0; i < length; i++)
		if (data[i] == x) return i + 1;
	return 0;
}
template<class DataType>
void SeqList<DataType>::Insert(int i, DataType x)
{
	if (length >= MaxSize) throw "Overflow";
	if (i<1 || i>length + 1) throw "Location";
	for (int j = length; j >= i; j--)
		data[j] = data[j - 1];
	data[i - 1] = x;
	length++;
}
template<class DataType>
DataType SeqList<DataType>::Delete(int i)
{
	int x;
	if (length == 0) throw "Underflow";
	if (i<1 || i>length) throw "Location";
	x = data[i - 1];
	for (int j = i; j < length; j++)
		data[j - 1] = data[j];
	length--;
	return x;
}
template<class DataType>
void SeqList<DataType>::PrintList()
{
	for (int i = 0; i < length; i++)
		cout << data[i] << "  ";
}
template<class DataType>
void SeqList<DataType>::addList()
{
	for (int i = 0; i < length; i++)
		cout << data[i] << "  ";
}
int main() {
	vector<int>n1;
	vector<int>n2;
	int num;
	int flag = 0;
	while (cin >> num ) {
		if (flag == 0)n1.push_back(num);
		else n2.push_back(num);
		if (cin.get() == '\n') {
			flag = 1;
		}
	}
	int len1 = n1.size();
	int len2 = n2.size();
	SeqList<int>s1(n1,len1);
	SeqList<int>s2(n2, len2);
	SeqList<int>s3(n1, len1);
	s1.PrintList();
	cout << endl;
	s2.PrintList();
	for (int i = 1; i < s1.length; i = i + 2) {
		for (int j = 1; j < s2.length; j = j + 2) {
			if (s1.data[i] == s2.data[j]) {
				s2.data[j - 1] += s1.data[i - 1];
				flag = 0;
			}
		}
		if (flag == 1) {
			s2.Insert(s2.length + 1, s1.data[i - 1]);
			s2.Insert(s2.length + 1, s1.data[i ]);
		}
	}
	/*
	3 4 2 3 1 2
	-2 3 4 2 5 1 6 0
	0  3  5  2  5  1  6  0  3  4
	3 4 5 2 5 1 6 0（求和结果
	*/
	cout << endl;
	s2.PrintList();
	vector<Num_Exp>nes;
	for (int i = 0; i < s2.length; i = i + 2) {
		Num_Exp ne;
		if (s2.data[i] == 0) {
			continue;
		}
		ne.num = s2.data[i];
		ne.expnum = s2.data[i + 1];
		ne.exp = "x^";
		nes.push_back(ne);
	}
	for (int i = 0; i < nes.size(); i++) {
		for (int j = nes.size() - 1; j >= i; j--) {
			if (nes[i].expnum > nes[j].expnum) {
				Num_Exp temp = nes[i];
				nes[i] = nes[j];
				nes[j] = temp;
			}
		}
	}
	for (int i = 0; i < nes.size()-1; i++) {
		cout << nes[i].num << "*" << nes[i].exp<<nes[i].expnum << "+";
	}
	cout << nes.back().num << "*" << nes.back().exp<<nes.back().expnum;
	return 0;
}