数据结构编程实验

  1 #include <bits/stdc++.h>
  2 using namespace std;
  3 
  4 typedef int ElemType;//元素类型
  5 typedef struct LNode{
  6     ElemType data;
  7     struct LNode *next;
  8 }LNode,*LinkList;
  9 //声明
 10 LinkList Ran_createNode(int n);
 11 LinkList createNode(int n);
 12 void show(LinkList head);
 13 LinkList updown(LinkList head);
 14 LinkList erase_even(LinkList head);
 15 LinkList head,head1,head2;
 16 void insert_lower_bound(LNode *head,ElemType data);
 17 LinkList creat_lower_bound(int n);
 18 LinkList creatlow(int x1,int x2);
 19 LinkList creathigh(int x1,int x2);
 20 void fenjie(int n,LinkList head1,LinkList head2);
 21 int menu();
 22 void print(LinkList head,int n);
 23 LinkList duoxiang(int x1,int x2);
 24 
 25 int main(){
 26     while(menu());
 27 }
 28 
 29 //0.单链表的初始化
 30 LinkList LinkedListInit()
 31 {
 32     LinkList L;
 33     L = (LinkList)malloc(sizeof(LNode));    //申请结点空间
 34     if(L == NULL)                        //判断是否有足够的内存空间
 35         printf("申请内存空间失败/n");
 36     L->next = NULL;                     //将next设置为NULL,初始长度为0的单链表
 37     return L;
 38 }
 39 //1.1 随机产生长度为n的链表
 40 LinkList Ran_createNode(int n){
 41     LinkList L;      //头指针
 42     L=(LinkList)malloc(sizeof(LNode));
 43     L->next=NULL;  //初始化空链表
 44     LinkList r;       //新指针
 45     r=L;
 46     while(n--){
 47         LinkList p;
 48         p=(LinkList)malloc(sizeof(LNode));
 49         p->data=rand()%1000; //随机生成下一个
 50         if(rand()%2==0)p->data=-p->data;
 51         r->next=p;
 52         r=p;
 53     }
 54     r->next=NULL;
 55     return L;
 56 }
 57 //1.2 按输入生成长度为n的链表
 58 LinkList createNode(int n){
 59     LinkList L;      //头指针
 60     L=(LinkList)malloc(sizeof(LNode));
 61     L->next=NULL;  //初始化空链表
 62     LinkList r;       //新指针
 63     r=L;
 64     ElemType x;
 65     while(n--){
 66         LinkList p;
 67         cin >> x;
 68         p=(LinkList)malloc(sizeof(LNode));
 69         p->data=x; //随机生成下一个
 70         r->next=p;
 71         r=p;
 72     }
 73     r->next=NULL;
 74     return L;
 75 }
 76 //2.输出链表
 77 void show(LinkList head){
 78     LinkList p;
 79     for(p=head->next;p!=NULL;p=p->next){
 80         printf("%d\t",p->data);
 81     }
 82     printf("\n");
 83 }
 84 //3.逆置
 85 LinkList updown(LinkList head){
 86     LinkList p1,p2,p3;
 87     p1=head->next;
 88     p2=NULL;
 89     head->next=NULL;
 90     while(p1!=NULL){
 91         p3=p1->next;
 92         p1->next=p2;
 93         p2=p1;
 94         p1=p3;
 95     }
 96     head->next=p2;
 97     return head;
 98 }
 99 //4.删除所有偶数节点
100 LinkList erase_even(LinkList head){
101     LinkList p1;
102     for(p1=head;p1->next!=NULL;p1=p1->next){
103         while((p1->next->data)%2==0){
104             p1->next=p1->next->next;
105             if(p1->next==NULL)
106             break;
107         }
108         if(p1->next==NULL)
109             break;
110     }
111     return head;
112 }
113 //5.非递减有序插入
114 void insert_lower_bound(LNode *head,ElemType data){
115     LinkList p,pnew;
116     pnew=new LNode;
117     pnew->data=data;
118     int flag=0;
119     for(p=head;p->next!=NULL;p=p->next){
120         if(p->next->data>=data){
121             pnew->next=p->next;
122             p->next=pnew;
123             flag=1;
124             break;
125         }
126     }
127     if(flag==0){
128         pnew->next=NULL;
129         p->next=pnew;
130     }
131 }
132 //5.建立一个非递减有序单向链表。
133 LinkList creat_lower_bound(int n){
134     LinkList head=LinkedListInit();
135     while(n--){
136         insert_lower_bound(head,rand()%1000);
137     }
138     show(head);
139     return head;
140 }
141 //6.合并生成非递增 随机
142 LinkList creatlow(int x1,int x2){
143     printf("链表1：\n");
144     LinkList head1=creat_lower_bound(x1);
145     printf("链表2：\n");
146     LinkList head2=creat_lower_bound(x2);
147     LinkList p;
148     for(p=head2->next;p!=NULL;p=p->next){
149         insert_lower_bound(head1,p->data);
150     }
151     printf("合并后非递增链表如下：\n");
152     updown(head1);
153     show(head1);
154     return head1;
155 }
156 //7.合并生成非递减 随机
157 LinkList creathigh(int x1,int x2){
158     printf("链表1：\n");
159     LinkList head1=creat_lower_bound(x1);
160     printf("链表2：\n");
161     LinkList head2=creat_lower_bound(x2);
162     LinkList p;
163     for(p=head2->next;p!=NULL;p=p->next){
164         insert_lower_bound(head1,p->data);
165     }
166     printf("合并后非递减链表如下：\n");
167     show(head1);
168     return head1;
169 }
170 //8.分解为奇数偶数两个链表 随机
171 void fenjie(int n,LinkList head1,LinkList head2){
172     head1=LinkedListInit();
173     head2=LinkedListInit();
174     LinkList head=Ran_createNode(n);
175     printf("链表如下：\n");
176     show(head);
177     LinkList p,tmp,p1,p2;
178     p1=head1;p2=head2;
179     for(p=head->next;p!=NULL;p=p->next){
180         tmp=new LNode;
181         tmp->data=p->data;
182         if((tmp->data)%2==0){
183             p2->next=tmp;
184             p2=tmp;
185         }
186         else{
187             p1->next=tmp;
188             p1=tmp;
189         }
190     }
191     p1->next=NULL;p2->next=NULL;
192     printf("奇数链表如下：\n");
193     show(head1);
194     printf("偶数链表如下：\n");
195     show(head2);
196 }
197 //10.菜单
198 int menu(){
199     srand((unsigned)time(NULL));
200     printf("\n------------------------------------------------------------------------------\n");
201     printf("请输入需要进行的操作：\n");
202     printf("0．随机产生元素建立一个带头结点的单向链表（无序）。\n");
203     printf("1．键盘输入一组元素，建立一个带头结点的单向链表（无序）。\n");
204     printf("2．输出单向链表的元素。\n");
205     printf("3．把单向链表中元素逆置。\n");
206     printf("4．在单向链表中删除所有的偶数元素结点。\n");
207     printf("5．建立一个非递减有序单向链表。\n");
208     printf("6．建立两个非递减有序单向链表，然后合并成一个非递增链表。\n");
209     printf("7．建立两个非递减有序单向链表，然后合并成一个非递减链表。\n");
210     printf("8．建立一个链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数。\n");
211     printf("9．采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。\n");
212     printf("其他.退出\n");
213     printf("------------------------------------------------------------------------------\n");
214     int x,x1,x2;
215     cin >> x;
216     int n;
217     switch(x){
218     case 0:printf("请输入n以建立长度为n的链表\n");cin >> n;head=Ran_createNode(n);show(head);break;
219     case 1:printf("请输入n以建立长度为n的链表\n");cin >> n;printf("接下来请输入n个数以建立长度为n的链表\n");head=createNode(n);show(head);break;
220     case 2:show(head);break;
221     case 3:head=updown(head);show(head);break;
222     case 4:head=erase_even(head);show(head);break;
223     case 5:printf("请输入n以建立长度为n的链表\n");cin >> n;head=creat_lower_bound(n);break;
224     case 6:printf("请输入两个数x1,x2以建立建立两个非递增有序单向链表\n");cin >> x1 >>x2;creatlow(x1,x2);break;
225     case 7:printf("请输入两个数x1,x2以建立建立两个非递减有序单向链表\n");cin >> x1 >>x2;creathigh(x1,x2);break;
226     case 8:printf("请输入n以建立长度为n的链表\n");cin >> n;fenjie(n,head1,head2);break;
227     case 9:printf("请输入两个数x1,x2以建立两个一元多项式\n");cin >> x1 >> x2;duoxiang(x1,x2);break;
228 
229     default:return 0;
230     }
231     return 1;
232 }
233 
234 
235 
236 
237 
238 
239 //输出多项式
240 void print(LinkList head,int n)
241 {
242     int flag=0;
243     LinkList p;
244     for(p=head->next;p!=NULL;p=p->next,n--){
245         if(p->data==0)continue;
246         flag=1;
247         if(p!=head->next&&p->data>0)
248             cout << ‘+‘;
249         if(n==0)
250             cout << p->data;
251         else{
252             if(p->data==1)
253                 cout <<‘x‘;
254             else if(p->data==-1)
255                 cout << "-x";
256             else
257                 cout << p->data <<‘x‘;
258             if(n!=1)
259                 cout << ‘^‘ << n;
260         }
261     }
262     if(!flag){
263         cout << 0 ;
264     }
265     cout <<endl;
266 }
267 //9.多项式
268 LinkList duoxiang(int x1,int x2)
269 {
270     LinkList head1=Ran_createNode(x1);
271     printf("A: ");
272     print(head1,x1);
273     LinkList head2=Ran_createNode(x2);
274     printf("B: ");
275     print(head2,x2);
276     LinkList p,p1;
277     int n=max(x1,x2);
278     if(x1<x2){
279     p1=head1->next;
280     for(p=head2->next;p!=NULL;p=p->next,x2--){
281         if(x1==x2){
282             p->data=p1->data+p->data;
283             x1--;
284         }
285     }
286     printf("A+B: ");
287     print(head2,n);
288     return head2;
289     }
290     else{
291     p1=head2->next;
292     for(p=head1->next;p!=NULL;p=p->next,x1--){
293         if(x1==x2){
294             p->data=p1->data+p->data;
295             x2--;
296         }
297     }
298     printf("A+B: ");
299     print(head1,n);
300     return head1;
301     }
302 }

  1 #include <iostream>
  2 #include <cstdio>
  3 #include <string>
  4 #include <cstring>
  5 using namespace std;
  6 #define MAX 100 //栈的最大值
  7 
  8 typedef int ElemType;
  9 //节点
 10 class Node{
 11 public:
 12     ElemType data;
 13     Node *next;
 14 };
 15 //基于链表实现的栈
 16 class Stack{
 17 public:
 18     //构造器
 19     Stack(){
 20         Stack_top=NULL;
 21     }
 22     //出栈
 23     void pop(){
 24         if(Stack_top!=NULL){
 25             Node *p=Stack_top;
 26             Stack_top=Stack_top->next;
 27             delete p;
 28         }
 29     }
 30     //入栈
 31     void push(ElemType x){
 32         Node *p=new Node;
 33         p->next=Stack_top;
 34         p->data=x;
 35         Stack_top=p;
 36     }
 37     //得到栈末数据
 38     ElemType top(){
 39         if(Stack_top)
 40             return Stack_top->data;
 41         else
 42             return 0;
 43     }
 44     //判栈空
 45     bool isEmpty(){
 46         return Stack_top==NULL;
 47     }
 48 private:
 49     //栈顶指针
 50     Node *Stack_top;
 51 };
 52 //基于链表实现的队列
 53 class Queue{
 54 public:
 55     //构造器
 56     Queue(){
 57         Queue_top=new Node;
 58         Queue_end=Queue_top;
 59         Queue_top->next=NULL;
 60         Queue_top->data=0;
 61         num=0;
 62     }
 63     //出队
 64     void pop(){
 65         if(num){
 66             Node *p=Queue_top;
 67             Queue_top=Queue_top->next;
 68             delete p;
 69             num--;
 70         }
 71     }
 72     //入队
 73     void push(ElemType x){
 74         Node *p=new Node;
 75         p->data=x;
 76         Queue_end->next=p;
 77         Queue_end=p;
 78         Queue_end->next=NULL;
 79         if(num==0){
 80             Queue_top=Queue_top->next;
 81         }
 82         num++;
 83     }
 84     //得到队首数据
 85     ElemType top(){
 86         if(num)
 87             return Queue_top->data;
 88         else
 89             return 0;
 90     }
 91     //判队空
 92     bool isEmpty(){
 93         return num!=0;
 94     }
 95 private:
 96     //队首指针
 97     Node *Queue_top;
 98     //队末指针
 99     Node *Queue_end;
100     int num;
101 };
102 
103 //顺序栈
104 typedef struct
105 {
106     ElemType *base;
107     int top;
108 }SqStack;
109 //顺序队列
110 typedef struct
111 {
112     ElemType *base;
113     int fron,rear;
114 }SqQueue;
115 //顺序栈初始化
116 void st_init(SqStack &st){
117     st.base=new ElemType[MAX];
118     st.top=-1;
119 }
120 //顺序栈出栈
121 bool st_pop(SqStack &st){
122     if(st.top<0){
123         return false;
124     }
125     st.top--;
126     return true;
127 }
128 //顺序栈入栈
129 bool st_push(SqStack &st,ElemType x){
130     if(st.top>=MAX-1){
131         return false;
132     }
133     st.top++;
134     st.base[st.top]=x;
135     return true;
136 }
137 //得到栈顶元素
138 ElemType st_top(SqStack &st){
139     return st.base[st.top];
140 }
141 
142 //顺序队列初始化
143 void Q_init(SqQueue &q){
144     q.base=new ElemType[MAX];
145     q.fron=q.rear=0;
146 }
147 //顺序队列出队
148 bool Q_pop(SqQueue &q){
149     if(q.fron==q.rear){
150         return false;
151     }
152     q.fron=(q.fron+1)%MAX;
153     return true;
154 }
155 //顺序队列入队
156 bool Q_push(SqQueue &q,ElemType x){
157     if((q.fron-q.rear+MAX)%MAX==1){
158         return false;
159     }
160     q.base[q.rear]=x;
161     q.rear=(q.rear+1)%MAX;
162     return true;
163 }
164 
165 //得到队首元素
166 ElemType Q_top(SqQueue &q){
167     return q.base[q.fron];
168 }
169 
170 //后缀表达式求值
171 int solve(char* x)
172 {
173     Stack st;
174     int ans=0,flag=0,i;
175     for(i=0;i<strlen(x);i++)
176     {
177         if(x[i]>=‘0‘&&x[i]<=‘9‘)
178         {
179             ans=ans*10+x[i]-‘0‘;
180             flag=1;
181         }
182         else
183         {
184             if(flag)
185             {
186                 st.push(ans);
187                 flag=0;
188             }
189             ans=0;
190         }
191         if(x[i]==‘+‘)
192         {
193             int a=st.top();
194             st.pop();
195             int b=st.top();
196             st.pop();
197             st.push(a+b);
198         }
199         else if(x[i]==‘-‘)
200         {
201             int a=st.top();
202             st.pop();
203             int b=st.top();
204             st.pop();
205             st.push(b-a);
206         }
207         else if(x[i]==‘*‘)
208         {
209             int a=st.top();
210             st.pop();
211             int b=st.top();
212             st.pop();
213             st.push(a*b);
214         }
215         else if(x[i]==‘/‘)
216         {
217             int a=st.top();
218             st.pop();
219             int b=st.top();
220             st.pop();
221             st.push(b/a);
222         }
223     }
224     return st.top();
225 
226 }
227 //中缀转后缀
228 void trans(char* x,char *y)
229 {
230     Stack st;
231     int ans=0,flag=0,i,j=0;
232     for(i=0;i<strlen(x);i++)
233     {
234         while(x[i]>=‘0‘&&x[i]<=‘9‘)
235         {
236             ans=ans*10+x[i]-‘0‘;
237             flag=1;
238             i++;
239         }
240         if(flag)
241         {
242             Stack tmp;
243             while(ans>0)
244             {
245                 tmp.push(ans%10);
246                 ans/=10;
247             }
248             while(!tmp.isEmpty())
249             {
250                 y[j++]=tmp.top()+‘0‘;
251                 tmp.pop();
252             }
253             y[j++]=‘ ‘;
254         }
255         if(x[i]==‘*‘||x[i]==‘/‘||x[i]==‘(‘)
256         {
257             st.push(x[i]);
258         }
259 
260         else if(x[i]==‘+‘||x[i]==‘-‘)
261         {
262             if(st.top()==‘*‘||st.top()==‘/‘)
263             {
264                 while(!st.isEmpty()&&st.top()!=‘(‘)
265                 {
266                     y[j++]=st.top();
267                     st.pop();
268                 }
269                 st.pop();
270                 st.push(x[i]);
271             }
272             else
273                 st.push(x[i]);
274         }
275         else if(x[i]==‘)‘)
276         {
277             while(!st.isEmpty()&&st.top()!=‘(‘)
278             {
279                 y[j++]=st.top();
280                 st.pop();
281             }
282             st.pop();
283         }
284     }
285     while(!st.isEmpty())
286     {
287         y[j++]=st.top();
288         st.pop();
289     }
290     y[j]=‘\0‘;
291 }
292 int main()
293 {
294     int x;
295     while(true){
296         printf("------------------------------\n");
297         printf("实验二：链式存储栈、队列的实现\n");
298         printf("输入 1：测试链式栈；\n");
299         printf("输入 2：测试链式队列；\n");
300         printf("输入 3：测试顺序栈；\n");
301         printf("输入 4：测试顺序队列；\n");
302         printf("输入 5：后缀表达式求和；\n");
303         printf("输入 6：中缀表达式求和；\n");
304 
305 
306         printf("------------------------------\n");
307         cin >> x;
308         switch(x)
309         {
310         case 1:{
311             Stack st;
312             printf("输入一个整数来表示要进行的操作\n");
313             printf("1代表入栈，2代表出栈，3代表结束\n");
314             int a,tmp;
315             while(true){
316                 cin >> a;
317                 if(a==3)
318                     break;
319                 switch(a)
320                 {
321                 case 1:
322                     printf("请输入要入栈的数:");
323                     cin >>tmp;
324                     st.push(tmp);
325                     break;
326                 case 2:
327                     printf("%d\n",st.top());
328                     st.pop();
329                 }
330             }
331             break;
332         }
333 
334         case 2:{
335             Queue q;
336             printf("输入一个整数来表示要进行的操作\n");
337             printf("1代表入队，2代表出队，3代表结束\n");
338             int a,tmp;
339             while(true){
340                 cin >> a;
341                 if(a==3)
342                     break;
343                 switch(a)
344                 {
345                 case 1:
346                     printf("请输入要入队的数:");
347                     cin >>tmp;
348                     q.push(tmp);
349                     break;
350                 case 2:
351                     printf("%d\n",q.top());
352                     q.pop();
353                 }
354             }
355             break;
356         }
357         case 3:{
358             SqStack st;
359             st_init(st);
360             printf("输入一个整数来表示要进行的操作\n");
361             printf("1代表入栈，2代表出栈，3代表结束\n");
362             int a,tmp;
363             while(true){
364                 cin >> a;
365                 if(a==3)
366                     break;
367                 switch(a)
368                 {
369                 case 1:
370                     printf("请输入要入栈的数:");
371                     cin >>tmp;
372                     if(!st_push(st,tmp)){
373                         printf("栈满\n");
374                     }
375                     break;
376                 case 2:
377                     if(st.top==-1){
378                         printf("栈空\n");
379                         break;
380                     }
381                     printf("%d\n",st_top(st));
382                     st_pop(st);
383                 }
384             }
385             break;
386         }
387         case 4:{
388             SqQueue q;
389             Q_init(q);
390             printf("输入一个整数来表示要进行的操作\n");
391             printf("1代表入队，2代表出队，3代表结束\n");
392             int a,tmp;
393             while(true){
394                 cin >> a;
395                 if(a==3)
396                     break;
397                 switch(a)
398                 {
399                 case 1:
400                     printf("请输入要入队的数:");
401                     cin >>tmp;
402                     if(!Q_push(q,tmp)){
403                         printf("队满\n");
404                     }
405                     break;
406                 case 2:
407                     if(q.fron==q.rear){
408                         printf("队空\n");
409                         break;
410                     }
411                     printf("%d\n",Q_top(q));
412                     Q_pop(q);
413                 }
414             }
415             break;
416         }
417         case 5:{
418             char x[10000];
419             getchar();
420             gets(x);
421             printf("%d\n",solve(x));
422             break;
423         }
424         case 6:{
425             char x[10000];
426             char y[10000];
427 
428             getchar();
429             gets(x);
430             trans(x,y);
431             puts(y);
432             printf("%d\n",solve(y));
433             break;
434         }
435 
436         default:
437             return 0;
438         }
439     }
440 
441     return 0;
442 }