/************************************ * *******************
************************ ****** *******************************/
#ifndef _SQLIST_CPP
#define _SQLIST_CPP
#Incluye " MyClassLib.h "
# incluye ltiostream gt
# incluye ltiomanip gt
Utilice el espacio de nombres std
typedef int ElemType
//El constructor con parámetros predeterminados inicializa la tabla lineal.
SqList::SqList(entero sin signo n)
{
elem = nuevo tipo de elemento[n];
if( elem ==NULL)
Salir (desbordamiento); //Error en la asignación de almacenamiento
Longitud = 0 //La longitud de la lista vacía es 0
lista; size = n; //Capacidad de almacenamiento inicial
}
//Inicialización de la tabla lineal completada
//Destructor
SqList:: ~SqList()
{
Eliminar[]elem;
}
//Fin
/ /Crear una tabla lineal e ingresar datos.
void SqList::CreateList_Sq(void)
{
int I = 0;
cout lt lt"Ingrese el valor a se almacenará Contenido: ("
for(I = 0; i ltlistsizei)
CIN gt; gtelem[I];
length = listsize//table length
}
//End
//Obtener la información de la tabla lineal actual
void SqList::ListInfo()
{
cout lt lt"Contenido actual de la tabla lineal:"
for(int I = 0; i lt length; i)
cout lt ltsetw (5) lt; ltelem[I];
cout lt ltendl lt lt"Longitud actual de la tabla lineal:"
cout lt ltendl lt lt"Capacidad actual de la mesa lineal: "
p>}
//Fin
//Inserta el elemento dado en la posición especificada.
int SqList::list insert_Sq(elem tipo e, int lugar)
{
int j = 0;
ElemType * newbase
If (place lt1 | | place gt; length 1)
Error de retorno; //Determina la legalidad de la posición
//Se produce desbordamiento Aumentar asignación de espacio cuando
if (longitud gt = tamaño de la lista)
{
nueva base = nuevo tipo de elemento [incremento de lista del tamaño de la lista] //Reasignar más espacio
if(newbase==NULL)
Salir (desbordamiento);
//Si la asignación de memoria es exitosa, muévase antes de colocar los elementos en orden .
for(j = 0;j ltplace-1;j)
nueva base[j]= elem[j];
//Fin
Los elementos después de la secuencia p>
place se mueven hacia atrás en secuencia.
for(j = longitud; j gt= colocarj -)
{
nueva base[j]= elem[j-1] // a Mover elementos más tarde
}
//Fin
Eliminar []elem; //Liberar el espacio de tabla lineal anterior
elem = newbase
tamaño de lista = incremento de lista; //Aumento del espacio de tabla lineal
}
//Si hay suficiente espacio,
Otros
{
for(j = 0; j ltplace-1; j )
elem[j]= elem[j];
//End
Los elementos después de la secuencia de lugar se mueven hacia atrás en secuencia.
for(j = longitud; j gt= colocarj -)
{
elem[j]= elem[j-1] // mover hacia atrás; elemento
}
//End
}
elem[place-1]= e; //Insertar en el número de serie posición Nuevos elementos.
Longitud ; //La longitud de la tabla lineal aumenta.
Regresar OK;
}
//Operación de inserción completada
///Eliminar el elemento I-ésimo en la tabla lineal L , utilice e para devolver su valor.
int SqList::ListDelete_Sq(int i, ElemType ampe)
{
int j = 0
if (i lt1; | | I gt; longitud 1)
Error de retorno; //Juzga la legalidad de la posición
e = elem[I-1];
/ / Eliminar
for(j = I; j lt longitud; j)
{
elem[j-1]= elem[j];
}
Longitud-;
Volver OK;
}//Eliminación completa
//Tabla lineal en línea L Busque los datos E y regrese a la tabla almacenada; de lo contrario, se informará un error.
int SqList::Location_Sq(elem tipo e)
{
int I = 0
mientras(i lt Longitud y length. =e)
i;
Si (i gt=length)
devuelve NOFOUND
Otro
Return I; //Devuelve el índice de almacenamiento de e.
}
//La búsqueda finaliza
//Dividimos la lista lineal en función del primer elemento.
int SqList::Part_Sq()
{
int i, j
int x, y
;x = elem[0]; //Pon los datos en el eje x
for(I = 1; i lt length; i)
{
//El elemento actual es más pequeño que la línea base.
if(elem[I] lt; x)
{
y = elem[I];
//movimiento hacia atrás
for(j = I-1; j gt=0; j -)
{
elem[j 1]= elem[j]; /p>
}
elem[0]= y;
}
}
Regresar OK;
}
}
Regresar OK;
} p>
}
//La división ha terminado
//Devuelve el número de elementos de la lista lineal actual.
int SqList::GetLength(void)
{
Devuelve la longitud
}
/ / End
//Devuelve la longitud de la tabla lineal (espacio ocupado)
int SqList::GetSize(void)
{
Devolver tamaño de lista
}
//Fin
//Clasificación por inserción directa
void SqList::SortList (condición booleana)
{
tipo de elemento t = 0
int i=0, j = 0
If(condición==verdadero; )// Ordenar en orden ascendente.
{
for(I = 1; I lt length; I) //Número de selecciones: 1~n-1***n-1 veces.
{
//Almacena temporalmente el número con el subíndice I.. Nota: El subíndice comienza desde 1 porque está al principio.
//El primer número, es decir, el número con el subíndice 0, no tiene ningún número delante, sino solo uno, por lo que el orden se considera bueno.
t = elem[I];
{
//Nota: j=i-1, j-, aquí está el número con el subíndice I, encuentre la posición de inserción en la secuencia anterior.
for(j = I-1; j gt= 0 amp ampt ltelem[j]; j -)
{
//Si las condiciones son se encuentran y luego retroceden. En el peor de los casos, t es menor que cualquier número con un subíndice de 0, por lo que debe colocarse al frente, j==-1, y salir del ciclo.
elem[j 1]= elem[j];
}
elem[j 1]= t; // Encuentra el número con la ubicación del subíndice I ubicación.
}
}
}
De lo contrario//Organizar en orden descendente
{
for(I = 1; Ilt length; I) //Número de selecciones: 1~n-1***n-1 veces.
{
//Almacena temporalmente el número con el subíndice I.. Nota: El subíndice comienza desde 1 porque está al principio.
//El primer número, es decir, el número con el subíndice 0, no tiene ningún número delante, sino solo uno, por lo que el orden se considera bueno.
t = elem[I];
{
//Nota: j=i-1, j-, aquí está el número con el subíndice I, encuentre la posición de inserción en la secuencia ordenada anterior.
for(j = I-1; j gt= 0 amp ampt gtelem[j]; j -)
{
//Si las condiciones son se encuentran y luego retroceden. En el peor de los casos, t es menor que cualquier número con un subíndice de 0, por lo que debe colocarse al frente, j==-1, y salir del ciclo.
elem[j 1]= elem[j];
}
elem[j 1]= t; //Encontrar el número con la ubicación del subíndice I ubicación.
}
}
}
}
//Fin
/ ///////////Fusionar la y lb en lc (función amiga de SqList)
int MergeList_Sq(SqList la, SqList lb, SqList amplc)
{
int i=0, j=0, k = 0;
if((la.length lb.length)>longitud)
{
Salir (desbordamiento);
}
//Fusionar la y lb
mientras(i lt longitud y longitud. ampj lt lb longitud )
{
if(la . elem[I] lt; elemento[j])
LC . elem[k ]= la . ];
Otros
LC . elem[k ]= lb . elementos restantes de la
while(ilt=la.length-1)
LC . elem[k] = la elem[i];
/. /Inserte los elementos restantes de lb
while(j lt;=lb length-1)
LC . elem[k]= lb .
LC longitud = la . longitud lb longitud;
Regresar OK;
}
////////// El. la fusión está completa.
#endif
Contenido del archivo MyClassLib.h
/********************* * **************************
*************** ******* ****************************/
#ifndef _SQLIST_H_H
#define _SQLIST_H_H
# definelisinitsize 10//Asignación inicial de espacio de almacenamiento
# definelisincrement 3//Incremento de asignación de espacio de almacenamiento
typedef int ElemType
typedef enum {
Overflow = -1, // Sin memoria.
Aceptar = 0. //Regresa normalmente.
ERROR = 1, //Error de operación.
No encontrado = 2 //No encontrado
} estado
Categoría SqList
{
Privado; ：
ElemType * elem//La dirección base del espacio de almacenamiento
int length; //La longitud de la tabla lineal actual
int listsize// La capacidad de almacenamiento asignada actualmente, en unidades de tamaño ElemType.
Público:
//Inicializa una tabla lineal SQLIST (unsigned int n = Listinitsize).
//Constructor con parámetros predeterminados (n especifica la longitud de la tabla lineal)
SqList(unsigned int n = ListInitSize);
//Convierte el data void CreateList_Sq(void) ingresa a la lista lineal establecida.
void create list _ Sq(void);
//Obtiene la información de la tabla lineal actual, void ListInfo()
void ListInfo(); /p>
p>
//Ordenar la lista lineal actual, anular SortList (condición bool)
//Descripción del parámetro de condición: (Verdadero: orden ascendente, falso: orden descendente)
void SortList(bool condition);
//Inserta el elemento dado intlistinsert_sq (elementtype e, intplace = 1) en la posición especificada.
//Hay dos valores de retorno: (Error: posición de inserción ilegal, OK: inserción exitosa)
int ListInsert_Sq(ElemType e, int place = 1);
//Elimina el elemento I-ésimo en la lista lineal y devuelve su valor int list delete _ sq (int i, tipo de elemento; e)
//Hay dos valores de retorno: (error : La ubicación de eliminación es ilegal, OK: eliminación exitosa).
int ListDelete_Sq(int i, ElemType ampe);
// Busque los datos E en la tabla lineal y encuentre la tabla donde están almacenados; de lo contrario, procese int Location_Sq( ElemType; mi).
//Hay dos valores de retorno: (NOFOUND: el elemento no existe, la búsqueda falló, OK: la búsqueda fue exitosa).
int Location _ Sq(elem type e);
//Dividimos la tabla lineal según el primer elemento int Part_Sq().
int Part _ Sq();
//Devuelve el número de elementos en la tabla lineal actual int GetLength(void)
int GetLength(void)
//Devuelve la longitud (espacio ocupado) de la tabla lineal int GetSize(void).
int GetSize(void);
//Destructor
~ SqList();
amigo int MergeList_Sq(SqList la , SqList lb, SqList ampLC); // Combina la y lb en lc.
};
#endif