* Stack* is a logical data structure, its implementation in physical memory being made by using other data structures.

The components of the

*stack*data structure have the same data type, which means that the

*stack*is a homogeneous data structure.

There are two basic operations with

*stack*: adding and removal of an item.

Manner of implementation for operations is given by the discipline of access:

*.*

**LIFO – Last In First Out**All adds (

**push**) and extractions (

**pop**) are achieved at the same end of the implementation structure, called the

*stack top*.

In the below example, implementations of

*push*and

*pop*operations are presented, using as implemention structure the

*simply linked list*[…]. The each element structure of the

*stack*is formed by a value of type

**int**and the address of next element of the

*stack*.

struct Nod{ int val; Nod* next; }; Nod* push(Nod* vf, int v){ Nod* nou=new Nod; nou->val=v; nou->next=vf; return nou; } Nod* pop(Nod* vf, int *v){ if(vf){ *v=vf->val; Nod* t=vf; vf=vf->next; delete t; return vf; } return vf; }

* Queue* keeps the characteristics of the

*stack*structure, less the issues regarding the implemention of the insertion and extraction operations. Thus, the implementation way of the operations is given by access discipline:

*. All adds (*

**FIFO – First In First Out****put**) are made at one end of the structure of physical implementation, and extractions from the

*queue*(

**get**) are achieved at the other end of the structure.

In the below example, implementations of operations

*put*and

*get*are presented, using as support structure the

*simply linked list*[…]. The each element structure of the

*queue*is formed from a value of type

**int**and address of the successor node from

*queue*structure.

struct Nod{ int val; Nod* next; }; Nod* put(Nod* c,int v){ Nod* nou=new Nod; nou->val=v; nou->next=NULL; if(!c) return nou; else{ Nod* t=c; while(t->next) t=t->next; t->next=nou; return c; } } Nod* get(Nod* c,int *v){ if(c){ *v=c->val; Nod* t=c; c=c->next; delete t; return c; } return c; }