devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构栈和队列_头歌java 数据结构之栈、队列

作者：不正经 | 2024-05-29 03:22:37

赞

踩

头歌java 数据结构之栈、队列

第四关

  1. #include<iostream>
  2. #include<fstream>
  3. using namespace std;
  4.  
  5. #define OK 1
  6. #define ERROR 0
  7. #define OVERFLOW -2
  8. #define MAXSIZE  5 //顺序栈存储空间的初始分配量
  9. typedef int Status;
  10. typedef char SElemType;
  11.  
  12.  
  13. typedef struct
  14. {int top[2],bot[2];			//栈顶和栈底指针
  15.  SElemType *V;			//栈数组
  16.  int m;					//栈最大可容纳元素个数
  17. }DblStack;
  18.  
  19. //栈初始化
  20. Status InitDblStack(DblStack &S,int m)
  21. {
  22. 	// ###### Begin ###### 
  23.     S.m = MAXSIZE;
  24.     S.V = new SElemType[MAXSIZE];
  25.     if(!S.V) return ERROR;
  26.  
  27.     S.bot[0] = 0,S.bot[1] = m - 1;
  28.     S.top[0] = -1,S.top[1] = m;
  29.     
  30.     return OK;
  31.     //###### End ######
  32. }
  33.  
  34. Status DblPush(DblStack &S,int i,SElemType x)
  35. {
  36. 	// ###### Begin ###### 
  37.     if(S.top[0] + 1 == S.top[1]) return ERROR;
  38.  
  39.     if(i == 0) S.V[S.top[0] ++ ] = x;
  40.     else S.V[S.top[1] -- ] = x;
  41.     
  42.     return OK;
  43.     
  44.     //###### End ######
  45. }
  46.  
  47. Status DblPop(DblStack &S,int i,SElemType &x)
  48. {
  49. 	// ###### Begin ###### 
  50.     if(i == 0)
  51.     {
  52.         if(S.top[0] == -1) return ERROR;
  53.         x = S.V[S.top[0] -- ];
  54.     }
  55.     else
  56.     {
  57.         if(S.top[1] == S.m) return ERROR;
  58.         x = S.V[S.top[1] ++ ];
  59.     }
  60.     
  61.     return OK;
  62.     //###### End ######
  63. }
  64. int IsEmpty(DblStack S,int i)
  65. {
  66. 	// ###### Begin ###### 
  67.     if(i == 0 && S.top[0] == -1 || i == 1 && S.top[1] == S.m) return true;
  68.     
  69.     return false;
  70.     
  71.     //###### End ######
  72. }
  73. int IsFull(DblStack S) 
  74. {
  75. 	// ###### Begin ###### 
  76.     if(S.top[0] + 1 == S.top[1]) return true;
  77.     
  78.     return false;
  79.     
  80.     //###### End ######
  81. }
  82.  
  83. int main() {
  84. 	DblStack s;
  85. 	int choose, flag = 0;
  86. 	int i,m; 
  87. 	SElemType j, e, t;
  88. 	
  89. 	choose = -1;
  90. 	while (choose != 0) {
  91. 		
  92. 		cin >> choose;
  93. 		switch (choose) {
  94. 		case 1://栈的初始化
  95. 		{
  96. 			
  97. 	        cin >> m;	
  98. 	        if(InitDblStack(s,m)){ 
  99. 	            flag=1; 
  100. 	            cout << "初始化栈成功!" << endl;} 
  101. 	        else
  102. 	            cout << "初始化栈失败!" << endl;
  103. 	        break;
  104. 		}
  105. 		case 2: {//入栈
  106. 		    if(flag){
  107. 			   
  108. 	            cin >> i >> e; 
  109. 	            if(DblPush(s,i,e))
  110. 	                cout << e << "入栈成功" << endl;
  111. 	            else
  112. 	                cout <<  "栈已满，入栈失败" << endl;
  113. 			}
  114. 			else
  115. 				cout << "栈未建立，请重新选择\n\n";
  116. 			break;
  117. 	    }
  118. 	    case 3:{//出栈
  119. 			if(flag != -1 && flag != 0){
  120. 			
  121. 			    
  122. 	            cin >> i;
  123. 	            if(DblPop(s,i,e))
  124. 	                cout << e << "出栈成功！" << endl;
  125. 	            else
  126. 	                cout <<"栈中无元素！" << endl;
  127. 				}				
  128. 			else
  129. 				cout << "栈中无元素\n" << endl;
  130. 			break;
  131. 	    }
  132. 	    case 4:{//判空 
  133. 	    
  134. 	    	cin >> i;
  135. 	    	if(IsEmpty(s,i))
  136. 	    	    cout << i << "号栈为空栈"<< endl;
  137. 			else
  138. 			    cout << i << "号栈不为空栈" << endl; 
  139. 			break;
  140. 		}
  141. 		case 5:{//判满 
  142. 		    if(IsFull(s))
  143. 	    	    cout << "栈满" << endl;
  144. 			else
  145. 			    cout << "栈不满" << endl; 
  146. 			break;
  147. 		}
  148. 		default:exit(0); 
  149. 	    }
  150. 	} 
  151. } 
  152.

第五关

  1. //顺序栈定义
  2. #include<iostream>
  3. #include<cstring>
  4. using namespace std;
  5. #define OK 1
  6. #define ERROR 0
  7. #define OVERFLOW -2
  8. #define MAXSIZE  100 //顺序栈存储空间的初始分配量
  9. typedef int Status;
  10. typedef char SElemType;
  11.  
  12. typedef struct {
  13. 	SElemType *base;//栈底指针
  14. 	SElemType *top;//栈顶指针
  15. 	int stacksize;//栈可用的最大容量
  16. } SqStack;
  17.  
  18. //算法3.1　顺序栈的初始化
  19. Status InitStack(SqStack &S) {
  20. 	//构造一个空栈S
  21. 	S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
  22. 	if (!S.base)
  23. 		exit(OVERFLOW); //存储分配失败
  24. 	S.top = S.base; //top初始为base，空栈
  25. 	S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
  26. 	return OK;
  27. }
  28.  
  29. //算法3.2　顺序栈的入栈
  30. Status Push(SqStack &S, SElemType e) {
  31. 	// 插入元素e为新的栈顶元素
  32. 	if (S.top - S.base == S.stacksize)
  33. 		return ERROR; //栈满
  34. 	*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
  35. 	return OK;
  36. }
  37.  
  38. //算法3.3　顺序栈的出栈
  39. Status Pop(SqStack &S, SElemType &e) {
  40. 	//删除S的栈顶元素，用e返回其值	
  41. 	if (S.base == S.top)
  42. 		return ERROR;//栈空
  43. 	e = *(--S.top); //栈顶指针减1，将栈顶元素赋给e
  44. 	return OK;
  45. }
  46.  
  47. int EmptyStack(SqStack S){
  48. 	return S.base==S.top;
  49. }
  50.  
  51. int IsPalindrome(char *t)
  52. {
  53. 	//###### Begin ###### 
  54.     int len = strlen(t);
  55.    
  56.     int i = 0,j = len - 1;
  57.     while(i < j)
  58.     {
  59.         if(t[i] != t[j]) return 0;
  60.         i ++ ,j -- ; 
  61.     } 
  62.     
  63.     return 1;
  64.    // ###### End ######
  65. }
  66.  
  67. int main(){
  68. 	
  69. 	char str[MAXSIZE];
  70. 	cin>>str;
  71. 	if(IsPalindrome(str))
  72. 	    cout<<"是回文"<<endl;
  73. 	else
  74. 	    cout<<"不是回文"<<endl;
  75. }

第六关

  1. #include<iostream>
  2.  
  3. using namespace std;
  4.  
  5. //顺序栈定义
  6. #define OK 1
  7. #define ERROR 0
  8. #define OVERFLOW -2
  9. #define MAXSIZE  100//顺序栈存储空间的初始分配量
  10. typedef int Status;
  11. void InoutS(int s[]){
  12. 	//###### Begin ###### 
  13.     int top = 0;
  14.  
  15.     int x;
  16.     while(cin >> x)
  17.     {
  18.         if(x != -1)
  19.         {
  20.             if(top == MAXSIZE - 1) cout << "栈满" << endl;
  21.             else s[top ++ ] = x;
  22.       
  23.         }
  24.         else 
  25.         {
  26.             if(top == 0) cout << "栈空" << endl;
  27.             else cout << "出栈元素是" << s[ -- top] << endl;
  28.         }
  29.     }
  30.     
  31.     
  32.     // ###### End ######
  33. }
  34. int main(){
  35. 	int s[MAXSIZE];
  36. 	InoutS(s);
  37. }

第七关

  1. #include<iostream>
  2.  
  3. #include<stdlib.h>
  4. using namespace std;
  5.  
  6. //顺序栈定义
  7. #define OK 1
  8. #define ERROR 0
  9. #define OVERFLOW -2
  10. #define MAXSIZE  100//顺序栈存储空间的初始分配量
  11. typedef int Status;
  12. typedef double SElemType;
  13.  
  14. typedef struct {
  15. 	SElemType *base;//栈底指针
  16. 	SElemType *top;//栈顶指针
  17. 	int stacksize;//栈可用的最大容量
  18. } SqStack;
  19.  
  20. //算法3.1　顺序栈的初始化
  21. Status InitStack(SqStack &S) {
  22. 	//构造一个空栈S
  23. 	S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
  24. 	if (!S.base)
  25. 		exit(OVERFLOW); //存储分配失败
  26. 	S.top = S.base; //top初始为base，空栈
  27. 	S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
  28. 	return OK;
  29. }
  30. //算法3.2　顺序栈的入栈
  31. Status Push(SqStack &S, SElemType e) {
  32. 	// 插入元素e为新的栈顶元素
  33. 	if (S.top - S.base == S.stacksize)
  34. 		return ERROR; //栈满
  35. 	*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
  36. 	return OK;
  37. }
  38. //算法3.3　顺序栈的出栈
  39. Status Pop(SqStack &S, SElemType &e) {
  40. 	//删除S的栈顶元素，用e返回其值	
  41. 	if (S.base == S.top)
  42. 		return ERROR;//栈空
  43. 	e = *(--S.top); //栈顶指针减1，将栈顶元素赋给e
  44. 	return OK;
  45. }
  46. //算法3.4　取顺序栈的栈顶元素
  47. double GetTop(SqStack S) {//返回S的栈顶元素，不修改栈顶指针
  48. 	if (S.top != S.base) //栈非空
  49. 		return *(S.top - 1); //返回栈顶元素的值，栈顶指针不变
  50. }
  51.  
  52. int get(char op,int a,int b)
  53. {
  54.     if(op == '+') return a + b;
  55.     else if(op == '-') return a - b;
  56.     else if(op == '*') return a * b;
  57.     else return a / b; 
  58. }
  59.  
  60. double Postfix(){
  61. 	
  62. //###### Begin ###### 
  63.     int *s = new int [MAXSIZE];
  64.     
  65.     char op;
  66.  
  67.     int t = 0,top = 0;
  68.     while(op = getchar(),op != '$')
  69.     {
  70.         if(op == ' ')
  71.         {
  72.             if(t) s[top ++ ] = t;
  73.             t = 0;
  74.             continue;
  75.         }
  76.  
  77.         if(op == '+' || op == '-' || op == '*' || op == '/')
  78.         {
  79.             if(t)
  80.             {
  81.                 s[top ++ ] = t;
  82.                 t = 0;
  83.             }
  84.  
  85.             int y = s[-- top],x = s[-- top];
  86.             s[top ++ ] = get(op,x,y); 
  87.         }
  88.         else t = t * 10 + (op - '0');
  89.     }
  90.  
  91.     int k = top - 1;
  92.     return s[k];
  93.     // ###### End ######
  94. }
  95. int main()
  96. {
  97. 	double x;
  98. 	x=Postfix();
  99. 	cout << x;
  100. }

第八关

  1. #include<iostream>
  2. using namespace std;
  3. #define MAXSIZE 100
  4. bool Judge(char A[])
  5. {
  6. 	//###### Begin ###### 
  7.     int k = 0;
  8.  
  9.     bool flag = true;
  10.     for(int i = 0;A[i] != '\0';i ++ )
  11.     {
  12.         if(A[i] == 'I') k ++ ;
  13.         else 
  14.         {
  15.             if(!k)
  16.             {
  17.                 flag = false;
  18.                 break;
  19.             }
  20.             k -- ;
  21.         }
  22.     }
  23.     
  24.     if(flag) cout << "序列合法" << endl;
  25.     else cout << "序列非法" << endl;
  26.     // ###### End ######
  27.  } 
  28.  main()
  29.  {
  30.  	char b[MAXSIZE];
  31.  	int i;
  32.  	cin >> b;
  33.  	i=Judge(b);
  34.  	
  35.  }

第九关

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. #define OK 1
  5. #define ERROR 0
  6. #define OVERFLOW -2
  7. typedef char QElemType;
  8. typedef int Status;
  9.  
  10.  
  11. typedef struct QNode{
  12. 	QElemType data;
  13. 	struct QNode *next;
  14. } QNode, *QueuePtr;
  15.  
  16. typedef struct {	
  17. 	QueuePtr rear; //只设队尾指针
  18. } LinkQueue;
  19.  
  20. void InitQueue(LinkQueue &Q) {//构造一个空队列Q
  21.     
  22.     	//###### Begin ###### 
  23.     Q.rear = new QNode;
  24.     Q.rear -> next = Q.rear;
  25.     
  26.     // ###### End ######
  27. 	
  28. }
  29.  
  30. int EmptyQueue(LinkQueue Q)
  31. {
  32. 		//###### Begin ###### 
  33.     if(Q.rear -> next == Q.rear) return OK;
  34.     
  35.     return ERROR;
  36.     // ###### End ######
  37. }
  38.  
  39. Status EnQueue(LinkQueue &Q,QElemType e)
  40. {
  41. 		//###### Begin ###### 
  42.     QueuePtr t = new QNode;
  43.     t -> data = e;
  44.     
  45.     t -> next = Q.rear -> next;
  46.     Q.rear -> next = t;
  47.     Q.rear = t;
  48.  
  49.     return OK;
  50.     // ###### End ######
  51. }
  52.  
  53. Status DeQueue(LinkQueue &Q,QElemType &e)
  54. {
  55. 		//###### Begin ###### 
  56.     if(EmptyQueue(Q)) return ERROR;
  57.  
  58.     QueuePtr p = Q.rear -> next;
  59.     QueuePtr t = p -> next;
  60.     e = t -> data;
  61.  
  62.     p -> next = t -> next;
  63.     if(p -> next == p) Q.rear = p;
  64.     delete t;
  65.  
  66.     return OK;
  67.     // ###### End ######
  68. }
  69. main()
  70. {
  71.     int choose, flag = 0;
  72. 	LinkQueue q;
  73. 	QElemType j;
  74.  
  75. 	choose = -1;
  76. 	while (choose != 0) {
  77. 		
  78. 		cin >> choose;
  79. 		switch (choose) {
  80. 		case 1:InitQueue(q);flag=1;cout<<"初始化成功\n";break;
  81. 		case 2:
  82. 		    if (flag) {
  83. 				flag = 1;
  84. 				
  85. 				cin >> j;
  86. 				EnQueue(q, j);
  87. 				cout << j<<"已入队\n";				
  88. 			}
  89. 		    else
  90. 				cout << "队列未建立，请重新选择\n\n";
  91. 			break;
  92. 		case 3:
  93. 			if (flag){
  94. 			    flag=1;
  95. 				if(DeQueue(q, j))
  96. 				    cout << j<<"已出队\n";				
  97. 				else
  98. 				    cout <<"队列已空，无可出队元素\n";
  99. 				}
  100. 		    else
  101. 				cout << "队列未建立，请重新选择\n\n";	
  102. 			break;
  103. 		case 4:
  104. 			if(EmptyQueue(q))
  105. 			    cout <<"此对为空队\n";
  106. 			else
  107. 			    cout<<"此对不空\n";
  108. 			break; 
  109. 	   }
  110.     }
  111. }

第十关

  1. #include<iostream>
  2. using namespace std;
  3.  
  4. #define MAXSIZE 5
  5. #define OK 1
  6. #define ERROR 0
  7. #define OVERFLOW -2
  8. typedef char ElemType;
  9. typedef int Status;
  10.  
  11. typedef struct{
  12. 	ElemType *base;
  13. 	int front,rear,tag;
  14. }SqQueue;
  15.  
  16. Status InitQueue(SqQueue &Q)
  17. {
  18. 	//###### Begin ###### 
  19.     Q.base = new ElemType [MAXSIZE];
  20.     Q.front = Q.rear = 0;
  21.     Q.tag = 0;
  22.     
  23.     return OK;
  24.     // ###### End ######
  25. }
  26. Status EnQueue(SqQueue &Q, ElemType e) {
  27. 	//###### Begin ###### 
  28.     if(Q.tag == 1) return ERROR;
  29.     
  30.     Q.base[Q.rear] = e;
  31.     Q.rear = (Q.rear + 1) % MAXSIZE;
  32.  
  33.     if(Q.front == Q.rear) Q.tag = 1;
  34.     else Q.tag = 2;
  35.  
  36.     return OK;
  37.     // ###### End ######
  38. }
  39. Status DeQueue(SqQueue &Q, ElemType &e)
  40. {
  41. 	//###### Begin ###### 
  42.     if(Q.tag == 0) return ERROR;
  43.     
  44.     e = Q.base[Q.front];
  45.     Q.front = (Q.front + 1) % MAXSIZE;
  46.     if(Q.front == Q.rear) Q.tag = 0;
  47.  
  48.     return OK;
  49.     // ###### End ######
  50. }
  51. main()
  52. {
  53.     SqQueue q;
  54.     int choose,flag;
  55.     ElemType j;
  56.     
  57. 	choose = -1;
  58. 	while (choose != 0) {
  59. 		
  60. 		cin >> choose;
  61. 		switch (choose) {
  62. 		case 1:
  63. 			if (InitQueue(q)) {
  64. 				flag = 1;
  65. 				cout << "成功对队列进行初始化\n";
  66. 			} else
  67. 				cout << "初始化队列失败\n";
  68. 			break;
  69. 		case 2:
  70. 		    if (flag) {
  71. 				flag = 1;
  72. 				
  73. 				cin >> j;
  74. 				if(EnQueue(q, j))
  75. 				    cout << j<<"已入队\n";				
  76. 				else
  77. 				    cout <<"队列已满，不可入队\n";
  78. 				}
  79. 		    else
  80. 				cout << "队列未建立，请重新选择\n";
  81. 			break;
  82. 		case 3:
  83. 			if (flag){
  84. 			    flag=1;
  85. 				if(DeQueue(q, j))
  86. 				    cout << j<<"已出队\n";				
  87. 				else
  88. 				    cout <<"队列已空，无可出队元素\n";
  89. 				}
  90. 		    else
  91. 				cout << "队列未建立，请重新选择\n";	
  92. 			break;
  93. 	   }
  94.     }
  95. }

第十一关

  1. #include<iostream>
  2. using namespace std;
  3.  
  4.  
  5. #define OK 1
  6. #define ERROR 0
  7. #define OVERFLOW -2
  8. #define MAXSIZE 10
  9. typedef char QElemType;
  10. typedef int Status;
  11.  
  12. typedef struct{
  13. 		//###### Begin ###### 
  14.     QElemType *base;
  15.     int front,rear;
  16.     
  17.     // ###### End ######
  18. }SqQueue;
  19. Status InitQueue(SqQueue &Q)
  20. {
  21. 		//###### Begin ###### 
  22.     Q.base = new QElemType [MAXSIZE];
  23.     Q.front = Q.rear = 0;
  24.     
  25.     return OK;
  26.     // ###### End ######
  27. }
  28.  
  29. Status EnQueue(SqQueue &Q,QElemType e)
  30. {
  31. 		//###### Begin ###### 
  32.     if((Q.front + 1) % MAXSIZE == Q.rear) return ERROR;
  33.  
  34.     Q.base[Q.front] = e;
  35.     Q.front = (Q.front + 1) % MAXSIZE;
  36.     
  37.     return OK;
  38.     // ###### End ######
  39. }
  40. Status DeQueue(SqQueue &Q,QElemType &e)
  41. {
  42. 		//###### Begin ###### 
  43.     if(Q.front == Q.rear) return ERROR;
  44.  
  45.     e = Q.base[Q.rear];
  46.     Q.rear = (Q.rear + 1) % MAXSIZE;
  47.     
  48.     return OK;
  49.     // ###### End ######
  50. }
  51. main()
  52. {
  53.     SqQueue q;
  54.     int choose,flag;
  55.     QElemType j;
  56.    
  57. 	choose = -1;
  58. 	while (choose != 0) {
  59. 		
  60. 		cin >> choose;
  61. 		switch (choose) {
  62. 		case 1:
  63. 			if (InitQueue(q)) {
  64. 				flag = 1;
  65. 				cout << "成功对队列进行初始化\n";
  66. 			} else
  67. 				cout << "初始化队列失败\n";
  68. 			break;
  69. 		case 2:
  70. 		    if (flag) {
  71. 				flag = 1;
  72. 				
  73. 				cin >> j;
  74. 				if(EnQueue(q, j))
  75. 				    cout << j<<"已入队\n";				
  76. 				else
  77. 				    cout <<"队列已满，不可入队\n";
  78. 				}
  79. 		    else
  80. 				cout << "队列未建立，请重新选择\n";
  81. 			break;
  82. 		case 3:
  83. 			if (flag){
  84. 			    flag=1;
  85. 				if(DeQueue(q, j))
  86. 				    cout << j<<"已出队\n";				
  87. 				else
  88. 				    cout <<"队列已空，无可出队元素\n";
  89. 				}
  90. 		    else
  91. 				cout << "队列未建立，请重新选择\n";	
  92. 			break;
  93. 	   }
  94.     }
  95. }

第十二关

  1. #include<iostream>
  2. #include<stdlib.h>
  3. #define M 100
  4. #define N 100
  5. using namespace std;
  6. int Ack(int m,int n)//递归算法 
  7. {
  8. 	//###### Begin ###### 
  9.     if(!m) return n + 1;
  10.     else if(!n) return Ack(m - 1,1);
  11.     else return Ack(m - 1,Ack(m,n - 1)); 
  12.     
  13.     
  14.     // ###### End ######
  15. }
  16.  
  17. main(){
  18. 	int m,n;
  19. 	int x,y;
  20. 	cin>>m>>n;
  21. 	x=Ack(m,n);
  22. 	cout << x <<endl;
  23. 	
  24. }

第十三关

  1. #include<iostream>
  2. #include<cstring>
  3. using namespace std;
  4. typedef struct LNode {
  5. 	int data; //结点的数据域
  6. 	struct LNode *next; //结点的指针域
  7. } LNode, *LinkList; //LinkList为指向结构体LNode的指针类型
  8.  
  9. void InitList(LinkList &f) //创建链表
  10. {
  11. 	f = new LNode;
  12. 	f->next = NULL;
  13. }
  14. void ListInput(LinkList &f,int n)
  15. {
  16. 	LinkList r,p;
  17. 	int i=1;
  18. 	r=p=f;
  19. 	cin >> p->data;
  20. 	while(i<n)
  21. 	{		
  22. 		p = new LNode;
  23. 		cin >> p->data;	    
  24. 	    p->next = NULL;
  25. 	    r->next = p;
  26. 	    r = p;
  27. 	    i++;
  28. 	}
  29. 	cout<<"完成输入\n";	
  30. }
  31.  
  32. int GetMax(LinkList p)
  33. {
  34. 	
  35. 	//###### Begin ###### 
  36.     LinkList t = p;
  37.  
  38.     int maxv = 0;
  39.  
  40.     while(t)
  41.     {
  42.         maxv = max(maxv,t -> data);
  43.         t = t -> next;
  44.     }
  45.     
  46.     return maxv;
  47.     // ###### End ######
  48. }
  49. int GetLength(LinkList p)
  50. {
  51. 	//###### Begin ###### 
  52.     LinkList t = p;
  53.  
  54.     int length = 0;
  55.  
  56.     while(t)
  57.     {
  58.         length ++ ;
  59.         t = t -> next;
  60.     }
  61.     
  62.     return length;
  63.     
  64.     
  65.     // ###### End ######	
  66. }
  67. double GetAverage(LinkList p,int n)
  68. {
  69. 	//###### Begin ###### 
  70.     LinkList t = p;
  71.  
  72.     double sum = 0;
  73.  
  74.     while(t)
  75.     {
  76.         sum += t -> data;
  77.         t = t -> next;
  78.     }
  79.     
  80.     return sum / n;
  81.     // ###### End ######
  82. }
  83. main()
  84. {
  85. 	LinkList L;
  86. 	int choose,tag=0,n;
  87. 	int max,len;
  88. 	double ave;
  89. 	choose=-1;
  90. 	while (choose != 0) {		
  91. 		cin >> choose;
  92. 		switch (choose) {
  93. 			case 1: InitList(L);tag=1;cout<<"初始化完成\n";break;
  94. 			case 2: 
  95. 			{
  96. 				if(tag==1)
  97. 				{				
  98. 			        cin>>n;
  99. 			        ListInput(L,n);
  100. 				}
  101. 				break;
  102. 			}
  103. 			case 3:
  104. 			{ 
  105. 			    if(tag==1)
  106. 			    {
  107. 				    max=GetMax(L);
  108. 				    cout<<"max="<<max<<endl;
  109. 				}			       
  110. 				break;
  111. 			}
  112. 			case 4:
  113. 			{
  114. 				if(tag==1)
  115. 				{
  116. 				    len=GetLength(L);
  117. 					cout<<"len="<<len<<endl;
  118. 				}				    
  119. 				break;				
  120. 			}
  121. 			case 5:
  122. 			{
  123. 			    if(tag==1)
  124. 			    {
  125. 			    	ave=GetAverage(L,len);
  126. 				    cout<<"ave="<<ave<<endl;
  127. 				} 				    
  128. 				break;	
  129. 			}			
  130. 		}
  131.     }
  132. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/640373
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号