0601
用顺序表实现 A = A U B。
假设合并后的顺序表的长度不会超出序表可能达到的最大长度。
输入要求：
多组输入。
每组输入数据由3行组成。
第一行，输入两个整数a和b，分别代表顺序表A和B的长度。
第二行和第三行，分别输入a个和b个整数。
详见代码和样例输入。
输出要求：
每组数据输出2行，分别是合并后的顺序表A和原顺序表B。每个元素后一个空格，每个表输出结束结束后换行。
空表用空行表示
输入：
3 3
1 3 5
5 4 3
输出：
1 3 5 4
5 4 3
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 10 // 顺序表可能达到的最大长度
typedef int ElemType; // 元素数据类型
typedef struct {
ElemType *elem; //指向数据元素的基地址
int length; // 当前长度
} SqList; // 顺序表
void createSqList(SqList &L, int n); // 根据用户输入，创建n个整数顺序表
void printSqList(SqList L); // 打印顺序表
void mergeSqList(SqList &LA, SqList LB);// 实现 A=AUB
int main(){
int a,b;
while(~scanf("%d%d",&a,&b)){
SqList LA, LB;
createSqList(LA, a);
createSqList(LB, b);
mergeSqList(LA, LB);
printSqList(LA);
printSqList(LB);
}
}
void createSqList(SqList &L, int n) // 根据用户输入，创建n个整数顺序表
{
L.elem= new ElemType;
L.length=n;
for(int i=0;i<n;i++)
{
scanf("%d",&L.elem[i]);
}
}
void printSqList(SqList L) // 打印顺序表
{
for(int i=0;i<L.length;i++)
{
printf("%d ",L.elem[i]);
}
printf("\n");
}
void mergeSqList(SqList &LA, SqList LB)// 实现 A=AUB
{
int i,j;
for(i=0;i<LB.length;i++)
{
for(j=0;j<LA.length;j++)
{
if(LB.elem[i]==LA.elem[j]) break;
}
if(j==LA.length)
{
LA.elem[LA.length]=LB.elem[i];
LA.length++;
}
}
}
0602
用链表实现 A = A U B。。
输入要求：
多组输入。
每组输入数据由3行组成。
第一行，输入两个整数a和b，分别代表链表A和B的长度。
第二行和第三行，分别输入a个和b个整数。
输出要求：
每组数据输出2行，分别是合并后的链表A和原链表B。每个元素后一个空格，每个表输出结束结束后换行。 空表用空行表示。
数据示例1：
输入：
3 3
1 3 5
5 4 3
输出：
1 3 5 4
5 4 3
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType; // 元素数据类型
typedef struct LNode{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode,*LinkList;
void createLinkList(LinkList &L, int n); // 创建n个整数链表，顺序与用户输入一致
void printLinkList(LinkList L); // 打印顺序表
void mergeLinkList(LinkList &LA, LinkList LB);// 实现 A=AUB
int main(){
int a,b;
while(~scanf("%d%d",&a,&b)){
LinkList LA, LB;
createLinkList(LA, a);
createLinkList(LB, b);
mergeLinkList(LA, LB);
printLinkList(LA);
printLinkList(LB);
}
}
//
void createLinkList(LinkList &L, int n) // 创建n个整数链表，顺序与用户输入一致
{
L=new LNode;
L->next=NULL;
LNode *r=L;
for(int i=0;i<n;i++){
LNode *p=new LNode;
scanf("%d",&p->data);
p->next=NULL;
r->next=p;
r=r->next;
}
}
void printLinkList(LinkList L) // 打印顺序表
{
LNode *p=L->next;
while(p){
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
void mergeLinkList(LinkList &LA, LinkList LB)// 实现 A=AUB
{
LNode *pa=LA;
LNode *pb=LB;
LNode *r=LA;
while(r->next) r=r->next;//找到LA中最后一个元素
while(pb){
while(pa){
if(pb->data==pa->data) break;
pa=pa->next;
}
if(!pa){
r->next=new LNode;
r=r->next;
r->data=pb->data;
r->next=NULL;
}
pb=pb->next;
pa=LA;
}
}
0603
合并两个按非降序排列的有序顺序表，结果扔按非降序排列。
输入要求：
一个整数m（0<m<=10）和m个按非降序排列的整数；
一个整数n（0<n<=10）和n个按非降序排列的整数；
输出要求：
2个输入的序列及合并后的序列
数据示例1：
输入：
3
1 3 5
3
2 4 6
输出：
1 3 5
2 4 6
1 2 3 4 5 6
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 10
typedef int ElemType;
typedef struct {
ElemType *elem;
int length;
} SqList;
void createList(SqList &L, int n); // 创建
void printList(SqList L); // 打印
void merge(SqList A, SqList B, SqList &C); // 合并
int main(){
int n;
SqList A, B, C;
scanf("%d", &n);
createList(A, n);
scanf("%d", &n);
createList(B, n);
createList(C, 0);
merge(A,B,C);
printList(A);
printList(B);
printList(C);
}
void createList(SqList &L, int n)// 创建
{
L.elem=new ElemType;
L.length=n;
for(int i=0;i<n;i++)
{
scanf("%d",&L.elem[i]);
}
}
void printList(SqList L)// 打印
{
for(int i=0;i<L.length;i++)
{
printf("%d ",L.elem[i]);
}
printf("\n");
}
void merge(SqList A, SqList B, SqList &C)// 合并
{
int i=0,j=0,k=0;
while(i<A.length&&j<B.length){
if(A.elem[i]<B.elem[j]){
C.elem[k]=A.elem[i];
i++;k++;
}
else{
C.elem[k]=B.elem[j];
j++;k++;
}
}
while(i<A.length){
C.elem[k++]=A.elem[i++];
// i++;k++;
}
while(j<B.length){
C.elem[k++]=B.elem[j++];
// j++;k++;
C.length=k;
}
}
0604
合并两个按非降序排列的有序链表，结果扔按非降序排列。
输入要求：
一个整数 m 和m个按非降序排列的整数；
一个整数 n 和n个按非降序排列的整数；
输出要求：
2个输入的序列及合并后的序列
数据示例1：
输入：
3
1 3 5
3
2 4 6
输出：
1 3 5
2 4 6
1 2 3 4 5 6
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
void createList(LinkList &L, int n); // 创建链表
void printList(LinkList L); // 打印链表
void merge(LinkList A, LinkList B, LinkList &C); // 合并
int main(){
int n;
LinkList A, B, C;
scanf("%d", &n);
createList(A, n);
scanf("%d", &n);
createList(B, n);
createList(C, 0);
merge(A,B,C);
printList(A);
printList(B);
printList(C);
}
void createList(LinkList &L, int n) // 创建链表
{
L=new LNode;
L->next=NULL;
LNode *r=L;
for(int i=0;i<n;i++){
LNode *p=new LNode;
scanf("%d",&p->data);
p->next=NULL;
r->next=p;
r=r->next;
}
}
void printList(LinkList L) // 打印链表
{
LNode *p=L->next;
while(p){
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
void merge(LinkList A, LinkList B, LinkList &C) // 合并
{
LNode *pa=A->next;
LNode *pb=B->next;
LNode *pc=C;
while(pa&&pb){
if(pa->data<pb->data) {
pc->next=new LNode; pc=pc->next;
pc->data=pa->data; pa=pa->next; pc->next=NULL;
}
else{
pc->next=new LNode; pc=pc->next;
pc->data=pb->data; pb=pb->next;pc->next=NULL;
}
// pa=pa->next;pb=pb->next;
}
while(pa){
pc->next=new LNode; pc=pc->next;
pc->data=pa->data; pa=pa->next;pc->next=NULL;
}
while(pb){
pc->next=new LNode; pc=pc->next;
pc->data=pb->data; pb=pb->next;pc->next=NULL;
}
}
0605
将单链表就地逆置，要求不创建新的结点
输入要求：
先输入一个n，表示接下来要输入n个数
接下来输入n个数。
输出要求：
分别输出逆置前和逆置后链表中的元素。每个元素后一个空格，每个链表输出结束后换行。
数据示例1：
输入：
5
1 2 3 4 5
输出：
1 2 3 4 5
5 4 3 2 1
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType; // 元素数据类型
typedef struct LNode{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode,*LinkList;
void createLList(LinkList &L, int n); // 采用尾插法创建链表
void inverseLList(LinkList &L); // 链表就地逆置，不创建任何结点
void printLList(LinkList L); // 打印链表，每个数字后有一空格
int main(){
int n;
LinkList list;
scanf("%d",&n);
createLList(list, n);
printLList(list);
inverseLList(list);
printLList(list);
}
void createLList(LinkList &L, int n)// 采用尾插法创建链表
{
L=new LNode;
L->next=NULL;
LNode *r=L;
for(int i=0;i<n;i++){
LNode *p=new LNode;
scanf("%d",&p->data);
p->next=NULL;
r->next=p;
r=r->next;
}
}
void inverseLList(LinkList &L)// 链表就地逆置，不创建任何结点
{
LNode *H=L->next;
L->next=NULL;
LNode *p=new LNode;
while(H){
p=H;H=H->next;
p->next=L->next;
L->next=p;
}
}
void printLList(LinkList L) // 打印链表，每个数字后有一空格
{
LNode *p=L->next;
while(p){
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
0606
多项式相加
注意：使用链表
输入要求：
首先输入2个整数m和n（0<m, n<=1000000000）分别代表2个多项式的项数。
然后，输入m+n行数据，前m行表示第一个多项式，后n行表示第二个多项式。
每行1个整数c和一个非负整数e（e>=0），分别表示多项式每一项的系数和指数（指数按升序排列）。
样例输入
3 4
1 1
2 3
3 5
1 0
-6 1
1 2
-3 5
输出要求：
输入的两个多项式和结果多项式，均按指数升序排列。
样例输出：
x+2x^3+3x^5
1-6x+x^2-3x^5
1-5x+x^2+2x^3
#include<stdio.h>
#include<stdlib.h>
typedef struct LNode{
int coef,index; //数据域
struct LNode *next; //指针域
}LNode,*LinkList;
void create(LinkList &ll,int n);
void add(LinkList l1,LinkList l2,LinkList &L);
void print(LinkList L);
int main(){
int n,m;
while(~scanf("%d %d", &n , &m)){
LinkList l1,l2,l3;
create(l1, n);
create(l2, m);
add(l1,l2,l3);
print(l1);
print(l2);
print(l3);
}
return 0;
}
void create(LinkList &ll,int n)
{
ll=new LNode;
LNode *l=ll;
int a,b;
while(n--)
{
scanf("%d %d",&a,&b);
if(a==0)continue;
l->next=new LNode;
l=l->next;
l->coef=a,l->index=b;
l->next=NULL;
}
}
void add(LinkList l1,LinkList l2,LinkList &L)
{
int cc=0;
L=new LNode;
LNode *p=L;
l1=l1->next,l2=l2->next;
while(l1&&l2){
p->next=new LNode;
if(l1->index<l2->index){//指数比较,小的先进行 ,l1小
p->next->coef=l1->coef;
p->next->index=l1->index;
l1=l1->next;
} else if(l1->index==l2->index){//指数相同的相加
int u=l1->coef+l2->coef;
if(u==0){//为0
p->next->coef=0;
p->next->index=0;
}else{//不为0
p->next->coef=u;
p->next->index=l1->index;
}
l1=l1->next;
l2=l2->next;
}else{//l2小
p->next->coef=l2->coef;
p->next->index=l2->index;
l2=l2->next;
}
p=p->next;
}
while(l1){
p->coef=l1->coef;
p->index=l1->index;
l1=l1->next;
p->next=new LNode;
p=p->next;
}
while(l2){
p->coef=l2->coef;
p->index=l2->index;
l2=l2->next;
p->next=new LNode;
p=p->next;
}
p->next=NULL;
}
void print(LinkList L)
{
int kk=0;
while(L->next!=NULL){
kk++;
L=L->next;
if(kk==1){//第一个数
if(L->coef==0){//a=0
continue;
}else if(L->coef==1){//a=1 剩下都有b是0 1 其他的情况
if(L->index==0){
printf("%d",L->coef);//就是1
}else if(L->index==1){
printf("x");
}else{
printf("x^%d",L->index);
}
}else{//a是其他情况
if(L->index==0){
printf("%d",L->coef);
}else if(L->index==1){
printf("%dx",L->coef);
}else{
printf("%dx^%d",L->coef,L->index);
}
}
} else{//不是第一个
if(L->coef>=0){//正数和0
if(L->coef==0){//a=0
continue;
}else if(L->coef==1){//a=1 剩下都有b是0 1 其他的情况
if(L->index==0){
printf("+%d",L->coef);//就是1
}else if(L->index==1){
printf("+x");
}else{
printf("+x^%d",L->index);
}
}else{//a是其他情况
if(L->index==0){
printf("+%d",L->coef);
}else if(L->index==1){
printf("+%dx",L->coef);
}else{
printf("+%dx^%d",L->coef,L->index);
}
}
}else{
{
if(L->index==0){
printf("%d",L->coef);
}else if(L->index==1){
printf("%dx",L->coef);
}else{
printf("%dx^%d",L->coef,L->index);
}
}
}
}
}
printf("\n");
}