Programa en C para encontrar tabla de secuencia, pila de secuencia y cola circular
/****************************************** **************************/
/* Las siguientes son 16 instrucciones sobre el algoritmo de operaciones de almacenamiento secuencial de tablas lineales. */
/****************************************** ** ************************************/
estructura Lista{
elemType *list;
int tamaño;
int maxSize
}; Lista *L)
{
/* El espacio se expande a 2 veces el tamaño original y es señalado por el puntero p. El contenido original se copia automáticamente al espacio de almacenamiento. señalado por p*/
elemType *p = realloc(L-gt; list, 2 * L-gt; maxSize * sizeof(elemType));
if(!p ){ /* Salir si la asignación falla* /
printf("¡La asignación de espacio de almacenamiento falló! ");
exit(1); p>
L-gt; list = p; /* Hacer que la lista apunte al nuevo espacio de tabla lineal*/
L-gt; maxSize = 2 * maxSize; el tamaño del espacio de tabla lineal a la nueva longitud*/
}
/* 1. Inicialice la tabla lineal L, es decir, asigne espacio de almacenamiento dinámico y establezca L como una tabla vacía */
void initList(struct List *L, int ms)
{
/* Compruebe si ms es válido; si no es válido, salga de la operación * /
if(ms lt;= 0){
printf("¡MaxSize es ilegal! ");
exit(1); función para finalizar el programa esta función está definida en stdlib.h* /
}
L-gt; maxSize = ms /* Establece el tamaño del espacio de tabla lineal en ms *; /
L-gt; tamaño = 0;
L-gt; lista = malloc(ms * sizeof(elemType)); -gt; lista){
printf("¡Error en la asignación de espacio! ");
salir(1);
}
regresar;
}
/* 2 .Borre todos los elementos de la lista lineal L, libere espacio de almacenamiento y conviértala en una lista vacía*/
void clearList(struct List *L)
{
if(L-gt; lista != NULL){
gratis(L-gt; lista);
L-gt; lista = 0;
L-gt; tamaño máximo = 0; p> }
return;
}
/* 3. Devuelve la longitud actual de la tabla lineal L. Si L está vacío, devuelve 0 */
int sizeList(struct List *L)
{
return L-gt;size;
}
/* 4. Determine si la lista lineal L está vacía. Si está vacía, devuelva 1; de lo contrario, devuelva 0 */
int vacíaList(struct List *L)
{
if(L-gt; size ==0){
devuelve 1;
}
else{
return 0;
}
}
/* 5. Devuelve el valor del elemento pos-ésimo en la tabla lineal L. Si pos excede el rango, detenga el programa Ejecutar */
elemType getElem(struct List *L, int pos)
{
if(pos lt; 1 || pos gt; L-gt ;size){ /* Si pos está fuera de los límites, salga de la operación*/
printf("¡El número del elemento está fuera de los límites! ");
exit(1);
}
return L-gt; list[pos - 1] /* Devuelve el valor del elemento con el valor pos del número de serie en el lista lineal*/
}
/* 6. El escaneo secuencial (es decir, recorrido) genera cada elemento en la lista lineal L*/
void traverseList(struct Lista *L)
{
int i;
for(i = 0; i lt; L-gt; tamaño; i ){
printf("d ", L -gt; lista[i]
}
printf(" ");
}
/* 7. Encuentra el elemento cuyo valor es igual a x de la lista lineal L. Si la búsqueda es exitosa, devuelve su posición, de lo contrario devuelve -1 */
int findList(struct List *L, elemType x)
{
int i
for(i = 0; i; lt; L-gt; tamaño; i ){
if(L- gt;list[i] == x){
devolver i;
}
}
return -1;
p>}
/* 8. Modificar el valor del elemento pos-ésimo en la tabla lineal L al valor de x. Si la modificación es exitosa, devuelve 1; de lo contrario, devuelve 0 */
int updatePosList(struct List *L, int p).
os, elemType x)
{
if(pos lt; 1 || pos gt; L-gt; size){ /* Si pos está fuera de los límites, la modificación falla */
devolver 0;
}
L-gt; lista[pos - 1] = x
devolver 1;
}
/* 9. Inserte el elemento x en el encabezado de la lista lineal L */
void insertFirstList(struct List *L, elemType x)
{
int i;
if(L-gt; tamaño == L-gt; maxSize){
otra vezMalloc(L );
p>}
for(i = L-gt; tamaño - 1; i gt; = 0; i--){
L -gt; lista[i 1] = L -gt; lista[i];
}
L-gt; > L-gt; tamaño ;
return;
}
/* 10. Inserte el elemento x al final de la lista lineal L */
void insertLastList (struct List *L, elemType x)
{
if(L-gt; size == L -gt; maxSize){ /* Reasignar más grande espacio de almacenamiento* /
otra vezMalloc(L);
}
L-gt; lista[L-gt; tamaño] = x; en la tabla Tail*/
L-gt; /* Aumenta la longitud de la tabla lineal en 1 */
return
}
/* 11. Inserte el elemento x en la posición del elemento pos-ésimo en la lista lineal L. Si la inserción es exitosa, devuelva 1; de lo contrario, devuelva 0 */
int insertPosList( Lista de estructuras *L, int pos, elemType x)
{
int i
if(pos lt; 1 || pos gt; L-gt ; tamaño 1){ /* Si pos está fuera de los límites, entonces la inserción falló*/
return
}
if(L-gt; size == L-gt; maxSize){ /* Reasignar actualización Gran espacio de almacenamiento*/
againMalloc(L);
}
for(i =); L-gt; tamaño - 1; i gt; = pos - 1; i--){
L-gt; lista[i 1] = L-gt; >
}
L -gt;lista[pos - 1] = x;
L-gt;tamaño
;
return 1;
}
/* 12. Inserte el elemento x en la lista lineal ordenada L para que siga ordenado después de la inserción*/
void insertOrderList(struct List *L, elemType x)
{
int i, j;
/* Si el espacio de la matriz se utiliza Luego reasigne un espacio de almacenamiento mayor*/
if(L-gt; size == L-gt; maxSize){
againMalloc(L);
}
/* Encuentra la posición de inserción de x secuencialmente*/
for(i = 0; i lt; L-gt; size; i){
if(x lt; L-gt; lista[i]){
descanso
}
}
/ * Retrocede una posición desde el final de la tabla hasta el elemento del subíndice i, dejando la posición de i vacante */
for(j = L-gt; size - 1; j gt; = i; j--)
L-gt; list[j 1] = L-gt; list[j]
/* Asigna el valor x al elemento con índice i *; /
L-gt; list[i] = x;
/* Aumenta la longitud de la lista lineal en 1 */
L-gt; size ;
return;
}
/* 13. Elimina el elemento de encabezado de la lista lineal L y devuélvelo. Si la eliminación falla, detén el proceso. programa */
elemType deleteFirstList(struct List *L)
{
elemType temp;
int i;
if (L -gt; size == 0){
printf("¡La tabla lineal está vacía y no se puede eliminar! ");
}
temp = L-gt; lista[0];
for(i = 1; i lt; L-gt; tamaño; i )
L-gt;list[i-1] = L-gt;list[i];
L-gt;size--;
regresar temp;
p>
}
/* 14. Eliminar el elemento de cola de la lista lineal L y devolverlo. Si la eliminación falla, detenga el programa */<. /p>
elemType eliminarLastList(struct List *L)
{
if(L -gt; tamaño == 0){
printf( "La lista lineal está vacía y no se puede eliminar. ! ");
salir(1);
}
L-gt; tamaño--;
regresar L -gt; lista[L-gt; tamaño];
/* Devuelve el valor del elemento original al final de la tabla */
}
/* 15. Elimina el elemento pos-ésimo de la tabla lineal L y devuélvelo Si la eliminación falla, detenga el programa Ejecutar */
elemType deletePosList(struct List *L, int pos)
{
elemType temp;
int i;
if(pos lt; 1 || pos gt; L-gt; size){ /* Si pos está fuera de los límites, la eliminación fallará*/
printf("¡El valor pos está fuera de los límites y no se puede eliminar! ");
exit(1); temp = L-gt; lista[pos-1];
for(i = pos; i lt; L-gt; tamaño; i)
L-gt; i-1] = L-gt; lista[i];
L-gt;
temperatura de retorno; >
/* 16. Elimina el valor x de la tabla lineal L El primer elemento, devuelve 1 si tiene éxito, 0 si falla */
int deleteValueList(struct List *L, elemType x)
{
int i , j;
/* Encuentra el primer elemento con valor x secuencialmente de la lista lineal*/
para (i = 0; i lt; L-gt; tamaño ; i ){
if(L-gt; list[i] == x){
break
}
}
/* Si la búsqueda falla indica que no hay ningún elemento con valor x y se devuelve 0 */
if(i == L-gt; size){
return 0;
}
/* Elimina el elemento L-gt con valor x ; lista[i] */
for(j = i 1; j lt; L-gt; tamaño; j ){
L-gt; = L-gt; lista[j];
}
L-gt;
devuelve 1; }
/******** ********************************** ****************** *************/
void main()
{
int a[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}
int
;estructura Lista L;
initList(amp; L, 5);
for(i = 0; i lt; 10; i){
insertLastList(amp; L, a[i]);
}
insertPosList(amp; L, 11, 48); insertPosList(amp; L, 1, 64); /p>
printf("d ", getElem(amp; L, 1));
traverseList(amp; L
printf("d ", findList); (amp; L, 10));
updatePosList(amp; L, 3, 20);
printf("d ", getElem(amp; L, 3));
traverseList(amp; L);
eliminarFirstList(amp; L); eliminarFirstList(amp; L);
eliminarLastList(amp; L); (amp; L);
eliminarPosList(amp; L, 5; eliminarPosList(amp; L, 7); ));
printf("d ", lista vacía(amp; L));
traverseList(amp; L
clearList(amp; L); );
devuelve 0;
}
************************ ***** *************************************
El La siguiente es la implementación en lenguaje C de la pila secuencial
********************************* *************** ****************
#incluye "stdafx.h"
//La longitud inicial es 100
# define StackSize 100
typedef char DataType;
typedef struct stack{
DataType datos [StackSize];
int top;
p>
}SqStack;
//Pila de inicialización
void InitStack( SqStack *S)
{
S- gt; top = -1
}
//Determina si está vacío
int StackEmpty(SqStack *S)
{
return S-gt; arriba == -1
}
//Determina si la pila está llena
int StackFull(SqStack *S)
{
return S-gt; Tamaño de pila-1;
}
//Empujar en la pila
void push(SqStack *S, DataType d)
{
if (StackFull(S))
{
printf("¡La pila está llena!");
exit(-1); gt; datos[ S-gt; arriba] = d
}
//Pop
Tipo de datos pop(SqStack *S)
{
if (StackEmpty(S))
{
printf("¡La pila está vacía!\n");
salir(-1);
}
retorno(S-gt; datos[S-gt; arriba--]); p >
//Mostrar
void disp(SqStack *S)
{
if (StackEmpty(S))
{
printf("¡La pila está vacía!\n");
exit(-1); count = S-gt;top;
printf("Los elementos de la pila son:\n");
while(S-gt;top != -1)
{
printf("c\n", S-gt; datos[S-gt; top--]); p > S-gt; arriba = contar;
}
int main()
{
SqStack *S; p >
S = (SqStack *)malloc(sizeof(SqStack));
printf("Inicializar la pila.\n");
InitStack(S);
empujar(S,'a');
empujar(S,'b');
empujar(S,'c');
push(S, 'd');
disp(S
printf("sacar un elemento\n"); > Tipo de datos aa = pop(S);
disp(S);
Tipo de datos bb = pop(S); p >
Tipo de datos cc = pop(S);
disp(S);
Tipo de datos dd = pop(S); ) ;
Tipo de datos ee = pop(S);
disp(S
}
;