#include <iostream>
using namespace std;
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
/*
(1)需要思考的地方,还是那个函数的按值传递,以及引用传递,
此中的initLinkList,以及destroyLinkList函数中的参数时LINKLIST*,
是由于传递之后希望值发生改变,所以引用传递。
然后那个createLinkList函数中的参数是LINKLIST ,仅仅是按值传递,
A->B,为什么传递之后,可以用A中的linklist变量,来访问在B中添加 的节点?
分析得,按值传递,那么data,以及next 都会按值拷贝,然后传递前后的实参以及形参
中的 linklist 变量的next是两个不同内存单元的,但是next指向是同一个内存单元。
*/
typedef struct{
float xishu;
int zhishu;
} elementType;
typedef struct NODE_TAG{
elementType data;
NODE_TAG* next;
} NODE,*NODEPTR,*LINKLIST;
// 初始化linklist
int initLinkList(LINKLIST* linklist){
*linklist=(NODEPTR)malloc(sizeof(NODE));
if(!(*linklist))
return 0;
(*linklist)->next=NULL;
return 1;
}
//遍历linklist
void traverseLinkList(LINKLIST linklist){
cout<<endl<<"traverse the linklist :"<<endl;
NODEPTR pnode=linklist->next;
elementType element;
while(pnode){
element=pnode->data;
printf("xishu=%f , zhishu=%d\n",element.xishu,element.zhishu);
pnode=pnode->next;
}
cout<<endl;
}
// 创建一个降序的多项式linklist.
int createLinkList(LINKLIST linklist){
elementType element;
NODEPTR pNewNode;
NODEPTR pNodeIndex;
cout<<endl<<"输入 指数,然后输入系数,当指数为0.然后输入一个系数,表示输入结束"<<endl;
while(1){
cin>>element.xishu>>element.zhishu;
if(!element.xishu) return 1;
pNewNode=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode) return 0;
pNewNode->data=element;
pNodeIndex=linklist;
while(pNodeIndex->next!=NULL&&(element.zhishu< (pNodeIndex->next->data.zhishu))){
pNodeIndex=pNodeIndex->next;
}
pNewNode->next=pNodeIndex->next;
pNodeIndex->next=pNewNode;
}
}
/* 多项式想加:
只有在两个多项式的某一个节点的指数相同时,才需要相互加,然后创建新节点,添加到linklist3中,
如果某一个指数只有一个多项式的某个节点有,则仍然需要创建新节点。
*/
int addPolyn(LINKLIST linklist1,LINKLIST linklist2,LINKLIST linklist3){
NODEPTR pnodeIndex1,pnodeIndex2,pnodeIndex3;
pnodeIndex1=linklist1->next;
pnodeIndex2=linklist2->next;
pnodeIndex3=linklist3;
NODEPTR pNewNode3;
elementType element;
while(pnodeIndex1&&pnodeIndex2){
if(pnodeIndex1->data.zhishu>pnodeIndex2->data.zhishu){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex1->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex1=pnodeIndex1->next;
}
else if(pnodeIndex1->data.zhishu<pnodeIndex2->data.zhishu){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex2->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex2=pnodeIndex2->next;
}
else {
element.zhishu=pnodeIndex1->data.zhishu;
element.xishu=pnodeIndex1->data.xishu+pnodeIndex2->data.xishu;
if(element.xishu){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->data=element;
pNewNode3->next=NULL;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
}
pnodeIndex1=pnodeIndex1->next;
pnodeIndex2=pnodeIndex2->next;
}
}
while(pnodeIndex1){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex1->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex1=pnodeIndex1->next;
}
while(pnodeIndex2){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex2->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex2=pnodeIndex2->next;
}
return 1;
}
int destroyLinkList(LINKLIST * linklist){
NODEPTR pnodeIndex,pPreNode;
pnodeIndex=*linklist;
while(pnodeIndex){
pPreNode=pnodeIndex;
pnodeIndex=pnodeIndex->next;
free(pPreNode);
}
*linklist=NULL;
return 1;
}
int main()
{
LINKLIST linklist1,linklist2,linklist3;
initLinkList(&linklist1);
initLinkList(&linklist2);
initLinkList(&linklist3);
createLinkList(linklist1);
traverseLinkList(linklist1);
createLinkList(linklist2);
traverseLinkList(linklist2);
cout<<"add linklist1 and linklist2 to linklist3"<<endl;
addPolyn(linklist1,linklist2,linklist3);
traverseLinkList(linklist3);
destroyLinkList(&linklist1);
destroyLinkList(&linklist2);
destroyLinkList(&linklist3);
cout << "Hello world!" << endl;
return 0;
}
using namespace std;
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
/*
(1)需要思考的地方,还是那个函数的按值传递,以及引用传递,
此中的initLinkList,以及destroyLinkList函数中的参数时LINKLIST*,
是由于传递之后希望值发生改变,所以引用传递。
然后那个createLinkList函数中的参数是LINKLIST ,仅仅是按值传递,
A->B,为什么传递之后,可以用A中的linklist变量,来访问在B中添加 的节点?
分析得,按值传递,那么data,以及next 都会按值拷贝,然后传递前后的实参以及形参
中的 linklist 变量的next是两个不同内存单元的,但是next指向是同一个内存单元。
*/
typedef struct{
float xishu;
int zhishu;
} elementType;
typedef struct NODE_TAG{
elementType data;
NODE_TAG* next;
} NODE,*NODEPTR,*LINKLIST;
// 初始化linklist
int initLinkList(LINKLIST* linklist){
*linklist=(NODEPTR)malloc(sizeof(NODE));
if(!(*linklist))
return 0;
(*linklist)->next=NULL;
return 1;
}
//遍历linklist
void traverseLinkList(LINKLIST linklist){
cout<<endl<<"traverse the linklist :"<<endl;
NODEPTR pnode=linklist->next;
elementType element;
while(pnode){
element=pnode->data;
printf("xishu=%f , zhishu=%d\n",element.xishu,element.zhishu);
pnode=pnode->next;
}
cout<<endl;
}
// 创建一个降序的多项式linklist.
int createLinkList(LINKLIST linklist){
elementType element;
NODEPTR pNewNode;
NODEPTR pNodeIndex;
cout<<endl<<"输入 指数,然后输入系数,当指数为0.然后输入一个系数,表示输入结束"<<endl;
while(1){
cin>>element.xishu>>element.zhishu;
if(!element.xishu) return 1;
pNewNode=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode) return 0;
pNewNode->data=element;
pNodeIndex=linklist;
while(pNodeIndex->next!=NULL&&(element.zhishu< (pNodeIndex->next->data.zhishu))){
pNodeIndex=pNodeIndex->next;
}
pNewNode->next=pNodeIndex->next;
pNodeIndex->next=pNewNode;
}
}
/* 多项式想加:
只有在两个多项式的某一个节点的指数相同时,才需要相互加,然后创建新节点,添加到linklist3中,
如果某一个指数只有一个多项式的某个节点有,则仍然需要创建新节点。
*/
int addPolyn(LINKLIST linklist1,LINKLIST linklist2,LINKLIST linklist3){
NODEPTR pnodeIndex1,pnodeIndex2,pnodeIndex3;
pnodeIndex1=linklist1->next;
pnodeIndex2=linklist2->next;
pnodeIndex3=linklist3;
NODEPTR pNewNode3;
elementType element;
while(pnodeIndex1&&pnodeIndex2){
if(pnodeIndex1->data.zhishu>pnodeIndex2->data.zhishu){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex1->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex1=pnodeIndex1->next;
}
else if(pnodeIndex1->data.zhishu<pnodeIndex2->data.zhishu){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex2->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex2=pnodeIndex2->next;
}
else {
element.zhishu=pnodeIndex1->data.zhishu;
element.xishu=pnodeIndex1->data.xishu+pnodeIndex2->data.xishu;
if(element.xishu){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->data=element;
pNewNode3->next=NULL;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
}
pnodeIndex1=pnodeIndex1->next;
pnodeIndex2=pnodeIndex2->next;
}
}
while(pnodeIndex1){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex1->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex1=pnodeIndex1->next;
}
while(pnodeIndex2){
pNewNode3=(NODEPTR)malloc(sizeof(NODE));
if(!pNewNode3) return 0;
pNewNode3->next=NULL;
pNewNode3->data=pnodeIndex2->data;
pnodeIndex3->next=pNewNode3;
pnodeIndex3=pNewNode3;
pnodeIndex2=pnodeIndex2->next;
}
return 1;
}
int destroyLinkList(LINKLIST * linklist){
NODEPTR pnodeIndex,pPreNode;
pnodeIndex=*linklist;
while(pnodeIndex){
pPreNode=pnodeIndex;
pnodeIndex=pnodeIndex->next;
free(pPreNode);
}
*linklist=NULL;
return 1;
}
int main()
{
LINKLIST linklist1,linklist2,linklist3;
initLinkList(&linklist1);
initLinkList(&linklist2);
initLinkList(&linklist3);
createLinkList(linklist1);
traverseLinkList(linklist1);
createLinkList(linklist2);
traverseLinkList(linklist2);
cout<<"add linklist1 and linklist2 to linklist3"<<endl;
addPolyn(linklist1,linklist2,linklist3);
traverseLinkList(linklist3);
destroyLinkList(&linklist1);
destroyLinkList(&linklist2);
destroyLinkList(&linklist3);
cout << "Hello world!" << endl;
return 0;
}