Study Code Program C data structure

Insertion sort

2007-05-10T00:20:00.000-07:00

#include
#include
#include

#define max 10

void print_array(int *array) {
int x;
for(x = 0; x if(x != max-1)
printf("%d, ", array[x]);
else
printf("%d\n", array[x]);
}
}
void main(){
int iarray[max];
int i,j;
int k;
// Seed rand()
srand((unsigned int)time(NULL));

for(i = 0; i < max; i++)
iarray[i] = (int)(rand() % 100);
// print initial data
printf("initial data \n");
print_array(iarray);
printf("\n");
//insertion sort
for(i=0 ; i k=iarray[i];
for(j=i-1;i>0 && k iarray[j+1] = iarray[j];
iarray[j] = k;
}
printf("round %d\n",i);
print_array(iarray);
}
printf("result sort\n");
print_array(iarray);
}

Selection sort

2007-05-10T00:19:00.000-07:00

#include
#include
#include

#define max 10

void print_array(int *array) {
int x;
for(x = 0; x if(x != max-1)
printf("%d, ", array[x]);
else
printf("%d\n", array[x]);
}
}
void main(){

int iarray[max];
int i,j;
int temp;
int min;
// Seed rand()
srand((unsigned int)time(NULL));

for(i = 0; i < max; i++)
iarray[i] = (int)(rand() % 100);

//selection sort
for(i=0 ; i printf("round %d\n",i);
print_array(iarray);
min = i;
for(j=i+1;j if(iarray[j] min = j;
temp = iarray[i];
iarray[i] = iarray[min];
iarray[min]=temp;
}
printf("result sort\n");
print_array(iarray);
}

Bubble sort

2007-05-10T00:18:00.001-07:00

#include
#include
#include

#define max 10

void print_array(int *array) {
int x;
for(x = 0; x if(x != max-1)
printf("%d, ", array[x]);
else
printf("%d\n", array[x]);
}
}
void main(){
int iarray[max];
int x,y;
int temp;
// Seed rand()
srand((unsigned int)time(NULL));

for(x = 0; x < max; x++)
iarray[x] = (int)(rand() % 100);

//print_array(iarray);
printf("initial data\n");
print_array(iarray);

// Bubble sort method.
for(x = 0; x < max; x++){
for(y = 0; y < max-1; y++)
if(iarray[y] > iarray[y+1]) {
temp = iarray[y+1];
iarray[y+1] = iarray[y];
iarray[y] = temp;
}
printf("\n round %d\n",x);
print_array(iarray);
}
printf("\n result\n");
print_array(iarray);
}

Recursive

2007-05-10T00:15:00.001-07:00

#include
int sum(int n)
{
if(n<=0)
return 0;
else
n= n+sum(n-1);
return n;
}
void main(){
int n = 10;
int summ;
summ = sum(n);
printf("sum = %d\n",summ);
}

.........................

factorial

#include
int factorial(int n)
{
if(n<=0)
return 1;
else
n= n*factorial(n-1);
return n;
}
void main(){
int n = 5;
int summ;

summ = factorial(n);

printf("sum = %d\n",summ);
}
................................

max min!

#include
void minmax(int *listnumber,int n,int *p_min,int *p_max){

int min2,max2;
if(n==1)
*p_max = *p_min = listnumber[0];
else if(n==2)
{
if(listnumber[0] *p_min = listnumber[0];
*p_max = listnumber[1];
}else{
*p_min = listnumber[1];
*p_max = listnumber[0];
}
}else{
minmax(listnumber,n/2,p_min,p_max);
minmax(listnumber+n/2,n-(n/2),&min2,&max2);
if(min2<*p_min)
*p_min = min2;
if(max2>*p_max)
*p_max = max2;
}
}

void main(){

int list[10]={1,5,7,6,3,4,8,9,2,0} ;
int p_max,p_min;
int n=10;
minmax(list,n,&p_min,&p_max);

printf("max = %d : min = %d\n",p_max,p_min);
}

Doubly linked list

2007-05-10T00:06:00.000-07:00

#include
#include

typedef struct dlist{

int element;
struct dlist *next;
struct dlist *prev;
}NODE;

NODE *createNode(int item){

NODE *newNode=NULL;

newNode = (NODE *)malloc(sizeof(NODE));
newNode->element=item;
newNode->next=NULL;
newNode->prev=NULL;

return newNode;
}
NODE *insertNodeHead(NODE *head,int item){

NODE *newNode = NULL;

newNode = createNode(item);
if(head == NULL)
return newNode;

newNode->next = head;
head->prev = newNode;
return newNode;
}
NODE *insertNodeTail(NODE *head,int item){

NODE *newNode = NULL,*runNode = head;
newNode = createNode(item);

if(head == NULL)
return newNode;

while(runNode->next!=NULL)
runNode = runNode->next;

runNode->next = newNode;
newNode->prev = runNode;
return head;
}
NODE *insertNodeBetween(NODE *head,int item,int position){

NODE *newNode =NULL,*runNode = head;

newNode = createNode(item);
if(head ==NULL){
return newNode;
}
else{
while(runNode != NULL && runNode->element!=position)
runNode = runNode->next;

if(runNode == NULL)
printf("position not found [%d]\n",position);
else {
if(runNode->prev ==NULL){ //insert head node
runNode->prev = newNode;
newNode->next = runNode;
head = newNode;
}else{
newNode->next = runNode;
newNode->prev = runNode->prev;
runNode->prev = newNode;
newNode->prev->next = newNode;
}
}
}
return head;
NODE *deleteNode(NODE *head,int item){

NODE *runNode = head;

while(runNode != NULL && runNode->element!=item)
runNode = runNode->next;

if(runNode == NULL){
printf("data not found [%d]\n",item);
}
else {
if(runNode->prev == NULL) { //delete head node
head = head->next; //move next
head->prev = NULL;
}
else {
runNode->prev->next = runNode->next ;
if(runNode->next != NULL)
runNode->next->prev = runNode->prev ;
}
free(runNode);
}
return head;
}
void displayNode(NODE *head){

NODE *runNode = head;

while (runNode != NULL){
printf("[%d]->",runNode->element);
runNode = runNode->next;
}
printf("NULL\n");
}

void main(){

NODE *head=NULL;
printf("insert head node 10 15 90\n");
head = insertNodeHead(head,10);
head = insertNodeHead(head,15);
head = insertNodeHead(head,90);
displayNode(head);

printf("insert tail node 300 400\n");
head = insertNodeTail(head,300);
head = insertNodeTail(head,400);
displayNode(head);

printf("insert between node (955,300) (990,90) (940,400) \n");
head = insertNodeBetween(head,955,300);
head = insertNodeBetween(head,990,90);
head = insertNodeBetween(head,940,400);
head = insertNodeBetween(head,940,500);
displayNode(head);

printf("delete node 90 15 400 500\n");
head = deleteNode(head,90);
head = deleteNode(head,15);
head = deleteNode(head,400);
head = deleteNode(head,500);
displayNode(head);
}

Sort more then to Least By Linked List

2007-05-10T00:03:00.000-07:00

#include
#include

typedef struct slist{
int entry;
struct slist *next;
}NODE;

NODE *createNode(int item)
{
NODE *newNode=NULL;
newNode=(NODE *)malloc(sizeof(NODE));
newNode->next=NULL;
newNode->entry =item;
return newNode;
}
NODE *sort(NODE *head,int item)
{
NODE *newNode=NULL,*runNode=head,*prevNode=NULL;
newNode=createNode(item);
if(head==NULL)
return newNode;
else {
while(runNode->next != NULL && newNode->entry>runNode->entry)
{
prevNode=runNode;
runNode=runNode->next;
}
if(newNode->entry<=runNode->entry){
if(prevNode == NULL){
head=newNode;
head->next=runNode;
}
else{
newNode->next = runNode;
prevNode->next = newNode;
}
}
else{
runNode->next = newNode;
}
}
return head;
}
void displayNodes(NODE *head)
{
NODE *runNode=head;
while(runNode!=NULL)
{
printf("[%d]->",runNode->entry );
runNode=runNode->next;
}
printf("NULL\n");
}
void main(void)
{
int input;
NODE *head=NULL;
// insert head node

// head = sort(head,50);displayNodes(head);
// head = sort(head,40);displayNodes(head);
// head = sort(head,70);displayNodes(head);
// head = sort(head,30);displayNodes(head);
// head = sort(head,60);displayNodes(head);
// head = sort(head,90);displayNodes(head);

do{
printf("input data (if exit input = 999):");
scanf("%d",&input);
if(input!=999)
head=sort(head,input);
}while(input != 999);
displayNodes(head);
}

Average By Linked list

2007-05-10T00:01:00.000-07:00

Singly Linked List

2007-05-09T23:57:00.000-07:00

Singly Linked List>> Create

#include
#include

typedef struct slist{
int entry;
struct slist *next;
}NODE;

NODE *createNode(int item)
{
NODE *newNode=NULL;
newNode=(NODE *)malloc(sizeof(NODE));
newNode->next=NULL;
newNode->entry =item;
return newNode;
}

void displayNodes(NODE *head)
{
NODE *runNode=head;
while(runNode!=NULL)
{
printf("[%d]->",runNode->entry );
runNode=runNode->next;
}
printf("NULL\n");
}

void main(void)
{
int item;
NODE *newNode=NULL;

printf(“input item:”);
scanf(“%d”,&item);

newNode=createNode(item);

displayNodes(newNode);

}

……………………………………………………

Singly Linked List>>> ADD

#include
#include

typedef struct slist{
int entry;
struct slist *next;
}NODE;

NODE *createNode(int item)
{
NODE *newNode=NULL;
newNode=(NODE *)malloc(sizeof(NODE));
newNode->next=NULL;
newNode->entry =item;
return newNode;
}

NODE *insertNodeHead(NODE *head,int item)
{
NODE *newNode=NULL;
newNode=createNode(item);
if(head!=NULL)
newNode->next=head;

return newNode;
}

NODE *insertNodeTail(NODE *head,int item)
{
NODE *newNode=NULL,*runNode=head;
newNode=createNode(item);
if(head==NULL)
return newNode;
else {
while(runNode->next != NULL)
runNode=runNode->next;
runNode->next = newNode;
}
return head;
}
void displayNodes(NODE *head)
{
NODE *runNode=head;
while(runNode!=NULL)
{
printf("[%d]->",runNode->entry );
runNode=runNode->next;
}
printf("NULL\n");
}
void main(void)
{
NODE *head=NULL;
// insert head node
head=insertNodeHead(head,2);
head=insertNodeHead(head,3);
head=insertNodeHead(head,4);
displayNodes(head);
//insert tail node
head=insertNodeTail(head,100);
head=insertNodeTail(head,200);
head=insertNodeTail(head,300);
displayNodes(head);
}

………………………………………………………

Singly Linked List <<< Del

#include
#include

typedef struct slist{
int entry;
struct slist *next;
}NODE;

NODE *createNode(int item)
{
NODE *newNode=NULL;
newNode=(NODE *)malloc(sizeof(NODE));
newNode->next=NULL;
newNode->entry =item;
return newNode;
}

NODE *insertNodeHead(NODE *head,int item)
{
NODE *newNode=NULL;
newNode=createNode(item);
if(head!=NULL)
newNode->next=head;

return newNode;
}
void displayNodes(NODE *head)
{
NODE *runNode=head;
while(runNode!=NULL)
{
printf("[%d]->",runNode->entry );
runNode=runNode->next;
}
printf("NULL\n");
}
NODE *deleteNode(NODE *head,int data)
{
NODE *prevNode=NULL,*runNode=head;
while(runNode!= NULL)
{
if(runNode->entry==data)
{
if(prevNode==NULL) // found at head
head=head->next;
else
prevNode->next=runNode->next;

free(runNode);
printf("Node deleted !!!!\n");
break;
}
prevNode=runNode;
runNode=runNode->next;
}
if(runNode==NULL)
printf("Data not found...\n");
return head;
}
void main(void)
{
NODE *head=NULL;

// insert head node
head=insertNodeHead(head,2);
head=insertNodeHead(head,3);
head=insertNodeHead(head,4);
displayNodes(head);

//delete
head=deleteNode(head,3); displayNodes(head);
head=deleteNode(head,4); displayNodes(head);
head=deleteNode(head,2); displayNodes(head);

}

………………………………………………………….

Singly Linked List <<< Insert

#include
#include

typedef struct slist{
int entry;
struct slist *next;
}NODE;

NODE *createNode(int item)
{
NODE *newNode=NULL;
newNode=(NODE *)malloc(sizeof(NODE));
newNode->next=NULL;
newNode->entry =item;
return newNode;
}

NODE *insertNodeHead(NODE *head,int item)
{
NODE *newNode=NULL;
newNode=createNode(item);
if(head!=NULL)
newNode->next=head;

return newNode;
}

void displayNodes(NODE *head)
{
NODE *runNode=head;
while(runNode!=NULL)
{
printf("[%d]->",runNode->entry );
runNode=runNode->next;
}
printf("NULL\n");
}
NODE *insertNodeBetween(NODE *head,int item,int position)
{
NODE *newNode=NULL,*runNode=head,*prevNode=NULL;
newNode=createNode(item);
if(head==NULL)
return newNode;
else {
while(runNode->next != NULL && runNode->entry!=position)
{
prevNode=runNode;
runNode=runNode->next;
}

if(runNode->entry==position)
{
if(prevNode==NULL){ // found at head
head=newNode;
head->next=runNode;
}
else{
newNode->next=runNode;
prevNode->next=newNode;
}
}
}
if(runNode==NULL)
printf("Data not found...\n\n");
return head;
}
void main(void)
{
NODE *head=NULL;
// insert head node
head=insertNodeHead(head,2);
head=insertNodeHead(head,3);
head=insertNodeHead(head,4);
displayNodes(head);

//insert between node
head = insertNodeBetween(head,50,3);displayNodes(head);
head = insertNodeBetween(head,60,50);displayNodes(head);
head = insertNodeBetween(head,70,4);displayNodes(head);
}

…………………………………………..
Singly Linked List <<< All
#include
#include

typedef struct slist{
int entry;
struct slist *next;
}NODE;

NODE *createNode(int item)
{
NODE *newNode=NULL;
newNode=(NODE *)malloc(sizeof(NODE));
newNode->next=NULL;
newNode->entry =item;
return newNode;
}

NODE *insertNodeHead(NODE *head,int item)
{
NODE *newNode=NULL;
newNode=createNode(item);
if(head!=NULL)
newNode->next=head;

return newNode;
}

NODE *insertNodeTail(NODE *head,int item)
{
NODE *newNode=NULL,*runNode=head;
newNode=createNode(item);
if(head==NULL)
return newNode;
else {
while(runNode->next != NULL)
runNode=runNode->next;
runNode->next = newNode;
}
return head;
}
NODE *insertNodeBetween(NODE *head,int item,int position)
{
NODE *newNode=NULL,*runNode=head,*prevNode=NULL;
newNode=createNode(item);
if(head==NULL)
return newNode;
else {
while(runNode->next != NULL && runNode->entry!=position)
{
prevNode=runNode;
runNode=runNode->next;
}

if(runNode->entry==position)
{
if(prevNode==NULL){ // found at head
head=newNode;
head->next=runNode;
}
else{
newNode->next=runNode;
prevNode->next=newNode;
}
}
}
if(runNode==NULL)
printf("Data not found...\n\n");
return head;
}
NODE *deleteNode(NODE *head,int data)
{
NODE *prevNode=NULL,*runNode=head;
while(runNode!= NULL)
{
if(runNode->entry==data)
{
if(prevNode==NULL) // found at head
head=head->next;
else
prevNode->next=runNode->next;

free(runNode);
printf("Node deleted !!!!\n");
break;
}
prevNode=runNode;
runNode=runNode->next;
}
if(runNode==NULL)
printf("Data not found...\n");
return head;
}
void displayNodes(NODE *head)
{
NODE *runNode=head;
while(runNode!=NULL)
{
printf("[%d]->",runNode->entry );
runNode=runNode->next;
}
printf("NULL\n");
}

void main(void)
{
NODE *head=NULL;

int choose=0;
int input,position;

while (choose != 6){
printf("1. insert node at head\n");
printf("2. insert node at tail\n");
printf("3. insert between node\n");
printf("4. delete node\n");
printf("5. display linked list\n");
printf("6. exit program\n\n");
scanf("%d",&choose);
if (choose == 1||choose == 2||choose ==3 ){
printf("input data for insert:-> ");
scanf("%d",&input);
if(choose == 3){
printf("input position node for insert: ");
scanf("%d",&position);
}
}
else if (choose == 4){
printf("input data for delete:-> ");
scanf("%d",&input);
}
switch (choose)
{
case 1:head = insertNodeHead(head,input); break;
case 2:head = insertNodeTail(head,input);break;
case 3:head = insertNodeBetween(head,input,position);break;
case 4:head = deleteNode(head,input);break;
case 5:displayNodes(head);break;
}
}
}

'''''''''''''''''''''''''''''''''''''''''''''

Circular Queue

2007-05-09T23:53:00.000-07:00

#include

#define MAXQUEUE 5

typedef struct {
char data[MAXQUEUE];
int rear;
int front;
int counter;
}QUEUE;

void initial(QUEUE *q);
int enqueue(QUEUE *q,char item);
int dequeue(QUEUE *q,char *ret);

void initial(QUEUE *q){

q->front=-1;
q->rear=-1;
q->counter=0;

}

int enqueue(QUEUE *q,char item)
{
if (q->counter == MAXQUEUE){
printf("FULL QUEUE !!! \n");
return 0;
}
else
{
q->counter++;
q->rear=(q->rear+1)%MAXQUEUE;
q->data[q->rear] = item;
printf("\t enqueue <- %c \n",q->data[q->rear]);

}
return 1;
}

Perfectly Queue

2007-05-09T23:41:00.000-07:00

#include

#define MAXQUEUE 5

typedef struct {
char data[MAXQUEUE];
int rear;
int front;
}QUEUE;

void initial(QUEUE *q);
int enqueue(QUEUE *q,char item);
int dequeue(QUEUE *q,char *ret);

void initial(QUEUE *q){

q->front=-1;
q->rear=-1;

}

int enqueue(QUEUE *q,char item)
{
if (q->rear == MAXQUEUE){
printf("FULL QUEUE !!! \n");
return 0;
}
else
{
q->rear++;
q->data[q->rear] = item;
printf("\n\t enqueue <- %c",q->data[q->rear]);

}
return 1;
}
} int dequeue(QUEUE *q,char *ret)
{
if (q->front== q->rear)
{
printf("Empty QUEUE !!! \n");
return 0;
}
else
{
q->front++;
*ret = q->data[q->front];
}
return 1;
}

void main(){

QUEUE q;
char *element="ABCDE";
char r;
int i=0;

initial(&q);

// enqueue
printf("ENQUEUE \n");

while(enqueue(&q,element[i]))
i++;

// dequeue
printf("\n DEQUEUE \n");
while(dequeue(&q,&r))
{
printf("\n\t dequeue ->%c",r);
}
}

Evaluate by Stack

2007-05-09T23:39:00.000-07:00

#include
#include
#include

#define MAXSTACK 5

typedef struct
{
int sp;
int Data[MAXSTACK];
}STACK;

void Initialize(STACK *s);
int push(STACK *s,int item);
int pop(STACK *s,int *ret);
int full(STACK *s);
int empty(STACK *s);

void Initialize(STACK *s)
{
s->sp=0;
}
int push(STACK *s,int item)
{
if(full(s))
{
printf("Stack is full !!!\n");
return 0;
}
else
{
// printf("\tpush -> %d\n",item);
s->Data[s->sp++]=item;
}
return 1;
}

int full(STACK *s)
{
if(s->sp==MAXSTACK)
return 1;
return 0;
}

int pop(STACK *s,int *ret)
{
if(empty(s))
{
// printf("Stack is empty !!!\n");
return 0;
}
else
*ret=s->Data[--s->sp];
return 1;
}

int empty(STACK *s)
{
if(s->sp==0)
return 1;
return 0;
}

void main(void)
{
STACK s;
char *postfix="53+2*697-/+";
int left,right;
int input,result;
int i;
char *tmp;
tmp = (char *)malloc(2);
tmp[1] ='\0';

Initialize(&s);
for(i=0;postfix[i]!='\0';i++)
{
if(postfix[i]>='0' && postfix[i] <= '9')
{
tmp[0] = postfix[i];
input = atoi(tmp);
push(&s,input);
}
else{
if (pop(&s,&right))
if (pop(&s,&left))
{
switch (postfix[i]){
case '+':
result = left + right;
break;
case '-':
result = left - right;
break;
case '*':
result = left * right;
break;
case '/':
result = left / right;
break;
}
push(&s,result);
}
}

}
if (pop(&s,&right))
printf("%d",right);
printf("\n");
}

postfix to infix

2007-05-09T23:37:00.000-07:00

#include
#include

#define MAXSTACK 5

typedef struct
{
int sp;
char Data[MAXSTACK];
}STACK;

void Initialize(STACK *s);
int push(STACK *s,char item);
int pop(STACK *s,char *ret);
int full(STACK *s);
int empty(STACK *s);

void Initialize(STACK *s){
s->sp=0;
}
int push(STACK *s,char item){
if(full(s))
{
printf("Stack is full !!!\n");
return 0;
}
else
{
// printf("\tpush -> %d\n",item);
s->Data[s->sp++]=item;
}
return 1;
}
int full(STACK *s){
if(s->sp==MAXSTACK)
return 1;
return 0;
}
int pop(STACK *s,char *ret){
if(empty(s))
{
// printf("Stack is empty !!!\n");
return 0;
}
else
*ret=s->Data[--s->sp];
return 1;
}
int empty(STACK *s){
if(s->sp==0)
return 1;
return 0;
}
void main(void)
{
STACK s;
char *postfix="ab+c-d+e+";
char left,right;
int i;
Initialize(&s);
for(i=0;postfix[i]!='\0';i++)
{
if(postfix[i]>='a' && postfix[i] <= 'z')
{
push(&s,postfix[i]);
}
else{
if (pop(&s,&right)){
if (pop(&s,&left)){
printf("%c",left);
}
printf("%c",postfix[i]);
printf("%c",right);
}
}
}
if (pop(&s,&right))
printf("%c",right);
printf("\n");
}

infix To postfix

2007-05-09T23:36:00.000-07:00

#include
#include

#define MAXSTACK 5

typedef struct
{
int sp;
char Data[MAXSTACK];
}STACK;

void Initialize(STACK *s);
int push(STACK *s,char item);
int pop(STACK *s,char *ret);
int full(STACK *s);
int empty(STACK *s);

void Initialize(STACK *s)
{
s->sp=0;
}

int push(STACK *s,char item)
{
if(full(s))
{
printf("Stack is full !!!\n");
return 0;
}
else
{
// printf("\tpush -> %d\n",item);
s->Data[s->sp++]=item;
}
return 1;
}

int full(STACK *s)
{
if(s->sp==MAXSTACK)
return 1;
return 0;
}

int pop(STACK *s,char *ret)
{
if(empty(s))
{
// printf("Stack is empty !!!\n");
return 0;
}
else
*ret=s->Data[--s->sp];
return 1;
}

int empty(STACK *s)
{
if(s->sp==0)
return 1;
return 0;
}

void main(void)
{
STACK s;
char *infix="a+b-c+d+e";
char ch;
int i;
Initialize(&s);
for(i=0;infix[i]!='\0';i++)
{
if(infix[i]>='a' && infix[i] <= 'z')
{
printf("%c",infix[i]);
}
else{
if (pop(&s,&ch))
printf("%c",ch);
push(&s,infix[i]);
}

}
if (pop(&s,&ch))
printf("%c",ch);
printf("\n");
}

stack And queue

2007-05-09T23:31:00.000-07:00

#include

#define MAXSTACK 5

typedef struct
{
int sp;
int Data[MAXSTACK];
}STACK;

void Initialize(STACK *s);
int push(STACK *s,int item);
int pop(STACK *s,int *ret);
int full(STACK *s);
int empty(STACK *s);

void Initialize(STACK *s)
{
s->sp=0;
}

int push(STACK *s,int item)
{
if(full(s))
{
printf("Stack is full !!!\n");
return 0;
}
else
{
printf("\tpush -> %d\n",item);
s->Data[s->sp++]=item;
}
return 1;
}
int full(STACK *s)
{
if(s->sp==MAXSTACK)
return 1;
return 0;
}

...................................................

#include

#define MAXSTACK 5

typedef struct
{
int sp;
int Data[MAXSTACK];
}STACK;

void Initialize(STACK *s);
int push(STACK *s,int item);
int pop(STACK *s,int *ret);
int full(STACK *s);
int empty(STACK *s);

void Initialize(STACK *s)
{
s->sp=0;
}

int push(STACK *s,int item)
{
if(full(s))
{
printf("Stack is full !!!\n");
return 0;
}
else
{
printf("\tpush -> %d\n",item);
s->Data[s->sp++]=item;
}
return 1;
}
int full(STACK *s)
{
if(s->sp==MAXSTACK)
return 1;
return 0;
}
................................................