- Crear una lista que almacene los "n"

primeros nmeros enteros y calcular el menor,

mayor y el promedio.

DATA HOSTED WITH BY PASTEBIN.COM - DOWNLOAD RAW - SEE ORIGINAL

1. /*
2. Autor: Joel Fernandez
3. Fecha: 11/10/14
4. Tema : Listas Enlazadas Simples
5. Ejercicio 1 : Crear una lista que almacene los n primeros numeros enteros
y calcular el menor, mayor, y el promedio.
6. */
7.
8.
9. #include <iostream>
10. #include <stdlib.h>
11.
12. using namespace std;
13.
14. struct nodo{
15.
16. int nro;
17.
18. struct nodo *sgte;
19.
20. };
21.
22.
23.
24. typedef struct nodo *Tlista;
25.
26.
27. /*-------------------- Insertar siguiente Elemento-------------------------*/
28. void insertarSgte(Tlista &lista, int valor)
29.
30. {
31.
32. Tlista t, q = new(struct nodo);
33.
34. q->nro = valor;
35.
36. q->sgte = NULL;
37.
38. if(lista==NULL)
39.
40. {
41. lista = q;
42. }
43.
44. else
45.
46. {
47. t = lista;
48. while(t->sgte!=NULL)
49. {
50. t = t->sgte;
51. }
52.
53. t->sgte = q;
54. }
55.
56. }
57.
58. /*----------------------Mostrar Lista--------------------------------------*/
59. void reportarLista(Tlista lista)
60.
61. {
62.
63. int i = 0;
64.
65. while(lista != NULL)
66.
67. {
68.
69. cout <<' '<< i+1 <<") " << lista->nro << endl;
70.
71. lista = lista->sgte;
72.
73. i++;
74.
75. }
76.
77. }
78.
79.
80. void calcularMayMenProm(Tlista
lista, int mayor, int menor, int promedio, int n){
81.
82. while(lista!=NULL){
83.
84. if(mayor<(lista->nro))
85.
86. mayor=lista->nro;
87.
88. if(menor>(lista->nro))
89.
90. menor=lista->nro;
91.
92. promedio+=lista->nro;
93.
94. lista=lista->sgte;
95. }
96.
97. promedio=promedio/n;
98.
99. cout<<endl<<"mayor:"<<mayor<<endl;
100.
101. cout<<endl<<"menor:"<<menor<<endl;
102.
103. cout<<endl<<"promedio:"<<promedio<<endl<<endl;
104.
105. }
106.
107. /*------------------------- Funcion Principal ---------------------------*/
108.
109. int main(void)
110.
111. {
112.
113. Tlista lista = NULL;
114.
115. system("color 0a");
116.
117. cout<<"\n\n\t\t[ EJERCICIOS LISTAS SIMPLES ]\n";
118.
119. cout<<"\t\t-----------------------------\n\n";
120.
121. cout<<" EJERCICIO 1: Calcular mayor,menor y promedio de una
lista"<<endl<<endl;
122.
123. cout<<"\n Ingrese tamanio de lista: ";
124.
125. cin>>n;
126.
127. for(int i=1;i<=n;i++){
128.
129. insertarSgte(lista,i);
130. }
131. cout<<endl<<"Elementos de lista"<<endl;
132. reportarLista(lista);
133.
134. mayor=lista->nro;
135.
136. menor=lista->nro;
137.
138. promedio=lista->nro;
139.
140. lista=lista->sgte;
141.
142. calcularMayMenProm(lista, mayor, menor, promedio, n);
143.
144.
145. system("pause");
146.
147. return 0;
148.
149. }

puedes descargar el codigo aqui

 Ejercicio 2::

- Almacenar numeros reales en una lista y

Reportarlos en forma ordenada.

DATA HOSTED WITH BY PASTEBIN.COM - DOWNLOAD RAW - SEE ORIGINAL

1. /*
2. Autor: Joel Fernandez
3. Fecha: 11/10/14
4. Tema : Listas Enlazadas Simples
5. Ejercicio 2 : Almacenar una lista de reales y reportarlos en forma
ordenada.
6.
7. */
8.
9. #include <iostream>
10. #include <stdlib.h>
11.
12. using namespace std;
13.
14. struct nodo{
15.
16. float nro;
17.
18. struct nodo *sgte;
19.
20. };
21.
22. typedef struct nodo *Tlista;
23.
24. Tlista fin;
25.
26. /*------------------Menu----------------------------------*/
27. void menu1()
28.
29. {
30.
31. cout<<"\n\n\t\t[ EJERCICIOS LISTAS SIMPLES ]\n";
32.
33. cout<<"\t\t-----------------------------\n\n";
34.
35. cout<<" EJERCICIO 2: Almacenar una lista de reales y
ordenarlos"<<endl<<endl;
36.
37. cout<<" 1. INSERTAR ELEMENTO "<<endl;
38.
39. cout<<" 2. MOSTRAR LISTA ORDENADA "<<endl;
40.
41. cout<<" 3. SALIR "<<endl;
42.
43.
44.
45. cout<<"\n INGRESE OPCION: ";
46.
47. }
48. /*----------------------------insertar elemento al inicio --------------------
-*/
49.
50. void insertarInicio(Tlista &lista, float valor)
51. {
52.
53. Tlista q;
54. q = new(struct nodo);
55.
56. q->nro = valor;
57.
58. q->sgte = lista;
59.
60. lista = q;
61.
62. }
63.
64. /*-------------------- Insertar siguiente Elemento-------------------------*/
65. void insertarFinal(Tlista &lista, float valor)
66.
67. {
68.
69. Tlista t, q = new(struct nodo);
70.
71. q->nro = valor;
72.
73. q->sgte = NULL;
74.
75. fin=q;
76.
77. if(lista==NULL)
78.
79. {
80. lista = q;
81. }
82.
83. else
84.
85. {
86. t = lista;
87. while(t->sgte!=NULL)
88. {
89. t = t->sgte;
90. }
91.
92. t->sgte = q;
93. }
94.
95. }
96.
97. /*------------------------- Funcio que inserta el elemento ordenado antes del
mayor y despues del menor*/
98. void insertarElementoEn(Tlista lista, float n){
99.
100. Tlista t,r,q=new (struct nodo);
101.
102. q->nro=n;
103.
104. q->sgte=NULL;
105.
106. while(lista->sgte!=NULL){
107.
108. t=lista->sgte;
109.
110. if((n>=(lista->nro))&&(n<=t->nro)){
111.
112. q->sgte=lista->sgte;
113.
114. lista->sgte=q;
115.
116. return;
117.
118. }
119.
120. lista=lista->sgte;
121.
122. }
123.
124. }
125. /*----------------------Mostrar Lista--------------------------------------*/
126. void reportarLista(Tlista lista)
127.
128. {
129.
130. int i = 0;
131.
132. while(lista != NULL)
133.
134. {
135.
136. cout <<' '<< i+1 <<") " << lista->nro << endl;
137.
138. lista = lista->sgte;
139.
140. i++;
141.
142. }
143.
144. }
145.
146.
147.
148. /*------------------------- Funcion Principal ---------------------------*/
149.
150. int main(void)
151.
152. {
153. Tlista lista = NULL;
154.
155. int op;
156.
157. float n;
158.
159. system("color 0a");
160.
161. do
162.
163. {
164.
165. menu1(); cin>> op;
166.
167. switch(op)
168.
169. {
170.
171. case 1:
172.
173. cout<< "\n NUMERO A INSERTAR: "; cin>> n;
174.
175. if(lista==NULL){
176.
177. insertarFinal(lista,n);
178.
179. }
180. else{
181. if(n<lista->nro)
182.
183. insertarInicio(lista,n);
184.
185. else if(n>fin->nro)
186.
187. insertarFinal(lista,n);
188.
189. else{ if((n>lista->nro)&&(n<fin->nro)){
190.
191. insertarElementoEn(lista,n);
192.
193. }
194.
195. }
196.
197.
198. }
199.
200. break;
201.
202.
203. case 2:
204.
205. cout<<endl<<"La lista Ordenada es:"<<endl;
206.
207. reportarLista(lista);
208.
209. break;
210.
211. case 3: return 0;
212.
213. default: cout<<"Ingrese una Opcion Valida....!"<<endl;
214.
215.
216. }
217.
218.
219.
220. cout<<endl<<endl;
221.
222. system("pause"); system("cls");
223.
224.
225.
226. }while(op!=3);
227.
228.
229.
230. system("pause");
231.
232. return 0;
233.
234. }
#ifndef LISTA_H_INCLUDED

#define LISTA_H_INCLUDED

#include "Nodo.h"

class lista

nodo*primero;

nodo*actual;

bool listaVacia(){

return (this -> primero == NULL)

public lista()

this -> primero = NULL;

this -> actual = NULL;

void insertar (int v)

nodo*nuevo = new Nodo(v);

if(listaVacia()){

this -> primero = nuevo;

else

this -> actual->siguiente = nuevo;

this ->primero = nuevo;

this -> actual = nuevo;

 }

#endif//lista de included

#ifndef LISTA_H_INCLUDED

#define LISTA_H_INCLUDED

class Nodo

private:

int valor;

Nodo*Siguiente;

public:

Nodo(int v, *sig=NULL){

this -> valor = v;

this -> siguiente *sig;

friend class lista;

};
Crear un sistema de ventas para una Tienda de
postres, la cual permita registrar y vender postres,
adicionalmente cada postre tiene m o n ingredientes.

Implementacion en C++:

DATA HOSTED WITH BY PASTEBIN.COM - DOWNLOAD RAW - SEE ORIGINAL

1. /*
2. Autor: Joel Cesar Fernandez Segura
3. Curso: Estructura de Datos
4. Ejercicio: VENTA DE POSTRES
5. IDE: CodeBlocks
6. Pagina Web: http://codebotic.blogspot.com
7.
8. */
9. #include<iostream>
10. #include<cstdlib>
11. #define maxchar 50
12.
13. using namespace std;
14.
15. struct nodo2{
16. char ingrediente[maxchar];
17.
18. };
19.
20. struct nodo{
21.
22. char nombre[maxchar];
23. float precio;
24. int codigo;
25. int cantIngred;
26. nodo2 ingred[maxchar];
27. struct nodo *sgte;
28.
29. };
30.
31. typedef struct nodo *TPostre;
32.
33. /*-------------------- FUNCION MENU PRINCIPAL ------------------*/
34. void menu(void){
35.
36. cout<<"\n\t\t[ VENTA DE POSTRES ]\n";
37. cout<<"\t\t--------------------------------\n\n";
38. cout<<" 1. REGISTRAR POSTRE "<<endl;
39. cout<<" 2. LISTAR POSTRES "<<endl;
40. cout<<" 3. VENDER POSTRE "<<endl;
41. cout<<" 4. SALIR "<<endl;
42.
43. cout<<"\n Ingrese opcion : ";
44. }
45.
46. /*------------------- FUNCION REGISTRAR UN POSTRE ------------------*/
47. void registrar_postre(TPostre &lista){
48.
49. TPostre t,q = new(struct nodo);
50.
51. cout<<"\n\n\t\t[ REGISTRO ]\n";
52. cout<<"\t\t------------";
53.
54. cout<<"\n\tDATOS DEL POSTRE \n";
55. cout<<"\n\tCODIGO DE VENTA:"; cin>>q->codigo;
56. cin.ignore();cout<<"\n\tNOMBRES:"; cin.getline(q->nombre,maxchar);
57. cout<<"\n\tPRECIO:"; cin>>q->precio;
58.
59. cout<<"\n\tIngrese Cantidad de Ingredientes:";
60. cin>>q->cantIngred;
61.
62. for(int i=0;i<q->cantIngred;i++){
63.
64. cin.ignore();
65. cout<<"\n\tIngrese ingrediente # "<<i+1<<" : ";
66. cin.getline(q->ingred[i].ingrediente,maxchar);
67.
68. }
69.
70. cout<<endl;
71.
72. system("cls");
73.
74. q->sgte = NULL;
75.
76. if(lista==NULL){
77.
78. lista = q;
79.
80. } else {
81.
82. t = lista;
83.
84. while(t->sgte!=NULL){
85.
86. t = t->sgte;
87. }
88.
89. t->sgte = q;
90.
91. }
92. }
93.
94. /*-------------------- MOSTRAR LISTA DE POSTRES ------------------*/
95. void listar_postres(TPostre q){
96.
97. int i=1;
98.
99. while(q!=NULL){
100.
101. cout<<"\n\n\tDATOS DEL POSTRE ["<<i<<"] ";
102. cout<<"\n\t------------------------";
103. cout<<"\n\tCODIGO DE VENTA: "<<q->codigo<<endl;
104. cout<<"\n\tNOMBRE : "<<q->nombre<<endl;
105. cout<<"\n\tPRECIO : "<<q->precio<<endl;
106. cout<<"\n\tINGREDIENTES:"<<endl;
107.
108. for(int j=0;j<q->cantIngred;j++){
109. cout<<endl<<"\t"<<j+1<<".- "<<q->ingred[j].ingrediente;
110. }
111.
112. q=q->sgte;
113.
114. i++;
115. }
116.
117. }
118.
119. /*-------------------- FUNCION VENDER POSTRE ------------------*/
120. void vender_postre(TPostre q){
121.
122. int cant;
123. int cod;
124.
125. cout<<"\n\n\n\t";
126. cout<<"\n\n\tINGRESE CODIGO DE VENTA:"; cin>>cod;
127.
128. while(q!=NULL){
129.
130. if(q->codigo==cod){
131.
132. system("cls");
133.
134. cout<<"\n\tDATOS DEL POSTRE";
135. cout<<"\n\t--------------------";
136. cout<<"\n\n\tCODIGO : "<<q->codigo<<endl;
137. cout<<"\n\tNOMBRE : "<<q->nombre<<endl;
138. cout<<"\n\tPRECIO : "<<q->precio<<endl;
139. cout<<"\n\tINGREDIENTES:"<<endl;
140.
141. for(int j=0;j<q->cantIngred;j++){
142.
143. cout<<endl<<"\t"<<j+1<<".- "<<q->ingred[j].ingrediente;
144. }
145.
146. cout<<"\n\n\tINGRESE CANTIDAD DE PORCIONES:";
147. cin>>cant;
148. cout<<"\n\n\tTOTAL A PAGAR:"<<cant*q->precio;
149. cout<<"\n\n\tGRACIAS POR SU COMPRA.....!!!!!!";
150.
151. return;
152.
153. }else {
154.
155.
156. q=q->sgte;
157.
158. }
159.
160. }
161. if(q==NULL)
162. cout<<"\n\tCODIGO INCORRECTO...!!\n";
163. }
164.
165.
166.
167. /*------------------------FUNCION PRINCIPAL-------------------------*/
168. int main(void){
169.
170. system("color 0a");
171.
172. TPostre lista=NULL;
173.
174. int op;
175.
176. do{
177. menu();
178. cin>>op;
179.
180. switch(op){
181.
182. case 1: registrar_postre(lista);
183. break;
184.
185. case 2: listar_postres(lista);
186. break;
187.
188. case 3: vender_postre(lista);
189. break;
190.
191. case 4: return 0;
192.
193.
194. default: cout<<"\nINGRESE UNA OPCION VALIDA...\n"; break;
195.
196. }
197. cout<<endl;
198. system("pause"); system("cls");
199.
200. }while(op!=6);
201.
202. system("pause");
203.
204. return 0;
205. }
En esta oportunidad les voy a compartir un cdigo
sobre Listas Enlazadas Circulares, Las listas
enlazadas circulares tienen la caracterstica de que
el ltimo nodo apunta al primer elemento de la lista.

Aqui podemos apreciar la representacin grafica de

una lista enlazada circular
Como vemos en las listas enlazadas circulares
simples solo tenemos un puntero que apunta al
siguiente nodo, caso diferente que en las
listas enlazadas doblemente circulares hay dos
punteros por cada nodo uno hacia adelante y otro
hacia atras. Bueno aqui la implementacion:

Implementacion en C++:

DATA HOSTED WITH BY PASTEBIN.COM - DOWNLOAD RAW - SEE ORIGINAL

1. /*
2. Autor: Joel Fernandez
3. Curso: Estructura de Datos
4. Ejercicio: IMPLEMENTACION DE UNA LISTA CIRCULAR
5. Descripcion: funciones inserta, elimina, busca y elimina
6. IDE: CodeBlocks
7. Pagina Web: http://codebotic.blogspot.com
8.
9. */
10.
11.
12. #include <iostream>
13. #include <cstdlib>
14. using namespace std;
15.
16. struct nodo{
17. int nro; //los datos seran de tipo entero
18. struct nodo *sgte; //puntero
19. };
20.
21. typedef struct nodo;//definimos a nodo como un tipo de variable
22. nodo *fin;//puntero que ira siempre al final de la lista
23. nodo *lista;//puntero que para nosotros apuntara a la cabeza de nuestra lista
24.
25. void menu1(); //declaramos las funciones a usar
26. void insertarInicio();
27. void insertarFinal();
28. void mostrar();
29. void buscarElemento();
30. void eliminarElemento();
31. void eliminarElementos();
32.
33. /* Funcion Principal
34. ---------------------------------------------------------------------*/
35.
36. int main(void)
37. {
38. lista = NULL;
39. int op; // opcion del menu
40.
41.
42. system("color 0a");
43.
44. do
45. {
46. menu1();
47. cin>>op;
48.
49. switch(op)
50. {
51. case 1:
52. insertarInicio();
53. break;
54.
55. case 2:
56. insertarFinal();
57. break;
58. case 3:
59. cout<<"\n\n Lista Circular \n\n";
60. mostrar();
61. break;
62.
63. case 4:
64. buscarElemento();
65. break;
66.
67. case 5:
68. eliminarElemento();
69. break;
70. case 6:
71. eliminarElementos();
72. break;
73.
74. default: cout<<"OPCION NO VALIDA...!!!";
75. break;
76.
77.
78. }
79.
80. cout<<endl<<endl;
81. system("pause"); system("cls");
82.
83. }while(op!=7);
84.
85. return 0;
86. }
87.
88. //////////////////////MOSTRAR MENU///////////////////////////////
89.
90. void menu1()
91. {
92. cout<<"\n\t\tLISTA ENLAZADA CIRCULAR\n\n";
93. cout<<" 1. INSERTAR AL INICIO "<<endl;
94. cout<<" 2. INSERTAR AL FINAL "<<endl;
95. cout<<" 3. REPORTAR LISTA "<<endl;
96. cout<<" 4. BUSCAR ELEMENTO "<<endl;
97. cout<<" 5. ELIMINAR ELEMENTO 'V' "<<endl;
98. cout<<" 6. ELIMINAR ELEMENTOS CON VALOR 'V' "<<endl;
99. cout<<" 7. SALIR "<<endl;
100.
101. cout<<"\n INGRESE OPCION: ";
102. }
103.
104. //////////////////////INSERTAR AL INICIO//////////////////////////
105.
106. void insertarInicio()
107. {
108. nodo *nuevo;
109. nuevo=new struct nodo;
110.
111. cout<<"\n***INSERTA AL INICIO*****\n";
112. cout<<"\nINGRESE DATO:";
113. cin>>nuevo->nro;
114. nuevo->sgte=NULL;
115.
116. if(lista==NULL)
117. {
118. cout<<"PRIMER ELEMENTO..!!!";
119. lista=nuevo;
120. lista->sgte=lista;
121. fin=nuevo;
122. }
123. else
124. {
125. nuevo->sgte = lista;
126. lista = nuevo;
127. fin->sgte = lista;
128. }
129.
130. }
131. //////////////////INSERTAR AL FINAL/////////////////////
132. void insertarFinal()
133. {
134. nodo *nuevo;
135. nuevo=new struct nodo;
136. cout<<"\n***INSERTA AL INICIO*****\n";
137. cout<<"\nINGRESE DATO:";
138. cin>>nuevo->nro;
139. nuevo->sgte=NULL;
140.
141. if(lista==NULL)
142. {
143. cout<<"PRIMER ELEMENTO..!!!";
144. lista=nuevo;
145. lista->sgte=lista;
146. fin=nuevo;
147. }
148. else
149. {
150. fin->sgte = nuevo;
151. nuevo->sgte = lista;
152. fin = nuevo;
153. }
154. }
155. //////////////////MOSTRAR TODOS LOS DATOS////////////////////////
156. void mostrar()
157. { nodo *aux;
158. aux=lista;
159. int i=1;
160.
161. if(lista!=NULL)
162. {
163. do
164. { cout<<" "<<aux->nro;
165. aux = aux->sgte;
166. i++;
167. }while(aux!=lista);
168. }
169. else
170. cout<<"\n\n\tLista vacia...!"<<endl;
171.
172.
173. }
174. //////////////////BUSCAR ELEMENTO///////////////////////
175. void buscarElemento() //esta funcion muestra la posicion del primer dato
coincidente
176. //encontrado en la lista
177. {
178. nodo *aux;
179. int i = 1, valor , flag = 0;
180.
181. cout<<"\nINGRESE ELEMENTO A BUSCAR:";
182. cin>>valor;
183. if(lista !=NULL)
184. {
185. aux = lista;
186.
187. do
188. {
189. if(aux->nro == valor)
190. {
191. cout<<"\n\n Encontrado en posicion "<< i <<endl;
192. flag=1;
193. }
194. else
195. {
196. aux = aux->sgte;
197. i++;
198. }
199. }while(aux!=lista);
200.
201. if(flag==0) cout<<"\n\n\tNumero no econtrado..!"<<endl;
202.
203. }
204. else
205. cout<<"\n\n\tLista vacia...!"<<endl;
206.
207. }
208. ////////////////ELIMINAR ELEMENTO DETERMINADO//////////////////////
209. void eliminarElemento()
210. {
211. nodo *aux, *r, *q;
212. int i = 1, flag = 0,valor;
213.
214. cout<<"\n INGRESE ELEMENTO A ELIMINAR:";
215. cin>>valor;
216.
217. if(lista !=NULL)
218. {
219. aux = lista;
220.
221. do
222. {
223. if(aux->nro == valor)
224. {
225. if(aux==lista)//si es que el dato a eliminar es el primero
226. { r=lista;
227. lista=lista->sgte;
228. aux=aux->sgte;
229. fin->sgte=lista;
230. r->sgte=NULL;
231. if(fin->sgte==NULL)
232. {
233. lista==NULL;
234. aux==NULL;
235. delete(r);
236. cout<<"\nELEMENTO ELIMINADO...!!!\n";
237. return;
238. }
239. else
240. {
241. delete(r);
242. cout<<"\nELEMENTO ELIMINADO...!!!\n";
243. return;
244. }
245. }
246. else
247. {
248. if(aux==fin)//si es que el dato a eliminar es al que
apunta a fin
249. {
250. r=aux;
251. aux=aux->sgte;
252. q->sgte=aux;
253. fin=q;
254. r->sgte=NULL;
255. delete(r);
256. cout<<"\nELEMENTO ELIMINADO...!!!\n";
257. return;
258. }
259. else
260. {
261. r=aux;
262. aux=aux->sgte;
263. q->sgte=aux;
264. r->sgte=NULL;
265. delete(r);
266. cout<<"\nELEMENTO ELIMINADO...!!!\n";
267. return;
268. }
269. }
270. flag=1;
271. }
272. else
273. { q=aux;
274. aux = aux->sgte;
275. i++;
276. }
277. }while(aux!=lista);
278.
279. if(flag==0)
280. cout<<"\n\n\tNumero no econtrado..!"<<endl;
281.
282.
283. }
284. else
285. cout<<"LISTA VACIA...!!!!";
286.
287.
288. }
289. //////////////////////ELIMINAR REPETIDOS/////////////////////
290. void eliminarElementos()
291. {
292. nodo *aux, *r, *q;
293. int flag = 0,valor;
294.
295. cout<<"\n DATO REPETIDO A ELIMINAR:";
296. cin>>valor;
297.
298. if(lista !=NULL)
299. { aux=lista;
300.
301. while(aux->nro==valor)//si los primeros elementos son repetidos
302. if(aux==lista) //esta funcion borra a estos
303. {
304. r=lista;
305. aux=lista->sgte;
306. lista=lista->sgte;
307. fin->sgte=lista;
308. r->sgte=NULL;
309. if(fin->sgte==NULL)
310. {
311. lista==NULL;
312. aux==NULL;
313. delete(r);
314. flag=1;
315. }
316. else
317. {
318. delete(r);
319. flag=1;
320. }
321. }
322. do
323. {
324. if(aux->nro == valor)
325. {
326. while(aux==lista)
327. {
328. r=lista;
329. aux=lista->sgte;
330. lista=lista->sgte;
331. fin->sgte=lista;
332. r->sgte=NULL;
333. if(fin->sgte==NULL)
334. {
335. lista==NULL;
336. aux==NULL;
337. delete(r);
338. }
339. else
340. delete(r);
341.
342. }
343.
344. if(aux==fin)//para si el elemento a borrar es apuntado por
*fin
345. {
346. r=aux;
347. aux=aux->sgte;
348. q->sgte=aux;
349. fin=q;
350. r->sgte=NULL;
351. delete(r);
352. }
353. else
354. {
355. r=aux;
356. aux=aux->sgte;
357. q->sgte=aux;
358. r->sgte=NULL;
359. delete(r);
360. }
361.
362. flag=1;
363. }
364. else
365. { q=aux;
366. aux = aux->sgte;
367. }
368. }while(aux!=lista);
369.
370. if(flag==0)
371. cout<<"\n\n\tNumero no econtrado..!"<<endl;
372. }
373. else
374. cout<<"LISTA VACIA...!!!!";
375. }