stack &queue help?

اختي هذا البرنامج هو عباره عن heder فيه جميع العمليات المطلوبه من

1- link list

2-array of stack

3- stack of linklist

4- array of queue

5- queue of linklist

وكل وحده انا مقسم ال prototype حقها

يعني نزل الهيدر هذا عندك واحفضه على شكل .h بعدين استدعيه من داخل البرنامج

اذا سميت البرامج هذا opration

داخل البرنامج الاصلي اكتب

#include "opration.h"

#include<stdio.h>
#include<stdlib.h>

typedef int standard_element;
typedef struct node{
	standard_element key;
	struct node *next;
}node;

/***Define LinkList***/
typedef struct linklist{
	node *head,*current;
}linklist;

/*** Define Stack Link***/
typedef struct stack{
	node * tos;
}stack;

/***Define Stack_Array***/
typedef struct stack_a{
	int max_size;
	int tos;
	standard_element *array;
}stack_a;

/***Define Queue Link***/
typedef struct queue{
	node *head,*tail;
	int size;
}queue;

/***Define Queue circlar**/
typedef struct {
	int max_size;
	int size;
	int head,tail;
	standard_element *circal;
}queue_c;

           /********PROTO TYPE*******/
//1 LINK LIST
void create(linklist *);
int empty (linklist *);
void updata(linklist *,standard_element );
void retrive(linklist *,standard_element *);
void findnext(linklist *);
void findfirst(linklist *);
int last(linklist *);
void insert(linklist *,standard_element );
void delet(linklist *);

////////////////////
//2 STACK LINKS
void push(stack *,standard_element );
void pop(stack * ,standard_element* );
int is_empty_s(stack *);
void create_s(stack*);

///////////////////
//3 STACK  ARRAY
void push_sa(stack_a *,standard_element );
standard_element pop_sa(stack_a *);
stack_a* create_sa(int);
int is_empty_sa(stack_a *);
int is_full_sa(stack_a *);
void dispose_sa(stack_a*);

////////////////////
//4 Queue Link
void enqueue(queue *,standard_element );
void dequeue(queue *,standard_element *);
int is_empty_q(queue *);
int queue_size(queue *);

///////////////////
///5 Queue Circlar array
void enqueue_c(queue_c *,standard_element );
standard_element dequeue_c(queue_c *);
queue_c* create_qc(int );
int is_empty_qc(queue_c *);
int is_full_qc(queue_c *);

/********************/////STACK LINK/////////********************/
void push(stack *s,standard_element x)
{
 node *pnew;
 pnew=(node*)malloc(sizeof(node));
 pnew->key=x;
 pnew->next=s->tos;
 s->tos=pnew;

}
/*****************/
void pop(stack *s,standard_element* x)
{
	node *p;
	p=s->tos;
	*x=p->key;
	s->tos=s->tos->next;
	free(p);

}
/****************/
int is_empty_s(stack *s)
{
	return (s->tos==NULL);
}
/***************/
void create_s(stack*s)
{
	s->tos=NULL;
}

/***********************////END STACK LINK//////**************/

/**************************///STACK ARRAY///*****************/
void push_sa(stack_a *s,standard_element x)
{
	s->array[++ s->tos]=x;

}
/****************/
standard_element pop_sa(stack_a *s)
{
	return s->array[s->tos--];
}
/***************/
stack_a* create_sa(int max_size)
{
	stack_a *s;
	s=(stack_a*)malloc(sizeof(stack_a));
   
	s->array=(standard_element*)malloc(max_size*sizeof(standard_element));
	s->max_size=max_size;
	s->tos=-1;
	return s;
}
/**************/
int is_empty_sa(stack_a *s)
{
return (s->tos==-1);
}
/*************/
int is_full_sa(stack_a *s)
{
return (s->tos==s->max_size-1);
}
/**************/
void dispose_sa(stack_a*s)
{
	if(s!=NULL){
  free(s->array);
        free(s);
	}
}
/***************/
void make_empty_sa(stack_a*s)
{
	s->tos=-1;
}

/*************************///End Stack Array///**************/



/**********************/////LINK LIST/////*******************/
void create(linklist *l)
{
	l->head=NULL;
}

/*********************/
int empty (linklist *l)
{
return (l->head==NULL);
}
/********************/
 void retrive(linklist *l,standard_element *x)
{
  *x=l->current->key;
}

 /*******************/
 void updata(linklist *l,standard_element x)
 {
  l->current->key=x;
 }
 /******************/
 void findnext(linklist *l)                  
 {
  l->current=l->current->next;

 }
 /********************/
 void findfirst(linklist *l)
 {
  l->current=l->head;
 }
 /*********************/
 int last(linklist *l)
 {
  return (l->current->next==NULL);
 }
 /**********************/
void insert(linklist *l,standard_element x)
{
	node *p;
	p=(node*)malloc(sizeof(node));

	p->key=x;
	p->next=l->head;
	l->head=l->current=p;
}
/****************************/
void delet(linklist *l)
{
  node *p;
   if(l->current==l->head)
  l->head=l->head->next;

  else{
  p=l->head;
  while(p->next != l->current)
   p=p->next;

  p->next=l->current->next;
 }

 free(l->current);
 l->current=l->head;
}

/*************************/
int end(linklist *l)
{
	return (l->current==NULL);
}

/*******************///// END LINK LIST/////*******************/

/******************/////Queue Link////////********************/
void create_q(queue *q)
{
	q->head=q->tail=NULL;
	q->size=0;
}
/****************/
void enqueue(queue *q,standard_element x)
{
	node*pnew;
	pnew=(node*)malloc(sizeof(node));
	pnew->key=x; 
	if(q->head==NULL)
  q->head=q->tail=pnew;
	else{
  q->tail->next=pnew;
  q->tail=pnew;
  q->size++;
	}

}
/*****************/
void dequeue(queue *q,standard_element *x)
{
 node *temp;
 temp=q->head;
 q->head=q->head->next;
 *x=temp->key;
 free(temp);
 q->size--;
 if(q->size==0)
  q->tail=NULL;
}
/****************/
int is_empty_q(queue *q)
{
	return (q->head==NULL);
}
/****************/
int queue_size(queue *q)
{
	return q->size;
}
/*****************/////END Queue Link ************************/

/*****************///Queue circalar//************************/

void enqueue_c(queue_c *q,standard_element x)
{
 q->circal[q->tail]=x;
 q->tail=(q->tail +1) % q->max_size;
 if(q->size <q->max_size)
 q->size++;
}
/****************/
standard_element dequeue_c(queue_c *q)
{
	standard_element x;
	x=q->circal[q->head];
	q->head=(q->head+1) % q->max_size;
	q->size--;
	return x;
}
/****************/
queue_c* create_qc(int max_size)
{
    queue_c *q;
	q=(queue_c *)malloc(sizeof(queue_c));

	q->max_size=max_size;
	q->size=q->head=q->tail=0;
	q->circal=(standard_element*)malloc(max_size*sizeof(standard_element));
   return q;
}
/*****************/
int is_empty_qc(queue_c *q)
{
	return (q->size==1);
}
/*****************/
int is_full_qc(queue_c *q)
{
	return (q->size==q->max_size);
}

/***************///End Queue circlar///*********************/

السلام عليكم

اخ عبدالله يعطيك الف عافيه ما تدري شكثر فدتني جزاك الله الف الف خير

تحياتي :)

العفو ولو في برنامج سويته بأحد هذي العمليات وما طبق انا إن شاء الله اساعدك فيه