// ******************************************************
// Structure de données I : la pile Last In First Out (LIFO)
// Implementation au moyen d'un tableau. En indice 0, 
// le tableau contient le nombre d'éléments de la pile
//*******************************************************

// Mode de protection permettant de redefinir les variables...
funcprot(0)

maxtaille = 1000      // nombre maximal d'elements

// creation d'une pile (=matrice à une dim (=tableau)) de maxtaille+1
function S = pile()         // S est la variable renvoyee, pile la fonction.
    S = zeros(maxtaille+1)  // attention c'est une pile d'entiers exclusivement
endfunction

//-------------- 4 fonctions de consultation de la pile------//
// connaitre le nombre d'éléments de la pile
function nb = nombres?(S)
    nb = S(1)
endfunction
// savoir si la pile est vide
// la fonction admet une pile et renvoie un booleen (T ou F))
function Bool= vide?(S)
    Bool = (S(1)==0)
endfunction

// dessus de la pile = dernier élément inséré
function el = top(S)
    el=S(S(1)+1)
endfunction

// Consulter l'element d'indice ind de la pile S
function contenu=lire(S,ind)
    contenu = S(ind+1)
endfunction

//---------------- Modifier la pile : 3 fonctions ----------//

// ajouter un l'element 'el' à la pile S
function S = push(S,el)
    S(1)     = S(1)+1 // le nbre d'ekements
    indice   = S(1)+1 // l'indice du nouvel element
    S(indice)= el     // on l'ajoute
endfunction

// Retirer un element à S
function S = pop(S)
    S(S(1)+1) = 0        // on met à 0 le dernier element
    S(1)      = S(1)-1  // on decrement le nombre d'elements
endfunction

// Vider completement la pile
function V = vider(S)
    while (S(1)~=0)
        S=pop(S)
    end
    V = S
endfunction

// ------------------------The End-----------------------//
// exercices : 
// 1. creer une pile
// 2. ajouter quelques élements aléatoires (x = int(10*rand())
// 3. tester les fonctions de consultation et modification.
// 4. teminer en vidant la pile.
// 5. Imaginer des situations nécessitant l'utilisation des piles


//-------------------------------------------------------//
// alternative : une pile implementee avec une liste
//-------------------------------------------------------//

// creation de la pile
function S = pilel()
    S = list()                  // Une liste de Scilab non typee
endfunction

function Bool= videl?(S)
    Bool = (length(S)==0)
endfunction

function contenu=lirel(S,ind)
    contenu = S(ind)
endfunction

function S=pushl(S,el)
    S($+1) = el            // ajoute en queue de liste !!! attention :'$' !!!
endfunction

function S=popl(S)         // il suffit de mettre l'élément correspondant 
    S(length(S)) = null()  // à la hauteur de la pile à la valeur null
endfunction

function el = topl(S)      // on recupere l'element el du haut de la pile.
    el = S(length(S))
endfunction

a=topl(pushl(pushl (pilel(),3),6))


// -------------------------------------------------------------------//
// Structure de données II : la File First In First Out (FIFO)
// -------------------------------------------------------------------//
funcprot(0)

function S = coda()
    S = list()         // on utilise la liste de Scilab
endfunction
 
function Bool = videcoda?(S)
    Bool = (length(S)==0)
endfunction
 
function S = enqueue(S,el)  // Insertion
   S($+1) = el              // $ indique la queue de la liste
endfunction
 
function S = dequeue(S)      // deletion
   S(1) = null()
endfunction
 
function el = head(S)
    el = S(1)
endfunction

//--------------------------THE END-----------------------//