selección de casos de diseño de cursos de visual c y guía de programación 8-1 respuestas
#includelt;iostream.hgt;
#includelt;stdlib.hgt;
//usando el espacio de nombres std;
// -------------------------------------------------- -
typedef enum Tipo {Array, Punteros} Tipo;
typedef int Datos;
//------------ ---------------------------------------
clase UList // Clase base
{
público:
virtual int Size()=0;
virtual bool Insert(const Dataamp;, int )=0;
virtual bool Eliminar(int)=0;
virtual int Buscar(const Dataamp;)=0
virtual bool Obtener(int) , Dataamp;)=0;
virtual void Print()const=0;
};
//--------- -------------------------------------------------- --------------------------
clase PList: public UList //clase de operación de lista enlazada
{
clase Nodo{
Elemento de datos
Nodo *siguiente
público:
Nodo (const Data amp; dat): elemento (dat), siguiente (NULL) {} //Datos de inicialización
Nodo (const Node amp; nod): elemento (nod.item), siguiente (NULL) { } //
clase de amigo PList
};
Nodo *begin; //Puntero al encabezado
Nodo * end ; //Puntero a la cola
int num;
public:
PList(): comenzar(NULL), end(NULL), num( 0 ){}
~PList(){
Nodo *tmp=begin;
while(numgt;0){
comenzar =begin-gt;siguiente;
eliminar tmp;
tmp=begin;
}
}
/*Función*/ int Tamaño(){return num;}
/*Número*/ bool Insert(const Dataamp;, int);
/*Extensión*/ booleano Quitar
(int);
int Buscar(const Datosamp;);
bool Obtener(int, Datosamp;
/*明*/ void Imprimir( )const;
};
//----------------------------- --- ----------------------------------------------- --- ---
clase AList: public UList //Clase de operación matricial
{
Datos *arr // contiene la matriz dinámica
; p>
int num; // celdas llenas hasta el momento
public:
static const int MAX_SIZE; // valor inicial max_size
AList() : arr( nuevos datos[MAX_SIZE]), num(0){}
~AList(){delete[] arr;}
int Size(){return num;}
bool Insert(const Dataamp;, int);
bool Remove(int
int Find(const Dataamp;); p> bool Get(int, Dataamp;);
void Print()const;
};
//-------- --- ----------------------------------------------- --- -------
UList* init_list(Tipo
//-----------------); --- ----------------------------------------
clase UStack // Clase de operación de pila
{
UList *stk;
público:
UStack(Tipo k): stk( init_list(k)){};
bool Push(const Dataamp;);
bool Top(Dataamp;)
bool Pop(Dataamp; );
void Print()const{stk-gt;Print(); return;};
};
// ----- --------------------------------------- ----- ---------------------
const int AList::MAX_SIZE = 4;
/ /---- --------------------------------------- ----- ---------------------
UList* init_list(Kind k) //Función de inicialización
<p>{
UList *tmp;
switch(k){
case Matriz:
tmp=new AList; p>
descanso;
caso Punteros:
tmp=new PList
descanso
predeterminado:
coutlt;lt;endllt;lt;"opción desconocida"lt;lt;endl;
return NULL;
}
return tmp;
}
//------------------------------- ------------------------------------------------------
bool PList::Insert(const Data amp; x, int place) //Operación de inserción de lista enlazada
{
Nodo *tmp;
if ((placelt ;=0)||(placegt;num 1))
return false;
if (place==1) // insertar al principio del list
{ //Insertar al principio de la lista enlazada
tmp=begin;
begin=new Node(x);
comenzar-gt; next=tmp ;
if (num==0) // en caso de que sea el único elemento en la lista
{ //Solo un dato
end=begin;
end-gt; next=NULL
}
}
si ( place==num 1) // insertar al final de la lista
{ //Insertar al final de la lista enlazada
tmp=end;
end=nuevo Nodo(x);
end-gt; next=NULL;
tmp-gt; next=end;
else
{
Nodo *titular;
tmp=begin
for(int i=1; ilt; place-1; i) // reenviar hasta la lista (lugar -1)
tmp=tmp-gt; //Púltimo en la lista vinculada
holder=tmp -gt; siguiente;
tmp-gt ;siguiente=nuevo Nodo(x);
tmp-gt;siguiente-gt;siguiente=titular;
}
num;
devuelve verdadero;
}
//------------- -------------- -----------------------
----------------------------------
bool PList:：Eliminar(int lugar) // Operación de eliminación de lista enlazada
{
Nodo *tmp=begin;
if((placelt;=0)||(placegt;num 1) )
return false;
if(place==1) // eliminar el primer elemento
{ //eliminar los primeros datos
comenzar=begin-gt; siguiente;
eliminar tmp;
}
else if(place==num) // eliminar el último elemento
{ //Eliminar los últimos datos
for(int i=1; ilt; place-1; i)
tmp=tmp-gt; // Encuentra el final desde el principio
eliminar final
end=tmp
end-gt; > }
else
{
Nodo *titular;
for(int i=1; ilt; place-1; i )
tmp=tmp-gt;siguiente;
titular=tmp-gt;siguiente;
tmp-gt;siguiente=titular-gt;siguiente;
p>
eliminar titular
}
if(num==1)
end=begin=NULL;
--num;
devuelve verdadero;
}
//------------ ------ -------------------------------------------- ------ ------------
int PList::Find(const Data amp;x) //Búsqueda de nodos de lista vinculada
{
Nodo *tmp=begin;
int i=1;
while((tmp!=NULL)amp;amp;(tmp-gt; elemento!=x))
{
i;
tmp=tmp-gt;
}
if (tmp= =NULL)
devuelve 0;
devuelve i
}
//--- ------- ------------------------------------------- ------- ---------------------
bool PList::Get(int place, Data amp; ret) / /Obtener datos del nodo
{
Nodo *tmp=begin;
if((placelt;=0)||(placegt;num 1))
<p> devuelve falso;
for(int i=1; ilt; lugar; i)
tmp = tmp-gt;
ret = tmp -gt;item;
devuelve verdadero;
}
//------------------ -------------------------------------------------- ---------------
void PList::Print(void)const{ //Salida de lista enlazada
if (num==0 ) retorno;
coutlt; lt; "cabeza";
for(Nodo *tmp=begin; tmp!=NULL; tmp=tmp-gt; siguiente){
coutlt;lt;"-gt;"lt;lt;tmp-gt;item;
}
coutlt;lt;endl;
regresar;
}
//------------------------------ ---- ---------------------------------------------- ---- ---------------
bool AList::Insert(const Data amp; x, int place=1) //Inserta un elemento en el matriz
{
if (num==MAX_SIZE) // si la matriz está llena
return false;
if(( placelt;=0)| |(placegt;num 1))
return false;
for(int i=num;igt;=place-1;--i)
arr[i 1]=arr[i];
arr[place-1]=x;
num;
retorno verdadero;
}
//------------------------------- -------------- ------------------------------------ -------------- ------
bool AList：：Remove(int place) //Elimina un elemento de la matriz
{
if((placelt;=0 )||(placegt;num 1))
return false;
for(int i=place- 1;ilt;num; i)
arr [i]=arr[i 1];
--num;
devuelve verdadero;
}
//-- ---------------------------------- ---------------- ---------------------------------- -----
int AList:: Find(const Data amp;x) //La matriz encuentra un elemento<
/p>
{
int i=0;
while((ilt; num)amp; amp; (arr[i]!=x)) i;
if (i==num) i=-1; // llegamos al final del array
return i 1;
}
//---------------------------------------------------- -------------- ------------------------------------ ----
bool AList::Get(int place, Data amp; ret) //Obtener el valor del elemento
{
if((placelt ;=0)||( placegt;num 1))
devuelve falso;
ret = arr[lugar-1];
devuelve verdadero;
}
//---------------------------------- ------- ------------------------------------------- -------
void AList::Print()const //Matriz de salida
{
coutlt;lt;"head";
for (int i=0; ilt; num; i) coutlt; "-gt; "lt; arr[i];
retorno;
}
//------------------------ ---------- ---------------------------------------- ---------- ----------
bool UStack::Push(const Data amp; dat) //Operación de inserción
{
return stk-gt; Insert(dat, stk-gt; Tamaño()
}
//------ --------- ----------------------------------------- ---------
bool UStack::Top(Data amp; ret)const //Operación superior de la pila
{
int n =stk-gt;Tamaño();
si (nlt;=0) devuelve falso;
(void)stk-gt; Get(n, ret);
devuelve verdadero;
>}
//-------------------------- ------------- -----------------------
bool UStack::Pop(Datos amp; ret) //Operación pop
{
int n=stk-gt;Size();
if (nlt;=0) return false ;
(nulo)st
k-gt; Obtener(n, ret);
(void)stk-gt; Eliminar(n);
devolver verdadero; p>
//------------------------------------------- -- ------------------
// todas las funciones de prueba devuelven falso si una de las pruebas falla o verdadero si todas las pruebas tuvieron éxito
// la función informa fallas al dispositivo de salida de errores estándar
bool Test_insert (Kind k) //Inserción de prueba
{
bool res = true;
UList *tmp=init_list(k);
if (!tmp-gt;Insert(5,1))
{
cerr lt; "Error al insertar la prueba número 1: insertar en un número de celda válido" lt; > }
else
cout lt; lt; "Éxito en la prueba de inserción n.° 1: insertar en un número de celda válido" lt; > if (tmp-gt;Insert(3, tmp-gt;Size() 2))
{
cerr lt;lt; "Error en la prueba de inserción n.° 2 - insertar en el número de celda superior" lt; lt; endl;
res = false;
}
else
cout lt; lt ; "Exito en la prueba de inserción n.° 2: insertar en el número de celda superior" lt;
if (tmp-gt; Insert(3, 0))
{
cerr lt; "Error al insertar la prueba número 3: insertar en el número de celda inferior" lt; > }
else
cout lt; lt; "Éxito en la prueba de inserción n.° 3: insertar en el número de celda inferior" lt; if ( k==Array)
{
bool ares=true
for(int i=0; ilt; AList:: MAX_SIZE 1; i )
{
un
res=tmp-gt;Insertar(i, 1);
}
if (ares)
{
cerr lt; lt; "Error en la prueba de inserción n.º 4: la matriz está llena" lt;
res = false
}
else
cout lt;lt; "Exito en la prueba de inserción n.º 4: la matriz está llena" lt;lt; endl;
}
return res;
}
//------------------------------------ --------- ----------------------------------------- --------- -----
bool Test_remove (Tipo k) //Eliminación de prueba
{
bool res = true ;
UList *tmp=init_list(k);
for (int i=0; ilt; 10; i) // llenando la lista
{
(void )tmp-gt;Insert(i, 1);
}
if (!tmp-gt;Remove(5))
{
cerr lt; lt; "Error al eliminar la prueba número 1 - eliminar del número de celda válido" lt;
res = false;
}
else
cout lt; "Exito en Eliminar prueba número 1 - eliminar del número de celda válido" lt; /p>
if (tmp -gt; Remove(12))
{
cerr lt; "Error en la prueba de eliminación n.° 2: eliminar de la celda superior número" lt; lt; endl;
res = false;
}
else
cout lt; lt; "Éxito en Eliminar prueba n.° 2: eliminar del número de celda superior" lt; lt; endl;
if (tmp-gt; Remove(0))
{
cerr lt; "Error en la prueba de eliminación n.º 3: eliminar del número de celda inferior" lt;
res = false;
else
cout lt；lt; "Exito en la prueba de eliminación n.° 3 - remo
ve desde el número de celda inferior" lt; lt; endl;
return res;
}
//----------- -------------------------------------------------- ----------------------------------
bool Test_push (Tipo k) //Prueba push
p>{
bool res = true;
UStack *tmp = new UStack(k); tmp-gt; Push (7))
{
cerr lt; "Error en la prueba de Push n.º 1 - Push normal" lt; >
res = false;
}
else
cout lt; "Éxito en la prueba de empuje n.° 1 - Empuje normal" lt; lt; endl;
if (k==Array)
{
bool ares=true
for(int i= 0; ilt; AList ::MAX_SIZE 1; i)
{
ares=tmp-gt;
}
if (ares)
{
cerr lt; "Error en la prueba de inserción n.º 2: la matriz está llena" lt;
res = false;
}
else
cout lt; "Éxito en la prueba Push n.º 2: la matriz está llena" lt; lt; endl;
}
devolver res;
}
//----------- ----- --------------------------------------------- ----- -----------------------
bool Test_pop (Tipo k) //Prueba emergente
{
bool res = true;
UStack *tmp = new UStack(k);
Datos ret; >
(void)tmp-gt;Push(2);
if (!tmp-gt;Pop(ret))
{
cerr lt; "Fallo en la prueba Pop n.° 1 - Pop normal" lt;
res = false;
cout lt; "Éxito en la prueba Pop
no. 1 - Pop normal" lt;lt; endl;
if (tmp-gt;Pop(ret))
{
cerr lt;lt ; "Error en la prueba Pop nº 2 - Pop de la pila vacía" lt; endl; p>
cout lt; lt; "Éxito en la prueba Pop n.° 2 - Pop de la pila vacía" lt;
return res; p>
//------------------------------------------- ------------------------------------------------
int main()
{
while (1) //Múltiples bucles
{
int ch ;
Tipo k;
coutlt;lt;"elegir Tipo"lt;lt;endllt;lt;"1. Matriz"lt;lt;endllt;lt;"2. Punteros "lt;lt;
endllt;lt;"cualquier otro número para salir"lt;lt;endl;
cingt;gt;ch;
switch(ch){ //Seleccione tipo
caso 1: //
k=Array //
break;
caso 2: //
k=Punteros; //
break; //
predeterminado: //
coutlt ;lt; "adiós"lt;endl; //
salida(0); //
} //
coutlt;lt; ; "elegir prueba"lt;lt;endllt;lt;"1. insertar (LISTA)"lt;lt;endllt;lt;"2. eliminar (LISTA)"lt;lt;endl
lt ; lt;"3. push (STACK)"lt;lt;endllt;lt;"4. pop (STACK)"lt;lt;endllt;lt;"cualquier otro número para salir"lt;lt;endl;< / p>
cingt; ch;
cambiar(ch){
caso 1:
if(Test_insert(k))
coutlt;lt;endllt;lt;"insertar prueba exitosa"lt;lt;endl; //Inserción de prueba
bre
ak;
caso 2:
if(Test_remove(k))
coutlt;lt;endllt;lt;"eliminar prueba exitosa"lt;lt; endl; //Prueba de eliminación
break;
caso 3:
if(Test_push(k))
coutlt;lt; endllt;lt;"push test seccessful"lt;lt;endl; //Prueba push en la pila
break;
caso 4:
if( Test_pop( k))
coutlt;lt;endllt;lt;"prueba pop exitosa"lt;lt;endl; //Prueba emergente
break;
predeterminado:
coutlt;lt;"adiós"lt;lt;endl;
salida(0);
}
cout lt ;lt; endl lt;lt; endl;
}
devuelve 0;
}