void LineEdit(){
// P50 算法3.2 行编辑程序
// #:退格 @:退行
// 利用字符栈S，从终端接收一行并传送至调用过程的数据区
SqStack S;
InitStack(S);
SElemType e;
char ch = getchar();
while (ch != EOF){
while (ch != EOF && ch != '\n'){
switch (ch){
case'#':
Pop(S, e);
break;
case'@':
ClearStack(S);
break;
default:
Push(S, ch);
break;
}
ch = getchar(); //从终端接收下一个字符
}
StackTraverse(S, Visit_Display_Char);
ClearStack(S);
if (ch != EOF) ch = getchar();
}
DestroyStack(S);
}// LineEdit
void lineEdit() {
SqStack S;
InitStack(S);
char ch;
ch = getchar();
ElemType e;
while (ch != EOF) {
while (ch != EOF && ch != '\n') {
switch (ch) {
case '#':
Pop(S, e);
break;
case '@':
ClearStack(S);
break;
default:
e.key = ch;
Push(S, e);
break;
}
ch = getchar();
}
PrintStack(S);
ClearStack(S);
if (ch != EOF) ch = getchar();
}
DestroyStack(S);
}
void LineEdit()
{ /* 利用字符栈s，从终端接收一行并送至调用过程的数据区。算法3.2 */
SqStack s;
char ch,c;
InitStack(&s);
printf("请输入一个文本文件,^Z结束输入:\n");
ch=getchar();
while(ch!=EOF)
{ /* EOF为^Z键，全文结束符 */
while(ch!=EOF&&ch!='\n')
{
switch(ch)
{
case '#':Pop(&s,&c);
break; /* 仅当栈非空时退栈 */
case '@':ClearStack(&s);
break; /* 重置s为空栈 */
default :Push(&s,ch); /* 有效字符进栈 */
}
ch=getchar(); /* 从终端接收下一个字符 */
}
StackTraverse(s,copy); /* 将从栈底到栈顶的栈内字符传送至文件 */
ClearStack(&s); /* 重置s为空栈 */
fputc('\n',fp);
if(ch!=EOF)
ch=getchar();
}
DestroyStack(&s);
}
//********************
void main_LineEdit(){
SeqStack S;
char ch;
DataType e;
DataType a[50];
int i,j=0;
InitStack(&S);
printf("输入字符序列(#表示前一个字符无效，@表示当前行字符无效).\n");
ch=getchar();
while(ch!='\n'){
switch(ch){
case '#':
if(!StackEmpty(S))
PopStack(&S,&ch);
break;
case '@':
ClearStack(&S);
break;
default:
PushStack(&S,ch);
}
ch=getchar();
}
while(!StackEmpty(S)){
PopStack(&S,&e);
a[j++]=e;
}
for(i=j-1;i>=0;i--)
printf("%c",a[i]);
printf("\n");
ClearStack(&S);
system("pause");
}
static void LineEdit()
{ // 利用字符栈s，从终端接收一行并送至调用过程的数据区。算法3.2
SqStack s;
char ch,c;
InitStack(s);
printf("请输入一个文本文件,^Z结束输入:\n");
ch=getchar();
while(ch!=EOF)
{ // EOF为^Z键，全文结束符
while(ch!=EOF&&ch!='\n')
{
switch(ch)
{
case '#':Pop(s,c);
break; // 仅当栈非空时退栈
case '@':ClearStack(s);
break; // 重置s为空栈
default :Push(s,ch); // 有效字符进栈
}
ch=getchar(); // 从终端接收下一个字符
}
StackTraverse(s,copy); // 将从栈底到栈顶的栈内字符传送至文件
ClearStack(s); // 重置s为空栈
fputc('\n',fp);
if(ch!=EOF)
ch=getchar();
}
DestroyStack(s);
}
void LineEdit()
{ // 利用字符栈s，从终端接收一行并送至调用过程的数据区。算法3.2
SqStack s;
char ch,c;
int n,i;
InitStack(s);
scanf("%d",&n); //多case
ch=getchar();
for(i=1;i<=n;i++)
{ ch=getchar();
while(ch!='\n')
{
switch(ch)
{
case '#':Pop(s,c);
break; // 仅当栈非空时退栈
case '@':ClearStack(s);
break; // 重置s为空栈
default :Push(s,ch); // 有效字符进栈
}
ch=getchar(); // 从终端接收下一个字符
}
StackTraverse(s,visit); // 将从栈底到栈顶的栈内字符输出
ClearStack(s); // 重置s为空栈
}
DestroyStack(s);
}
void LineEdit() { // 算法3.2
//利用字符栈S，从终端接收一行并传送至调用过程的数据区。
char ch,*temp;
SqStack S;
InitStack(S); //构造空栈S
printf("请输入一行(#:退格；@:清行):\n");
ch = getchar(); //从终端接收第一个字符
while (ch != EOF) { //EOF为全文结束符
while (ch != EOF && ch != '\n') {
switch (ch) {
case '#': Pop(S, ch); break; // 仅当栈非空时退栈
case '@': ClearStack(S); break; // 重置S为空栈
default : Push(S, ch); break; // 有效字符进栈,未考虑栈满情形
}
ch = getchar(); // 从终端接收下一个字符
}
temp=S.base;
while(temp!=S.top) {
printf("%c",*temp);
++temp;
}
// 将从栈底到栈顶的栈内字符传送至调用过程的数据区；
ClearStack(S); // 重置S为空栈
printf("\n");
if (ch != EOF) {
printf("请输入一行(#:退格；@:清行):\n");
ch = getchar();
}
}
DestroyStack(S);
}
void LineEdit()
{
SqStack s;
char ch;
InitStack(s);
printf("请输入一个文本文件，^Z结束输入：\n");
ch = getchar();
while (ch != EOF) {
while (ch != EOF && ch != '\n') {
switch (ch) {
case '#': if (!StackEmpty(s))
Pop(s, ch);
break;
case '@': ClearStack(s);
break;
default: Push(s, ch);
}
ch = getchar();
}
StackTraverse(s, copy);
fputc('\n', fp);
ClearStack(s);
if (ch != EOF)
ch = getchar();
}
DestroyStack(s);
}
int main ()
{
stackADT operandStack;
string line;
char ch;
printf("RPN kalkulator -- symulacja (napisz H aby otrzymać pomoc)\n");
operandStack=NewStack();
while (TRUE) {
printf("> ");
line=GetLine();
ch=toupper(line[0]);
switch (ch) {
case 'Q': exit(0);
case 'H': HelpCommand(); break;
case 'C': ClearStack(operandStack); break;
case 'D': DisplayStack(operandStack); break;
default: if (isdigit(ch))
Push(operandStack, StringToReal(line));
else
ApplyOperator(ch, operandStack);
break;
}
}
}
int main()
{
int j;
SqStack s;
int e;
if(InitStack(&s)==OK)
{
for(j=1; j<=10; j++)
Push(&s,j);
}
printf("Õ»ÖÐÔªËØÒÀ´ÎΪ£º");
StackTraverse(s);
Pop(&s,&e);
printf("µ¯³öµÄÕ»¶¥ÔªËØe=%d\n",e);
printf("Õ»¿Õ·ñ£º%d(1:¿Õ0:·ñ)\n",StackEmpty(s));
GetTop(s,&e);
printf("Õ»¶¥ÔªËØe=%dÕ»µÄ³¤¶ÈΪ%d\n",e,StackLength(s));
ClearStack(&s);
printf("Çå¿ÕÕ»ºó£¬Õ»¿Õ·ñ£º%d(1:¿Õ0:·ñ)\n",StackEmpty(s));
return 0;
}
/*---------------------------------------------------------------
* allocate the stack, set the maximum and minimum bounds
* on the stack, and show that the stack is empty.
*-------------------------------------------------------------*/
Stack *CreateStack ( int how_many )
{
Stack *pstk;
assert ( how_many > 0 ); /* make sure the size is legal */
pstk = (Stack *) malloc ( sizeof ( Stack ));
if ( pstk == NULL )
return ( NULL );
pstk->stack_size = how_many;
pstk->base = ( struct StkElement * )
malloc ( how_many * sizeof ( struct StkElement ));
if ( pstk->base == NULL ) /* error in allocating stack */
return ( NULL );
pstk->min_stack = 0;
pstk->max_stack = how_many - 1;
ClearStack ( pstk );
return ( pstk );
}
int main()
{
int j;
SqStack s;
SElemType e;
if( InitStack(&s) == OK )
for(j = 1; j <= 9; j++)
Push(&s, j);
printf("The items in the stack is: \n");
StackTraverse(s, visit);
Pop(&s, &e);
printf("The item popped is: %d\n", e);
printf("\n");
printf("The stack is empty now? empty:1, not empty:0\t%d\n", StackEmpty(s));
printf("\n");
GetTop(s, &e);
printf("The item at the top of the stack is: %d, the length of the stack is: %d\n",e, StackLength(s));
printf("\n");
ClearStack(&s);
printf("The stack cleared, is the stack empty? empty:1, not empty:0, %d\n", StackEmpty(s));
printf("\n");
DestroyStack(&s);
return 0;
}
Status scanner(char* c){
LinkStack* stack = NULL;
InitStack(&stack);
Status ret = FALSE;
int i = 0;
while(c[i] != '\0'){
elemType e;
if( isLeft(c[i]) ){
Push(stack,(elemType)c[i]);
}
if(isRight(c[i])){
char codeOut;
Pop(stack,&e);
codeOut = (char)e;
if(!isMatch(codeOut,c[i])){
printf("not matching %c %c\n",codeOut,c[i]);
ret = FALSE;
goto EXIT;
}
}
i++;
}
if(StackEmpty(stack)){
ret = TRUE;
}else{
ret = FALSE;
}
EXIT:
ClearStack(&stack);
return ret;
}
void LineEdit()
{
char ch, c;
SqStack s;
InitStack(&s);
ch = getchar();
while (ch != EOF) {
while ((ch != EOF) && (ch != '\n')) {
switch (ch) {
case '#':
Pop(&s, &c);
break;
case '@':
ClearStack(&s);
break;
default:
Push(&s, ch);
if (ch == EOF)
printf("\n push eof\n");
break;
}
ch = getchar();
}
// '\n' detected, send out and clear whole stack
if (ch == '\n') {
StackTraverse(s, sendToFile);
fputc('\n', fp);
ClearStack(&s);
ch = getchar();
} else if (ch == EOF) {
StackTraverse(s, sendToFile);
ClearStack(&s);
printf(" now exit\n");
}
/* if (ch == '\n') */
/* fputc('\n', fp); */
/* if (ch != EOF) */
/* ch = getchar(); */
/* else */
/* printf("ch == eof, should exit\n"); */
}
DestroyStack(&s);
}
int main()
{
Stack s;
ElemType x;
cout<<"(1)³õʼ»¯Õ»s"<<endl;
InitStack(s);
cout<<"(2)ջΪ"<<(StackEmpty(s)?"¿Õ":"·Ç¿Õ")<<endl;
cout<<"(3)ÒÀ´ÎÊäÈë×ÖĸÐòÁУ¬ÒÔ¡°#¡±½áÊø£º"<<endl;
cin>>x;
while( x!='#')
{
Push(s,x);
cin>>x;
}
cout<<"(4)ջΪ"<<(StackEmpty(s)?"¿Õ":"·Ç¿Õ")<<endl;
cout<<"(5)Õ»³¤¶ÈStackLength(s):"<<StackLength(s)<<endl;
cout<<"(6a)Õ»¶¥ÔªËØGetTop(s)Ϊ£º";
cout<<GetTop(s)<<endl;
cout<<"(6b)Õ»¶¥ÔªËØGetTop1(s,x)Ϊ£º"<<endl;
GetTop1(s,x);
cout<<x<<endl;
cout<<"(7)´ÓÕ»¶¥µ½Õ»µ×ÔªËØPrintStack(s)Ϊ£º"<<endl;
PrintStack(s);
cout<<"(8)³öÕ»Pop1(s,x)µÄÔªËØΪ£º"<<endl;
Pop1(s,x);
cout<<x<<endl;
cout<<"(9)³öÕ»ÐòÁÐ:"<<endl;
while(!StackEmpty(s))
{
cout<<Pop(s)<<" ";
}
cout<<endl;
cout<<"(10)ջΪ:"<<(StackEmpty(s)?"¿Õ":"·Ç¿Õ")<<endl;
cout<<"(11)ÒÀ´Î½øÕ»ÔªËØa,b,c:"<<endl;
Push(s,'a');
Push(s,'b');
Push(s,'c');
cout<<"(12)´ÓÕ»¶¥µ½Õ»µ×ÔªËØPrintStack(s)Ϊ£º"<<endl;
PrintStack(s);
cout<<"(13)Çå¿ÕÕ»ClearStack(s)"<<endl;
ClearStack(s);
cout<<"(14)ջΪ"<<(StackEmpty(s)?"¿Õ":"·Ç¿Õ")<<endl;
cout<<"(15)Ïú»ÙÕ»s:"<<endl;
DestoryStack(s);
cout<<"(16)Ïú»ÙÕ»ºóµ÷ÓÃPush(s,e)ºÍPrintStack(s)"<<endl;
Push(s,'e');
PrintStack(s);
return 0;
}
void CObjectOStream::Close(void)
{
if (m_Fail != fNotOpen) {
try {
DefaultFlush();
if ( m_Objects )
m_Objects->Clear();
ClearStack();
m_Fail = fNotOpen;
}
catch (CException& exc) {
if ( InGoodState() )
RethrowError(fWriteError, "cannot close output stream",exc);
}
}
}
int main() {
LinkStack S;
int result;
pNode node, topNode;
//0. InitStack
InitStack(S);
if (!S) {
printf("Init Stack failed!\n");
return -1;
}
PrintStack(S);
//1. Push
printf("\n");
PrintStack(S);
printf("Push Stack\n");
node = CreateNode(5);
if (!node) {
printf("Create Node failed\n");
return -1;
}
Push(S, node);
PrintStack(S);
topNode = Top(S);
PrintNode(topNode);
//2. Pop
printf("\n");
PrintStack(S);
if (!StackEmpty(S)) {
printf("Pop Stack\n");
Pop(S);
}
PrintStack(S);
//3. Clear
printf("\n");
PrintStack(S);
if (!StackEmpty(S)) {
printf("Clear Stack\n");
ClearStack(S);
}
PrintStack(S);
}
int main()
{
int j;
LinkStack s;
int e;
if(InitStack(&s)==OK)
for(j=1;j<=10;j++)
Push(&s,j);
printf("栈中元素依次为：");
StackTraverse(s);
Pop(&s,&e);
printf("弹出的栈顶元素 e=%d\n",e);
printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));
GetTop(s,&e);
printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
ClearStack(&s);
printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));
return 0;
}
void main()
{
int j;
LinkStack s;
SElemType e;
if(InitStack(&s))
for(j=1;j<=5;j++)
Push(s,2*j);
printf("栈中的元素从栈底到栈顶依次为: ");
StackTraverse(s,print);
Pop(s,&e);
printf("弹出的栈顶元素为%d\n",e);
printf("栈空否: %d(1:空 0:否)\n",StackEmpty(s));
GetTop(s,&e);
printf("当前栈顶元素为%d，栈的长度为%d\n",e,StackLength(s));
ClearStack(s);
printf("清空栈后，栈空否: %d(1:空 0:否)，栈的长度为%d\n",StackEmpty(s),StackLength(s));
printf("是否销毁栈了: %d(1:是 0:否)\n",DestroyStack(&s));
}
void testBasicStack() {
SqStack S;
InitStack(S);
if (StackEmpty(S)) printf("the Stack S is Empty");
PrintStack(S);
printf("add item to the stack.\n");
CreateStack(S);
PrintStack(S);
printf("pop the top of the stack:\n");
ElemType e;
Pop(S, e);
PrintStack(S);
printf("the element that is popped out: %d\n", e.key);
ClearStack(S);
printf("clear the stack:\n");
PrintStack(S);
printf("destroy the stack:\n");
DestroyStack(S);
PrintStack(S);
}
int main(void) {
Stack s;
StackEntry e;
CreateStack(&s); //for intializing the stack
if (!StackFull(&s))
Push (e, &s);
if (!StackEmpty(&s))
Pop (&e, &s);
if (!StackEmpty(&s))
StackTop (&e, &s);
x = StackSize (&s);
ClearStack (&s);
return 0;
}
int main (int argc, char **argv) {
LiStack *st;
car_t c1, c2;
c1.num = 1;
c1.time = 3;
c2.num = 2;
c2.time = 4;
InitStack (st);
Push (st, c1);
Push (st, c2);
DispStack (st);
Delete (st, c1);
DispStack (st);
c1.num = 4;
c1.time = 1;
Push (st, c1);
DispStack (st);
Delete (st, c2);
DispStack (st);
ClearStack (st);
return 0;
}
void
Permute(Stack *out, Stack *in, Stack *spur)
{
Stack *temp_out;
Stack *temp_spur;
Stack *temp_in; /* the backups. */
if (StackEmpty(out)) {
while (!StackEmpty(spur))
SendTrain(in, spur);
TraverseStack(in, PrintEntry); /* A mode is detected, */
total++; /* then print out the results.*/
ClearStack(in); /* release the memory. */
#ifdef __TRAVERSE__
printf("\n");
#endif
} else {
if (1 - frame_depth % 2) { /* To decide how to send trains. */
SendTrain(spur, out); /* If 'frame_depth' is odd, */
} else { /* 'out' to 'spur'. If 'frame_depth */
SendTrain(in, spur); /* is even, 'spur' to 'in'. */
}
temp_out = BackUp(out);
temp_spur = BackUp(spur);
temp_in = BackUp(in);
frame_depth++; /* To enter into a new recursion. */
Permute(temp_out, temp_in, temp_spur);
frame_depth--; /* Now back to the higher level of recursion. */
if (!StackEmpty(out) && !StackEmpty(spur))
Permute(out, in, spur);
}
}
int main(int argc, const char *argv[])
{
LinkStack *testList = NULL;
elemType e;
int i;
srand(time(0));
printf("list length is %d\n",StackLength(testList));
if(InitStack(&testList) == ERROR){
return -1;
}
for(i = 0; i < 10 ; i++){
Push(testList,i);
}
printf("list length is %d\n",StackLength(testList));
PrintStack(testList);
Pop(testList,&e);
printf("pop e is %d ,length is %d \n",e,StackLength(testList));
ClearStack(&testList);
printf("list length is %d\n",StackLength(testList));
printf("scanner: is it matching? ");
scanner("hello(){}") ? printf("true \n"):printf("false \n");
return 0;
}
/*
* @description 销毁栈
*/
void DestoryStack(SqStack *S) {
ClearStack(S);
(*S).top = (*S).base = NULL;
}
bool DestroyStack(SqStack &S)
{
ClearStack(S);
return true;
}
Stack::~Stack()
{
ClearStack();
}
BOOL RSAKey::GenKey(DWORD dwFlags)
{
DWORD dwBitLen;
DWORD dwByteLen1;
DWORD dwByteLen2;
DWORD dwBufferSize1;
DWORD dwBufferSize2;
BYTE *pb;
dwBitLen = dwFlags >> 16;
// use the default if not specified
if (dwBitLen == 0)
dwBitLen = 1024;
if ((dwBitLen % 16 != 0) ||
(dwBitLen > 16384))
{
SetLastError(NTE_BAD_FLAGS);
return FALSE;
}
m_dwBitLen = dwBitLen;
dwByteLen1 = dwBitLen / 8;
dwByteLen2 = dwByteLen1 / 2;
dwBufferSize1 = BigNum::GetBufferSize(dwByteLen1);
dwBufferSize2 = BigNum::GetBufferSize(dwByteLen2);
m_dwSize = BigNum::GetBufferSize(sizeof(DWORD)) +
(2 * dwBufferSize1 + 5 * dwBufferSize2);
pb = (BYTE*)malloc(m_dwSize);
if (pb == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return FALSE;
}
m_pBlob = pb;
m_pExponent = (BigNum*)pb;
pb += BigNum::GetBufferSize(sizeof(DWORD));
static const BYTE c_DefaultExponent[4] = { 1, 0, 1, 0 };
BigNum::SetBytes(m_pExponent, c_DefaultExponent, sizeof(DWORD));
#define HELPER(m_pMember, size) \
m_pMember = (BigNum*)pb; \
pb += dwBufferSize##size;
HELPER(m_pModulus, 1);
HELPER(m_pPrime1, 2);
HELPER(m_pPrime2, 2);
HELPER(m_pExponent1, 2);
HELPER(m_pExponent2, 2);
HELPER(m_pCoefficient, 2);
HELPER(m_pPrivateExponent, 1);
#undef HELPER
if (!GenerateKey())
{
ClearStack();
return FALSE;
}
if (!CheckKey())
{
SetLastError(E_UNEXPECTED);
_ASSERTE(false);
ClearStack();
return FALSE;
}
GetProvider()->SetSignatureKey(this);
return TRUE;
}
BOOL RSAKey::ImportKey(DWORD dwFlags, CONST BYTE *pbData, DWORD dwDataLen)
{
BOOL bPrivate;
DWORD dwBitLen;
DWORD dwByteLen1;
DWORD dwByteLen2;
DWORD dwBufferSize1;
DWORD dwBufferSize2;
BYTE *pb;
BLOBHEADER *pBlobHeader;
RSAPUBKEY* pRSAPubKey;
_ASSERTE(dwDataLen >= sizeof(BLOBHEADER));
pBlobHeader = (BLOBHEADER*)pbData;
pbData += sizeof(BLOBHEADER);
dwDataLen -= sizeof(BLOBHEADER);
switch (pBlobHeader->bType)
{
case PUBLICKEYBLOB:
bPrivate = FALSE;
break;
case PRIVATEKEYBLOB:
bPrivate = TRUE;
break;
default:
goto BadKey;
}
if (dwDataLen < sizeof(RSAPUBKEY))
{
goto BadKey;
}
pRSAPubKey = (RSAPUBKEY*)pbData;
pbData += sizeof(RSAPUBKEY);
dwDataLen -= sizeof(RSAPUBKEY);
if (GET_UNALIGNED_VAL32(&pRSAPubKey->magic) !=
(bPrivate ? 0x32415352U : 0x31415352U)) // 'RSA2' : 'RSA1'
{
goto BadKey;
}
dwBitLen = GET_UNALIGNED_VAL32(&pRSAPubKey->bitlen);
if ((dwBitLen == 0) ||
(dwBitLen % 16 != 0) ||
(dwBitLen > 16384))
{
goto BadKey;
}
m_dwBitLen = dwBitLen;
dwByteLen1 = dwBitLen / 8;
dwByteLen2 = dwByteLen1 / 2;
if (dwDataLen != (bPrivate ? (9 * dwByteLen2) : dwByteLen1))
{
goto BadKey;
}
dwBufferSize1 = BigNum::GetBufferSize(dwByteLen1);
dwBufferSize2 = BigNum::GetBufferSize(dwByteLen2);
m_dwSize = BigNum::GetBufferSize(sizeof(DWORD)) +
(bPrivate ? (2 * dwBufferSize1 + 5 * dwBufferSize2) : dwBufferSize1);
pb = (BYTE*)malloc(m_dwSize);
if (pb == NULL)
{
SetLastError(ERROR_OUTOFMEMORY);
return FALSE;
}
m_pBlob = pb;
m_pExponent = (BigNum*)pb;
pb += BigNum::GetBufferSize(sizeof(DWORD));
BigNum::SetBytes(m_pExponent, (BYTE*)&pRSAPubKey->pubexp, sizeof(DWORD));
#define HELPER(m_pMember, size) \
m_pMember = (BigNum*)pb; \
pb += dwBufferSize##size; \
BigNum::SetBytes(m_pMember, pbData, dwByteLen##size); \
pbData += dwByteLen##size;
HELPER(m_pModulus, 1);
if (!bPrivate)
return TRUE;
HELPER(m_pPrime1, 2);
HELPER(m_pPrime2, 2);
HELPER(m_pExponent1, 2);
HELPER(m_pExponent2, 2);
HELPER(m_pCoefficient, 2);
HELPER(m_pPrivateExponent, 1);
#undef HELPER
if (!CheckKey())
{
ClearStack();
goto BadKey;
}
ClearStack();
GetProvider()->SetSignatureKey(this);
return TRUE;
BadKey:
SetLastError(NTE_BAD_KEY);
return FALSE;
}
int main(void)
{
int select; /*保存选择变量*/
Elem e; /*保存从函数返回的结点的值*/
Elem v; /*保存传递给函数的结点的值*/
size_t i= 0;
LINKSTACK S;
InitStack(&S); /*初始化栈*/
srand((int)time(NULL));
while (1) /*while_@1*/
{
if (!(S.pBottom))
{
printf("栈不存在!\n");
break;
}
system("cls");
Menu();
printf("请输入您的选择(1~9):");
scanf("%d", &select);
getchar();
switch (select) /*switch_@1*/
{
case 1: /*入栈.*/
v = InputValue("入栈元素为:");
Push(&S, v);
printf("入栈操作成功!\n");
getchar();
break;
case 2: /*输出栈中元素.*/
printf("栈为:");
TraveStack(&S);
getchar();
break;
case 3: /*出栈.*/
if (OK == Pop(&S, &e))
{
printf("出栈成功,出栈元素是%d!\n", e);
}
else
{
printf("出栈失败!\n");
}
getchar();
break;
case 4: /*输出栈的长度.*/
printf("栈长为: %d \n", StackLength(&S));
getchar();
break;
case 5: /*清空栈.*/
ClearStack(&S);
printf("该栈已经清空!\n");
getchar();
break;
case 6: /*销毁栈.*/
DestroyStack(&S);
printf("栈已删除!\n");
getchar();
break;
case 7: /*返回栈顶结点元素.*/
if (OK == GetTop(&S, &e))
{
printf("栈顶为:%d\n", e);
}
else
{
printf("不存在栈顶元素!\n");
}
getchar();
break;
case 8: /*判断栈是否为空.*/
if (StackEmpty(&S) == TRUE)
{
printf("栈为空!\n");
}
else
{
printf("栈非空!\n");
}
getchar();
break;
case 9: /*进制转换*/
{
int d;
unsigned int m, n;
v = InputValue("请输入一个非负整数:");
d = InputValue("请输入转换进制:");
if (v < 0 ||d<2 ||d>16)
{
printf("输入数据错误!\n");
break;
}
m = (unsigned int)v;
n = (unsigned int)d;
Conversion_ten_to_n(m, n);
getchar();
break;
}
default:
printf("请重新选择!\n");
getchar();
break;
}/*switch_@1*/
} /*while_@1*/
return EXIT_SUCCESS;
}
