线性表的顺序存储实现
//线性表—数组实现
#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;
}