函数实现.cpp

程序实现双向栈的基本操作：1）初始化；2）判断栈是否为空；3）判断栈是否已满；4）入栈；5）出栈；6）清空栈；7）取栈顶元素。还有几个比较巧妙操作....哦

 int	 STACK_INIT_SIZE = 20 ;// 存储空间初始分配量

 struct SqStack
 {
   SElemType *base1; // 左栈底指针
   SElemType *top1; // 左栈顶指针
   SElemType *base2; // 右栈底指针
   SElemType *top2; // 右栈顶指针
   int stacksize; // 当前已分配的存储空间，以元素为单位
 }; // 顺序栈

 int		init_a ;
 SqStack	s ;	
 SElemType	e ;
 int		i ,digit ,num_stack = 1 ;//定义全局变量，表示双向栈的方向，1表示左栈，2表示右栈
 char		c , c_digit[10];
 static int	Init_flag = 0 ;	

Status InitStack(SqStack &S)
 { // 构造一个空栈S
   if( !(S.base1 = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))) )
     exit(OVERFLOW); // 存储分配失败
   init_a = *(s.base1) ;
   S.top1=S.base1;
   S.base2=S.top1+STACK_INIT_SIZE-1 ;
	S.top2=S.base2;
   S.stacksize=STACK_INIT_SIZE;
   return OK;
 }

 Status DestroyStack(SqStack &S)
 { // 销毁栈S，S不再存在
   //free(S.base1);
   //free(S.base2);
   S.base1=NULL;
   S.top1=NULL;

   //S.base2=NULL;
   //S.top2=NULL;
   S.stacksize=0;
   return OK;
 }

 Status ClearStack(SqStack &S)
 { // 把S置为空栈
	 while( (S.top1 !=S.base1)&&(num_stack==1) )
		*(--s.top1) = -842150451 ;//-841450451为初始化的值
	 while( (S.top2 !=S.base2)&&(num_stack==2) )
		*(++s.top2) = -842150451 ;
   //S.top1=S.base1;
   //S.top2=S.base2;
   return OK;
 }

 Status StackEmpty(SqStack S)
 { 
   if((S.top1==S.base1)&&(S.top2==S.base2))
     return TRUE;
   else
     return FALSE;
 }

 int StackLength(SqStack S)
 { 
   return ((S.top1-S.base1)+(S.base2-S.top2)-1);
 }

 Status GetTop(SqStack S,SElemType &e)
 { 
   if(num_stack==1)
   {
		 if(S.top1>S.base1)
	   {
		 e=*(S.top1-1);
		 return OK;
	   }
	   else
		 return ERROR;
   }
   else
   {
	   if(S.top2<S.base2)
	   {
		 e=*(S.top2+1);
		 return OK;
	   }
	   else
		 return ERROR;
   }

 }

 Status Push(SqStack &S,SElemType e)
 { // 插入元素e为新的栈顶元素
   
	 if(num_stack==1)
	 {
		 //if(S.top1==S.top2)
		 if(S.top1 > S.top2) //栈满
	   {
		 printf("\n		栈满!不能继续进栈了，抱歉!\n");
		 printf("\n		如果您想继续进栈，就请先选择：7--清空双向栈 （单向）\n");
		 return ERROR;		 
	   }
	 
		*(S.top1++)=e;
	 }
	 else
	 {
		 if(S.top1 > S.top2) //栈满
	   {
		 printf("\n		栈满!不能继续进栈了，抱歉!\n");
		 return ERROR;		 
	   }
	 
		*(S.top2--)=e;		
	 }

   return OK;
 }

 Status Pop(SqStack &S,SElemType &e)
 { 
    SElemType *pop_top ;
	if(num_stack==1)
	{ 
		if(S.top1==S.base1)
			return ERROR;
		 e=*(--S.top1);
		 pop_top = S.top1 ;
	}
   else
   {
	   if(S.top2==S.base2)
		return ERROR;
	   e=*(++S.top2);
	   pop_top = S.top2 ;
   }
   *pop_top = -842150451 ;
   return OK;
 }

 Status visit(SElemType c)
 {
	 if(c == init_a)
	 {
		 printf("| ") ;
		 return OK ;
	 }
	printf("|%d",c);
	//cout << "|" << c ;
	return OK;
 }

 Status StackTraverse(SqStack S,Status(*visit)(SElemType))
 {    
	 SElemType *Tra_base ;
	 /*printf("base->");
	 if(num_stack==1)
	 {
		 Tra_base = S.base1 ;
		 while(Tra_base<S.top1)
		 visit(*(Tra_base++));
	 }
	 else
	 {
		 Tra_base = S.base2 ;
		 while(Tra_base!=S.top2)
		 visit(*(Tra_base--));
	 }
	 printf("| <-top");*/
	 printf("base1->");
	 Tra_base = S.base1 ;
	 while(Tra_base <= S.base2)
	 visit(*(Tra_base++));

	printf("|<-base2");
	printf("\n\n");
	printf("		!栈空间已用%d个存储空间! \n",STACK_INIT_SIZE-(s.top2-s.top1+1) ) ;//cout << "		栈空间还未满!\n" ;
	printf("\n		!栈空间还还剩%d个存储空间! \n",s.top2-s.top1+1) ;//或是(STACK_INIT_SIZE-i)
	return OK;
 }

 void nowtime()
{
	char date[9]; 
	char date_show[11];
	char time[9]; 	
	_strdate(date); 
	_strtime(time); 
	date_show[0]='2';date_show[1]='0';date_show[2]=date[6];
	date_show[3]=date[7];date_show[4]='-',date_show[5]=date[0],date_show[6]=date[1];
	date_show[7]='-',date_show[8]=date[3],date_show[9]=date[4],date_show[10]='\0';
	cout<<"		"<<"现在日期是"<<date_show; 
	cout<<"	"<<"现在时间是"<<time<<endl; 
}

 void menu()
 {
	system("cls");
	system("color 02");
	cout << "\n\n\n\n" ;
	cout<<"	┌─────────────────────────┐\n"
		<<"	│  *操作双向栈*       请选择功能以回车结束         │\n"
		<<"	├────────────┬────────────┤\n"
		<<"	│1--初始化双向栈         │2--入栈                 │\n"
		<<"	│3--取栈顶元素           │4--出栈                 │\n"
		<<"	│5--判断栈是否为空       │6--判断栈是否已满       │\n"
		<<"	│7--清空双向栈 （单向）  │8--选择左右栈进行操作   │\n"
		<<"	│0--显示双向栈内容       │9--退出系统             │\n"
		<<"	├────────────┴────────────┤\n" ;
	if (num_stack == 1)
	cout<<"	│              当前系统对左栈进行操作   ！         │\n" ;
	else
	cout<<"	│              当前系统对右栈进行操作   ！         │\n" ;

	cout<<"	├─────────────────────────┤\n"
		<<"	│           注意：系统默认对左栈进行操作！         │\n"
		<<"	└─────────────────────────┘\n" ;
	nowtime();
 }

  int play()
 {
	 int	i ;
	 void	say_goodbye() ;
	 menu() ;

	 do{
	 //cin.get(c);
		 cin >> c ;
		 if	(c!='1' && Init_flag!=1 && c!='9')
		 {
			printf("	双向栈尚未初始化，请先选择 1. 初始化双向栈!!! \n");
			system("pause");
			menu() ;
		 }
		 else
			 break ;
		}while(c!='1' && Init_flag!=1 && c!='9') ;

	 switch (c)
	 {
		case '0':			
			 StackTraverse(s,visit) ;	
			 break ;
		case '1':
			cin.ignore(100,'\n') ;
			i = 0 ;
			printf("\n请输入欲初始化双向栈存储空间的大小（默认为20个，即以回车直接）：" ) ;
			cin.get(c_digit[i]) ;
			if (c_digit[i]=='\n')
				STACK_INIT_SIZE = 20 ;
			while ( isdigit(c_digit[i])&&c_digit[i]!='\n') 
			{
				i++ ;
				cin.get(c_digit[i]) ; 	
				STACK_INIT_SIZE = atoi(c_digit) ;
			}
			 if(InitStack(s)==OK)
				printf("\n		成功初始化%d个存储空间双向栈!\n",STACK_INIT_SIZE);
			 else
			 {
				printf("\n		初始化失败!\n");
				break ;
			 }
		     StackTraverse(s,visit); // 依次对元素调用visit()，输出元素的值
			 Init_flag = 1 ;
			break ;
		case '2':
		   printf("\n 请依次输入进栈元素并分别以回车输入最后以非数字结束：\n");
		   cin >> c_digit ;
		   c = c_digit[0] ;
		while ( isdigit(c) )	//!((c >='A'&&c<='Z')||(c >='a'&&c<='z') )
			{					
				int		push_error = 0 ;
				digit = atoi(c_digit) ;

				i =	Push(s,digit);
				if	(i)	
				{
					//cout << "进栈成功！\n" ;
					printf("进栈成功!!!\n");
				}
				else
				{
					//cout << "进栈失败！\n" ;
					printf("\n		!!!进栈失败!!! \n");
					push_error = 1 ;
				}
				if (push_error)
					break ;
				cin >> c_digit ;
				c = c_digit[0] ;
			}
		
			StackTraverse(s,visit);

			break ;
		case '3':			
			i = GetTop(s,e) ;
			if (i)
				printf("\n取得当前栈顶元素为: %d \n",e);
			else
				printf("\n		!栈为空没有元素! \n");
			StackTraverse(s,visit) ;
			break ;
		case '4':
			printf("	栈顶出栈之前栈内存储情况为： \n") ;
			StackTraverse(s,visit);
			i =	Pop(s,e) ;
			if	(i)	
			{
				printf( "	栈顶元素为%d出栈成功！\n" ,e);
				printf("	栈顶出栈后栈内存储情况为： \n") ;
			}
			else
				printf("\n		栈为空!出栈失败! \n") ;//cout << "	栈为空!出栈失败!\n" ;
			StackTraverse(s,visit);

			break ;
		case '5':
			i =	StackEmpty(s) ;
			if	(!i)			
				printf( "		!栈不为空!\n" ,e);			
			else
				printf("\n		!栈为空! \n") ;//cout << "		!栈为空!\n" ;
			StackTraverse(s,visit);
			break ;
		case '6':
			i = StackLength(s) ;
			if	(i == STACK_INIT_SIZE)			
				printf( "		栈空间已满！\n");
			else
			{
				printf("\n		!栈空间还未满! \n") ;//cout << "		栈空间还未满!\n" ;
				printf("		!栈空间还还剩%d个存储空间! \n",s.top2-s.top1+1) ;//或是(STACK_INIT_SIZE-i)
			}
			StackTraverse(s,visit);
			
			break ;
		case '7':
			ClearStack(s);
			printf("		清空栈.........栈已清空\n");
			StackTraverse(s,visit) ;
			break ;
		case '8':
			printf(" \n	选择左右栈进行操作：1.对左栈进行操作；2.对右栈进行操作（q退回）：");
			cin >> c ;
			if	(c == 'q'||c == 'Q')
				break ;
			switch (c)
			{
			case '1':
				num_stack = 1 ;
				break ;
			case '2':
				num_stack = 2 ;
				break ;
			default:
				printf(" \n	您的输入有误，请重新输入选择 !\n");
			}
		printf(" \n			! 选择操作成功 !\n");
		break ;
		case '9':
			say_goodbye() ;
			return	0 ;
			//exit (1);
			break ;
		
		default:
			printf(" \n	您的输入有误，请重新输入选择 !\n");

	 }
	 system("pause");
	 //getch();
	 play() ;
	 //return	0 ;
 }
 void say_goodbye()
 {
	system("cls");
	system("color 74");
		cout << "\n\n\n" ;
		cout<<"	┌─────────────────────────┐\n"
			<<"	│             !!! GOODBYE,BYE-BYE !!!              │\n"
			<<"	├────────────┬────────────┤\n"
			<<"	│         !!! 该程序由黄俊坤独立完成 !!!           │\n"
			<<"	│              !!!软件工程（三）班!!!              │\n"
			<<"	│               !!! 学号06065072 !!!               │\n"
			<<"	│                   !!! 谢谢 !!!                   │\n"
			<<"	└────────────┴────────────┘\n";


	//getch() ;
	//system("cls");
	cout << "\n		       !!! GOODBYE,BYE-BYE !!!		" ;
	cin.ignore(100,'\n') ;
	//string	str ;
	//getline(cin,str) ;
	
	system("pause");
	//exit (1);


 }