p Write a program to evaluate a postfix expression. #ifndef _Stack_H #define _Stack_H #define ElementType double

Size: px

Start display at page:

Download "p Write a program to evaluate a postfix expression. #ifndef _Stack_H #define _Stack_H #define ElementType double"

Hope Wilson
6 years ago
Views:

1 p Write a program to evaluate a postfix expression. #ifndef _Stack_H #define _Stack_H #define ElementType double struct Node; typedef struct Node *PtrToNode; typedef PtrToNode Stack; int IsEmpty(Stack S); Stack CreateStack(void); void DisposeStack(Stack S); void MakeEmpty(Stack S); ElementType Top(Stack S); void Pop(Stack S); #endif /*_Stack_h*/ struct Node ElementType Element; Position next; ; #include<stdio.h> #include<stdlib.h> #include<stack.h> int IsEmpty(Stack S) return S->Next==NULL; Stack Createstack(void) Stack S; S=malloc(sizeof(struct Node)); if(s==null) FatalError("Out of space!!!");

2 MakeEmpty(S); return S; void MakeEmpty(Stack S) if(s==null) Error("Must use CreateStack first"); while(!isempty(s)) Pop(S); void Push(Stack S,Element x) PtrToNode Tmpcell; TmpCell=malloc(sizeof(struct Node)); if(tmpcell==null) FatalError("Out of space!!!"); TmpCell->Element=x; TmpCell->Next=S->next; S->next=TmpCell; ElementType Top(Stack S) if(!isempty(s)) return S->next->Element; Error("Empty stack"); return 0; void Pop(Stack S) PtrToNode FirstCell; if(isempty(s))

3 Error("Empty stack"); FirstCell=S->next; S->next=S->next->next; free(firstcell); double computing(char expr[]) STACK S; double tnum,a,b,result; char *ptr; CreateStack(&S); ptr = expr; /* 字符指针指向后缀表达式串的第一个字符 */ while(*ptr!='\0') if(*ptr==' ') /* 当前字符是空格 */ ptr++; /* 字符指针指向下一字符 */ continue; if(*ptr>='0'&&*ptr<='9')/* 当前字符是数字, 则将该数字开始的数字串转换为数值 */ tnum=0; while(*ptr>='0'&&*ptr<='9') tnum = tnum * 10 +(*ptr-'0'); ptr++; Push(&S,tnum); if (*ptr=='+' *ptr=='-' *ptr =='*' *ptr =='/')/* 当前字符是运算符或其他符号 */ if(!isempty(s)) a=top(s);pop(&s); /* 取运算符的第二个运算数 */ if (!IsEmpty(S)) b=top(s);pop(&s); /* 取运算符的第一个运算数 */

4 return -1; return -1; switch(*ptr) case '+': Push(&S,b+a); break; case '-': Push(&S,b-a); break; case '*': Push(&S,b*a); break; case '/': Push(&S,b/a); break; return -1; ptr++; /* 字符指针指向下一字符 */ if (IsEmpty(S)) return -1; result=top(s); Pop(&S); /* 取运算结果 */ if (!IsEmpty(S)) return -1; return result; void main() char expr[100]; double result; gets(expr); result=computing(expr); printf("the result of %s is %f\n",expr,&result); p Write routines to implement two stacks using only one array. Your stack routines should not declare an overflow unless every slot in the

5 array is used. #ifndef _Stack_h #define _Stack_h struct StackRecord *Stack; int IsEmpty(Stack S,int Stacknum); int IsFull(Stack S); Stack CreateStack(int MaxElement); void Push(ElementType X,Stack S,int Stacknum); ElementType Top(Stack S,int Stacknum); void Pop(Stack S,int Stacknum); #endif /*_Stack_h*/ #define MinStackSize(5) Struct StackRecord int Capacity; int Top1; int Top2; Elementtype *Array; ; /*The bottom of the first stack is at Array[0]*/ /*The bottom of the second stack is at Array[ MaxElement ] */ /*Top1 and Top2 point to the top elements of two stacks respectively */ Stack CreateStack(int MaxElement) Stack S; if(maxelement<minstacksize) Error("Stack size is too small"); S=malloc(sizeof(struct StackRecord)); if(s==null) FatalError("Out of space!!!"); /*create an array for stack elements*/ S->Array=malloc(sizeof(ElementType)*MaxElements); if(s->array==null) FatalError("Out of space!!!"); S->Capacity=MaxElements; S->Top1=-1;S->Top2=MaxElement;/*initialize 2 empty stacks)*/ return (S);

6 int IsEmpty(Stack S,int Stacknum) if(stacknum==1) /*check stack 1*/ return S->Top1==-1; if(stacknum==2)/*check stack 2*/ return S->==S->Capacity; return Error("Stack number error"); int IsFull(Stack S) return S->Top1=S->Top2-1; void Push(ElementType X,Stack S,int Stacknum) if(isfull(s)) FatalError("Full Stack"); if(stacknum==1)/*push onto stack1*/ S->Array[++S->Top1]=X; if(stacknum==2)/*push onto stack2*/ S->Array[--S->Top2]=X; Error("Stack number error"); ElementType Top(Stack S,int Stacknum) if(isempty(s,stacknum)) return FatalError("Stack is empty"); if(stacknum==1)/*check stack1*/ return S->Array[S->Top1]; if(stacknum==2)/*check stack2*/ return S->Array[S->Top2];

7 return Error("Stack number error"); void Pop(Stack S,int Stacknum) if(isempty(s,stacknum)) FatalError("Stack is empty"); if(stacknum==1)/*pop stack1*/ S->Top1--; if(stacknum==2)/*pop stack2*/ S->Top2++; Error("Stack number error"); p A "deque" is a data structure consisting of a list of items, on which the following operations are possible: Push(X,D): Insert item X on the front end of deque D. Pop(D): Remove the front item from deque D and return it. Inject(X,D): Insert item X on the rear end of deque D. Eject(D): Remove the rear item from deque D and return it. Write routines to support the deque that take O(1) time per operation. #ifndef _deque_h #define _deque_h struct Node; typedef struct Node *PtrToNode; struct DequeRecord PtrToNode Front,Rear;

8 ; typedef struct DequeRecord *Deque; void Push(ElementType X,Deque D); ElementType Pop(Deque D); void Inject(ElementType X,Deque D); ElementType Eject(Deque D); #endif/*_deque_h*/ struct Node ElementType Element; PtrToNode Next,Last; ; /*Implement a deque using a doubly linked list with a header*/ /*front and rear point to two ends of the deque respectively*/ /*front always points to the header*/ /*deque is empty when front==rear*/ void Push(ElementType X,Deque D)/*Insert item X on the front end of deque D*/ PtrToNode Newnode; Newnode=malloc(sizeof(Node));/*create a new node*/ if(newnode==null) FatalError("The memory is full."); Newnode >Element=X; Newnode >Next=D >Front >Next; Newnode >Last=D >Front; if(d >Front==D >Rear) D >Rear=Newnode; /*if deque was not empty*/ D >Front >Next >Last=Newnode; D >Front >Next=Newnode; ElementType Pop(Deque D)/*Remove the front item from deque D and return it*/ PtrToNode Temp; ElementType Item; if(d >Front==D >Rear) return Error("Deque is empty");

9 Temp=D >Front >next; D >Front >Next=Temp >Next; Temp >Next >Last=D >Front; if(temp==d >Rear) D >Rear=D >Front; Item=Temp >Element; free(temp); return Item; void Inject(ElementType X,Deque D)/*Insert item X on the rear end of deque D*/ PtrToNode Newnode; Newnode=malloc(sizeof(Node));/*create a new node*/ if(newnode==null) FatalError("The memory is full"); Newnode >Element=X; Newnode >Next=NULL; Newnode >Last=D >Rear; D >Rear >Next=Newnode;/*reset original last node*/ D >Rear=Newnode;/*reset last*/ /*remove the rear item from deque D and return it*/ ElementType Eject(Deque D) PtrToNode Temp; ElementType Item; if(d >Front==D >Rear) return Error("Empty Deque"); Temp=D >Rear; D >Rear=D >Rear >Last;/*reset last*/ D >Rear >Next=NULL;/*reset the last element's link*/ Item=Temp >Element; free(temp);

10 return Item; p Write a routine to list out the nodes of a binary tree in "level order". List the root, then nodes at depth 1, followed by nodes at depth 2, and so on. You must do this in linear time. Prove your time bound. typedef struct TreeNode *PtrToNode; typedef PtrToNode Tree; struct TreeNode ElementType Element; Tree Left; Tree Right; #define MaxElements 100 /* max queue size */ void Level_order (Tree T) /* Level order binary tree traversal */ /* 1) enqueue the root T ) */ /* while (queue is not empty), do steps 2 and 3: */ /* 2) list the node at the front of the queue and dequeue it */ /* 3) enqueue the node's left and right children */ Queue Q; if (!T) return; /*empty tree */ Q=CreateQueue( MaxElements ); /* create an empty queue */ Enqueue(T,Q); /* enqueue the root */ while(!isempty(q)) T=FrontAndDequeue(Q); /* get the front element and dequeue it */ ListOut (T); if(t >Left) /* if this node has a left child */ Enqueue(T >Left,Q); if(t >Right) /* if this node has a right child */ Enqueue(T >Right,Q);

DATA STRUCUTRES. A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently.

DATA STRUCUTRES. A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently. DATA STRUCUTRES A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently. An algorithm, which is a finite sequence of instructions, each of which