线性表_C++实现

线性表的顺序存储实现

//线性表—数组实现

#include<iostream>
#include<assert.h>
using namespace std;
class arr{
public:
	arr(int m_size = 10):max_size(m_size){//初始化一个数组
		base = new int[max_size];
	}
	bool insert_m(int val, int pos);//在位置pos插入元素val,位置从1开始
	void delete_m(int pos_d);//删除位置pos_d的元素
	void pop_m( );//弹出数组最后一个元素
	void append_m(int val);//在末尾添加一个元素，值为val
	bool isEmpty_m();//判断是否是空表
	bool isfull_m();//判断是否是满表
	void size_m();//当前元素个数
	void show_m();//显示当前所有元素的值

private:
	int* base;//指向数组第一个元素
	int max_size;//数组的能够容纳的最多元素
	int cnt = 0;//当前已有的元素个数
};
void arr::pop_m() {
	if (this->isEmpty_m()) {
		cout << "已经是空表，无法再进行弹出" << endl;
		return;
	}
	cnt--;
}
void arr::delete_m(int pos_d) {
	if (this->isEmpty_m()) {
		cout << "已经是空表，无法再进行弹出" << endl;
		return;
	}
	for (int i = pos_d - 1; i < cnt - 1; i++)
		base[i] = base[i + 1];
	cnt--;
}
bool arr::isEmpty_m() {
	if (cnt == 0)
		return true;
	else
		return false;
}
void arr::append_m(int val) {
	if (isfull_m())
		throw("已达最大内存，无法再进行添加");
	
	base[cnt] = val;
	cnt++;
}
bool arr::isfull_m() {
	if (cnt == max_size)
		return true;
	else
		return false;
}
bool arr::insert_m(int value, int position) {
	if (isfull_m()) {
		cout << "已满" << endl;
		return false;
	}
		
	if (position<1 || position>cnt + 1) {
		cout << "插入的位置错误！" << endl;
		return false;
	}
	for (int i = cnt; i >= position; i--)
		base[i ] = base[i-1];
	base[position-1] = value;
	cnt++;
	return true;
}
void  arr::show_m(){
	if (this->isEmpty_m())
	{
		cout << "该对象里面没有任何元素！" << endl;
		return;
	}
	for (int i = 0; i < cnt; i++)
		cout << base[i] << endl;
}
void arr::size_m() {
	cout << this->cnt<<endl;
}
int main() {
	arr arr1;
	arr1.append_m(3);
	arr1.append_m(2);
	arr1.insert_m(4, 1);
	arr1.delete_m(2);
	arr1.show_m();
	return 0;
}

线性表的链式存储实现

//线性表—链表实现

#include<iostream>
using namespace std;

class node {
public:
	node() { this->pnext = NULL; }
	friend class arr;
	friend void insert_m(node* phead, int val, int pos);//在位置pos插入元素val,位置从1开始
	friend void delete_m(node* phead, int pos_d);//删除位置pos_d的元素
	friend void pop_m(node* phead);//弹出数组最后一个元素
	friend void append_m(node* phead, int val);//在末尾添加一个元素，值为val
	friend bool isEmpty_m(node* phead);//判断是否是空表
	friend int size_m(node* phead);//当前元素个数
	friend void show_m(node* phead);//显示当前所有元素的值
	/*int cnt = 0;*/
private:
	int val;
	node* pnext;
};
void pop_m(node* phead) {
	if (isEmpty_m(phead)) {
		cout << "已经是空表，无法再进行弹出" << endl;
		return;
	}
	node* temp = phead;
	while(temp->pnext->pnext){
		temp = temp->pnext;
	}
	node*curr = temp->pnext;
	delete curr;
	temp->pnext = NULL;
}
void delete_m(node* phead,int pos_d) {
	if (isEmpty_m(phead)) {
		cout << "已经是空表，无法再进行弹出" << endl;
		return;
	}
	node* ptemp = phead;
	node* pre = NULL;
	int i = 0;
	while(ptemp->pnext&&i<pos_d)
	{
		pre = ptemp;
		ptemp = ptemp->pnext;
		i++;
	}
	if (i < pos_d) {
		cout << "不存在这个位置" << endl;
		return;
	}
	
	pre->pnext = ptemp->pnext;
	delete ptemp;
}
bool isEmpty_m(node* phead) {
	if (phead->pnext)
		return false;
	else
		return true;
}
void append_m(node* phead,int val) {
	node* pnew = new node();
	pnew->pnext = NULL;
	pnew->val = val;
	node* temp = phead->pnext;
	node* pre= phead;
	while (temp!=NULL) {
		pre = temp;
		temp = temp->pnext;
	}
	pre->pnext = pnew;
}
void insert_m(node* phead,int value, int position) {
	
	if (position<1 ) {
		cout << "插入的位置错误！" << endl;
		return  ;
	}
	node* pre =NULL;
	node* ptemp = phead;
	node* pnew = new node();
	pnew->pnext = NULL;
	pnew->val = value;
	int m = 0;
	while(m<position&&ptemp->pnext)
	{
		pre = ptemp;
		ptemp=ptemp->pnext;
		m++;
	}
	if (m < position) {
		cout<< "该位置不存在！" << endl;
		return;
	}
	pre->pnext = pnew;
	pnew->pnext = ptemp;

}
void  show_m(node* phead) {
	node* ptemp = phead;
	while (ptemp=ptemp->pnext) {
		cout << ptemp->val;
	}
}
int size_m(node* phead) {
	int len = 0;
	node* ptemp = phead;
	while (ptemp->pnext) {
		ptemp = ptemp->pnext;
		len++;
	}
	return len;
}
int main() {
	node *head=new node;

	append_m(head,3);
	append_m(head,2);
	insert_m(head,4, 1);
	delete_m(head,2);
	pop_m(head);
	show_m(head);
	return 0;
}

链表实现多项式相乘

每个多项式的幂由大到小降阶排列

#include<iostream>
//#include<alogrithem>
using namespace std;
class node {
public:
	
	int value;
	int mi;
	node* pnext;
};
node* add( node*a,  node*b) {
	if (a->pnext == NULL)
		return b;
	if (b->pnext == NULL)
		return a;
	node*p1 = a->pnext;
	node*p2 = b->pnext;

	node*pre = new node();
	node*temp = pre;
	pre->pnext = NULL;
	while (p1&&p2) {
		node*pnew = new node();
		if (p1->mi == p2->mi) {
			pnew->value = p1->value + p2->value;
			pnew->mi = p2->mi;
			p1 = p1->pnext;
			p2 = p2->pnext;
		}
		else if (p1->mi > p2->mi) {
			pnew->value = p1->value;
			pnew->mi = p1->mi;
			p1 = p1->pnext;

		}
		else if (p1->mi < p2->mi) {
			pnew->value = p2->value;
			pnew->mi = p2->mi;
			p2 = p2->pnext;
		}
		pre->pnext = pnew;
		pre = pnew;

	}
	if (p1)
		pre->pnext = p1;
	if (p2)
		pre->pnext = p2;
	return temp;
}
node* multi(const node*a,const node*b) {
	node*p1 = a->pnext;
	node*ans=new node();
	ans->pnext = NULL;
	while (p1) {			
		node*pre = new node();
		pre->pnext = NULL;
		node*ptemp = pre;
		node*p2 = b->pnext;
		while (p2) {
			node* pnew = new node();
			pnew->mi = p1->mi + p2->mi;
			pnew->value = p1->value*p2->value;
			pnew->pnext = NULL;
			pre->pnext = pnew;
			pre = pnew;
			p2 = p2->pnext;
		}
		
		ans =add( ans ,ptemp);
		
		p1 = p1->pnext;
	}
	return ans;
}



int main() {
	node* pre1 = new node();
	node* pre2 = new node();
	node*head1 = pre1;
	node*head2 = pre2;
	
	int n1, n2,val,m;
	cout << "请输入第一个多项式的项数" << endl;
	cin >> n1;
	cout << "请输入第一个多项式的项数系数和幂" << endl;
	while (n1) {
		cin >> val;
		cin >> m;
		node*pnew = new node();
		pnew->value = val;
		pnew->mi = m;
		pnew->pnext = NULL;
		pre1->pnext = pnew;
		pre1 = pnew;
		n1--;
	}
	cout << "请输入第二个多项式的项数" << endl;
	cin >> n2;
	cout << "请输入第二个多项式的项数系数和幂" << endl;
	while (n2) {
		cin >> val;
		cin >> m;
		node*pnew = new node();
		pnew->value = val;
		pnew->mi = m;
		pnew->pnext = NULL;
		pre2->pnext = pnew;
		pre2 = pnew;
		n2--;
	}
	//***************
	
	node* NEW = new node;
	NEW = multi(head1, head2);
	NEW = NEW->pnext;
	while (NEW) {
		cout << NEW->value << ',' << NEW->mi << endl;
		NEW = NEW->pnext;
	}
	return 0;
}