Red de conocimiento informático - Conocimiento del nombre de dominio - Código fuente del algoritmo de fusión

Código fuente del algoritmo de fusión

Esta lista vinculada incluye agregar, eliminar, buscar y modificar. En general debería ser suficiente. Espero que ayude.

No debería ser difícil modificar el nombre de la función y luego llamar a la función interna para crear una nueva función para fusionar y dividir.

Plantilla lttypename T gt

Lista de candidatos clasificados según las puntuaciones de los exámenes

{

Privado:

Nodo de estructura

{

Datos de prueba;

Nodo * siguiente;

Nodo (T ampt constante=T( )): Datos (T)

{ next = NULL}

};

Nodo* cabeza;

Nodo* getPointer( int pos)

{

Nodo * p = encabezado

for(int I = 0; i ltposi )

p = p- gt; siguiente;

return p;

}

Público:

lista(): head(NULL){ };

Vacío clear()

{

Y (head!=null)

{

nodo * p = head - gt; siguiente;

Eliminar encabezado

head = p; Lista()

{

clear();

}

inserción nula _ front(const T amp;t)

{

Nodo* p = nuevo nodo (t);

p->; siguiente = cabeza

cabeza = p;

}

Itinerario no válido()

{

Nodo* p = cabecera;

Y (p! =null)

{

cout lt ltp->;data lt lt' ';

p = p- gt Siguiente;

}

cout lt ltendl

}

void insert _ back(const T amp; t)

{

Nodo* p = nuevo nodo(t);

if(head == 0)

head = p;

Otros

{

obtener puntero(tamaño()-1)- gt; siguiente = p

}

}

int tamaño()

{

int CNT = 0;

Nodo* p = encabezado

Y (p! = vacío)

{

cnt;

p = p- gt; siguiente;

}

Devuelve cnt

}

T getHead()

{

if(head == NULL)

Lanzar "sin cabeza";

Devolver encabezado - gt; datos;

}

T getTail()

{

if(head == NULL)

Lanzar "sin cola";

Nodo* p = head;

while(p-> ;Siguiente ! = vacío)

{

p = p- gt;Siguiente;

}

Devolver p- gt ;datos;

}

Booleano vacío()

{

retur

n head = = NULL

}

int find(const T amp; t)

{

int pos = 0;

Nodo* p = encabezado;

Y (p!=null)

{

Si (p->; datos == t)

Posición de retorno;

pos;

p = p- gt;

}

return-1;

}

Datos de actualización booleana (const T ampo, const T ampn)

{

int pos = buscar(o);

if(pos == -1)

Devuelve falso

nodo * p = obtener puntero(pos);

p->;data = n;

Devuelve verdadero

}

Borrado booleano (T ampt constante)

{

int pos = find(t);

if(pos == -1)

Devuelve falso

Si (posición = = 0)

{

nodo * p = head- gt;

eliminar encabezado

head = p;

}

Otros

{

nodo * pre = get pointer(pos-1);

nodo * cur = pre- gt; siguiente;

pre->; siguiente = cur- gt;

Eliminar cur

}

Devuelve verdadero

}

};