Problemas de programación de listas de secuencias

// 1.cpp: Define el punto de entrada para la aplicación de consola.

//

#include "stdafx.h"

#include

#include

#define MaxSize 100

#define InCreament 10

typedef int elemType;

struct SeqList

{

elemType *elem; //La dirección base de la tabla lineal

int length ; //La longitud de la tabla

int maxSize; //El espacio máximo ocupado

};

void againMalloc(struct SeqList *L)

{

/* El espacio se expande y al que apunta el puntero p. El contenido original se copia automáticamente al espacio de almacenamiento al que apunta p*/

<. p> elemType *p = (elemType *)realloc(L->elem, (L->maxSize+InCreament) * sizeof(elemType));

L->elem = p;

if(!p)

{

/* Salir si falla la asignación*/

printf("¡Error en la asignación de espacio de almacenamiento! ");

exit (1);

}

L->elem = p; /* Hacer que elem apunte al nuevo espacio de tabla lineal*/

L->maxSize = L ->maxSize+InCreament /* Modificar el tamaño del espacio de tabla lineal a la nueva longitud*/

}

/* 1. Inicialice el tabla lineal L, es decir, realizar una asignación dinámica de espacio de almacenamiento Concatenar L como una lista vacía*/

void InitSeqList(struct SeqList *L)

{

if(MaxSize <= 0)

{

printf("¡MaxSize es ilegal! ");

exit(1); finalizar el programa. Esta función está definida en stdlib.h */

}

L->elem = (elemType *)malloc(MaxSize*sizeof(elemType));

if(!L->elem )

{

printf("Error en la asignación");

exit(1);

}

L->longitud = 0;

L->maxSize = MaxSize;

}

/ * 2. Borre todos los elementos de la tabla lineal L, libere espacio de almacenamiento y conviértalo en una lista vacía*/

void clearList(struct SeqList &L)

{

if(L.elem != NULL)

{

libre(L.elem);

L.elem = N

ULL;

L.maxSize = 0;

L.length = 0;

}

retorno;

}

/* 3. Devuelve la longitud actual de la lista lineal L. Si L está vacía, devuelve 0 */

int sizeList(struct SeqList *L)

{

return L->length;

}

/* 4. Determine si la tabla lineal L está vacía. vacío, devuelve 1, de lo contrario devuelve 0 */

int vacíaList(struct SeqList *L)

{

if(L->length == 0)

{

devuelve 1;

}

más

devuelve 0;

}

/* 5. Devuelve el valor del elemento pos-ésimo en la lista lineal L. Si pos está fuera de rango, detenga el programa */

elemType getElem( struct SeqList *L, int pos)

{

if(pos < 0 || pos>L->longitud)

{

printf("¡Número de elemento fuera de límites! ");

salir(1);

}

else

regresar L->elem[pos-1];

}

/* 6. El escaneo secuencial (es decir, transversal) genera cada elemento en la lista lineal L*/

void traverseList(struct SeqList *L )

{

int i;

for(i=0; ilength; i++)

{

printf("%d ",L->elem[i]);

}

retorno;

}

/* 7. Encuentre el elemento cuyo valor es igual a x de la lista lineal L. Si la búsqueda es exitosa, devuelva su posición; de lo contrario, devuelva -1 */

int findList(struct SeqList *L, elemType x)

{

int i;

for(i=0; ilongitud; i++)

{

if(L->elem[i] == x)

{

retorno i;

}

}

return -1;

}

/* 8. Modifique el valor del elemento pos-ésimo en la tabla lineal L a x Valor, devuelve 1 si se modifica correctamente; de ​​lo contrario, devuelve 0 */

int updatePosList(struct SeqList *L, int pos, elemType x)

{

if (pos < 0 || pos>L->longitud)

{

printf("El número del elemento está fuera de límites! ");

devuelve 0;

}

else

{

L->elem[pos -1] = x;

devuelve 1;

}

}

/* 9.

Inserte el elemento x en el encabezado de la lista lineal L */

void insertFirstList(struct SeqList *L, elemType x)

{

if(L-> longitud == L->maxSize)

{

otra vezMalloc(L);

}

int i;

for(i=L->longitud-1; i>=0; i--)

{

L->elem[i+1] = L- > elem[i];

}

L->elem[0] = x;

L->longitud++;

return ;

}

/* 10. Inserte el elemento x al final de la lista lineal L */

void insertLastList(struct SeqList &L, elemType x)

{

if(L.length == L.maxSize)

{

otra vezMalloc(&L);

}

L.elem[L.longitud] = x;

L.longitud ++;

retorno;

}

/* 11. Insertar el elemento L, int pos, elemType x)

{

if(pos<1 || pos>L- >longitud+1)

{

printf("¡Error de inserción!");

devuelve 0;

}

if(L->longitud == L->maxSize )

{

otra vezMalloc(L);

}

int i;

for(i= L->longitud-1; i>=pos-1; i--)

{

L ->elem[i+1] = L->elem[i] ;

}

L->elem[pos-1] = x;

L->length ++;

return 1;

}

/* 12. Inserte el elemento x en la lista lineal ordenada L para que sea todavía ordenado después de la inserción*/

void insertOrderList( struct SeqList *L, elemType x)

{

if(L->length == L-> maxSize)

{

otra vezMalloc(L);

}

int i,j;

para (i=0; ilongitud; i++)

{

if(L->elem[i] == x)

romper ;

}

para (j=L->longitud-1; j>=i; i--)

{

L->elem[i+1] = L->elem[i];

}

L->elem[i ] = x;

L->longitud ++;

retorno;

}

/* 13. De la tabla lineal L Elimine el elemento del encabezado y devuélvalo. Si la eliminación falla, detenga el programa */

elemType deleteFirstList(struct SeqList *L)

{

si. ( L ->longitud == 0)

{

printf("¡La tabla lineal está vacía y no se puede eliminar! ");

exit(1 ) ;

}

elemType temp;

temp = L->elem[0];

for(int i=1 ; ilongitud-1;i++)

{

L->elem[i-1] = L->elem[i];

}

L->longitud --;

return temp;

}

/* 14. De la tabla lineal L Eliminar el elemento al final de la lista y devolverlo. Si la eliminación falla, detenga el programa */

elemType deleteLastList(struct SeqList *L)

{

if(L ->length == 0)

{

printf("¡La tabla lineal está vacía y no se puede eliminar! ");

salir(1);

}

L->longitud--;

return L ->elem[L->longitud] /* Devuelve el valor del elemento original al final de la tabla */

}

/* 15. Elimina el elemento pos-ésimo de la lista lineal L y devuélvelo If. la eliminación falla, detenga el programa */

elemType deletePosList(struct SeqList *L, int pos)

{

if(pos<1 || pos >L->longitud)

{

printf("¡El valor pos está fuera de los límites y no se puede realizar la operación de eliminación! ");

exit(1);

}

elemType temp = L->elem[pos-1];

for(int i=pos; ilongitud; i++)

{

L->elem[i-1] = L->elem[i];

}

L->longitud --;

temperatura de retorno;

}

/* 16. Elimine el primer elemento con valor x de la lista lineal L, devolviendo 1 si tiene éxito y 0 si falla */

int deleteValueList(struct SeqList *L, elemType x)

{

int i,j;

for(i=0; ilongitud; i++)

{

if(L

->elem[i] == x)

romper;

}

if(L->longitud == i)

{

devolver 0;

}

for(j=i+1;jlongitud;i++)

{

L->elem[j-1]=L->elem[j];

}

L->longitud--;

devuelve 0;

}

void sortList(struct SeqList *L)

{

int i, j;

int temp;

for(i=0; ilongitud; i++)

for(j=i+1;j longitud;j++)

{

if(L->elem[j]>L->elem[i])

{

temp = L->elem[i];

L->elem[i] = L->elem[j];

L->elem [j] = temp;

}

}

}

int main(int argc, char* argv[])

{

int x=0;

struct SeqList L;

InitSeqList(&L);

printf ("Ingrese un número entero (-1) para finalizar");

while(x!=-1)

{

scanf("%d", &x );

if(x!=-1)

insertLastList(L,x);

}

printf(" Tabla de pedidos\n");

traverseList(&L);

printf("\nLa longitud de la tabla es %d\n",sizeList(&L));

int n;

printf("Buscar valor del elemento\n");

scanf("%d",&n);

int pos = findList(&L,n);

printf("\nEncontrar el elemento en la posición %d\n",pos+1);

deletePosList(&L,pos+1) ;

printf("lista de secuencias\n");

traverseList(&L);

int p,q;

printf ( "\nIngrese el valor a insertar en la posición\n");

scanf("%d%d",&p,&q);

insertPosList(&L,p ,q );

printf("Lista de secuencias\n");

traverseList(&L);

sortList(&L);

printf("\nDespués de ordenar la lista de secuencias\n");

traverseList(&L);

printf("\n");

> devolver 0;

}