Sistema de código fuente completo
# incluir ltstring.h gt
# incluir ltctype.h gt
# incluir ltstdlib.h gt
#define MES_NUM 5 /*La mayoría de los meses*/
Trabajador de estructura
{
número int; /*Número de trabajo de cada trabajador*/
char name[15];/*El nombre de cada trabajador*/
int salario[MONTH_NUM];/*El salario mensual de cada trabajador*/
int sum/*Salario total de cada trabajador*/
Promedio flotante /*Salario promedio de cada trabajador*/
estructura trabajador * siguiente
};
STU de trabajador de estructura typedef
menú char (void);
int Ascending(int a, int b);
int Descending( int a, int b);
void IntSwap(int *pt1, int * pt2
void CharSwap(char *pt1, char * pt2);
<); p>void FloatSwap(float *pt1, float *pt2);STU *AppendNode(STU *head, const int m);
STU *DeleteNode(STU *head, int nodeNum);
STU *ModifyNode(STU *head, int nodeNum, const int m);
STU *SearchNode(STU *head, int nodeNum);
STU *Appendsalary(STU *head, const int m);
void Totalsalary(STU *head, const int m);
void Printsalary(STU *head, const int m);
STU *Deletesalary(STU *head, const int m);
void Modificarsalario(STU *head, const int m) ;
void Sortsalary(STU *head, const int m, int (*compare)(int a, int b));
void Searchsalary(STU *head, const int m );
anular eliminar memoria (STU * head);
main()
{
char ch
int m;
STU * head = NULL
Printf("Ingrese el mes a registrar (m
scanf("d ", ampm);
while (1)
{
ch = Menú();
Cambiar (canal)
{
cas
e ' 1 ': cabeza = agregar salario(cabeza, m);
Salario total (cabeza, m
Descanso
caso'2'); :Printsalary(cabeza, m);
Break;
case '3': head = Deletesalary(cabeza, m);
printf(" \ n); Después de la eliminación\n ");
Printsalary(head, m);
Pausa;
Caso "4": modificar salario(head, m);
Salario total (cápita, m);
printf (" \ nDespués de la modificación\ n ");
Printsalary (cápita, m
Printsalary (capita, m);
p>
Pausa;
Caso '5': Searchsalary(head, m); >Break;
caso '6': Sortsalary(head , m, orden descendente
printf("\nEn orden descendente de suma\n");
Printsalary(head, m);
Break;
case'7': Sortsalary(head, m, orden ascendente);
printf( "\nOrdenar en orden ascendente por suma\n");
Printsalary (head, m
Break
Caso "0": salir ( 0);
eliminar memoria(head);
printf("¡El programa finaliza!");
Interrupción;
Valor predeterminado : printf("¡Error de entrada!");
Pausa;
p>
}
}
}
Menú de caracteres (no válido)
{
char ch
printf("\nAdministrar salarios de los trabajadores\n");
Printf("1. Agregar registro\n");
Printf( " 2. Listar registros\ n ");
Printf(" 3. Eliminar registros\ n ");
Printf(" 4. Modificar registros\ n ");
Printf(" 5. Buscar registros\ n ");
Printf (" 6. Orden descendente\ n ");
Printf(" 7. Ascendente\ n ");
Printf(" 0.
Salir\n ");
Printf("Ingrese su elección: ");
scanf(" c ", ampch); /* Agregue un espacio antes de c para leer el retorno de carro en el buffer */
Return ch;
}
STU *Appendsalary(STU *head, const int m)
{
int I = 0;
char c;
hacer {
cabeza = AppendNode(cabeza, m ); *Agregar un nodo al final de la lista vinculada*/
Printf("¿Quieres agregar un nuevo registro (Y/N)?");
scanf(" c ", ampc);/*Hay un espacio antes de c*/
i;
} while(c = = ' Y ' | | c = = ' Y ') ;
printf("¡Se han abierto d nuevos nodos!\n", I);
Devolver encabezado;
}
STU *Deletesalary( STU *head, constante m)
{
int i = 0, nodeNum
char c;
do {
Printf("Ingrese el número de registro que desea eliminar: ");
scanf("d ", ampnodeNum
head = DeleteNode); (head, nodeNum) ;/*Eliminar la información del trabajador con el número de trabajador nodeNum*/
Printsalary(head, m);/*Mostrar la información de cada nodo en la lista vinculada actual*/
printf(" ¿Desea eliminar el nodo (S/N)? ");
scanf(" c ", ampc /*Hay un espacio antes de c*/
i;
} while(c == ' Y ' | | c == ' Y ');
printf("¡Los nodos d han sido eliminados! \n", I);
Devolver encabezado;
}
void Modifysalary(STU *head, const int m)
{
int i = 0, nodeNum
char c;
Do {
Printf("Ingrese el número de registro que desea para modificar: ");
scanf("d ", ampnodeNum);
head = ModifyNode(head, nodeNum, m); /*Modificar el nodo con número de nodo*/
printf("¿Quiere modificar el nodo (S/N)? ");
scanf(" c ", ampc); /*Hay un espacio antes de c*/
i;
} while(c = = ' Y ' | c = = ' Y ');
printf("¡Los nodos d han sido modificados!\n", I);
}
Salario total no válido (STU *head, const int m)
{
STU * p = head
int I;
And (p!= NULL) /*Bucle si no es pie de página*/
{
p->;sum = 0;
for (I = 0;iltm;i
)
{
p->;suma = p- gt;salario[I];
}
p->; promedio = (float)p->sum/m;
p = p- gt next; /*deje que p apunte al siguiente nodo*/
}
}
void Sortsalary(STU *head, const int m, int (*compare)(int a, int b))
{
stu *pt
int bandera = 0, yo;
hacer {
bandera = 0;
pt = encabezado;
p>
/*Si el salario total del último nodo es mayor que el del nodo anterior, se intercambiarán los datos de los dos nodos.
Tenga en cuenta que solo se intercambian datos de los nodos, el orden de los nodos permanece sin cambios, es decir, el contenido del siguiente puntero del nodo no se intercambia*/
while(pt- gt; next !=null)
{
if((*comparación)(pt- gt; next- gt; suma, pt- gt; suma))
{
int swap(amp;pt-gt;cantidadamppt-gt;next-gt;número);
char swap(pt-gt;nombre,pt-gt;next- gt ;nombre);
for(I = 0;iltm;i)
{
int swap(amp;pt- gt;salario[i] , amppt- gt; siguiente- gt; salario [I]);
}
int swap( amp; pt- gt; suma amppt- gt; siguiente- gt; suma) ;
FloatSwap(amp;pt-gt;averageamppt-gt;next-gt;average);
bandera = 1;
}
pt = pt- gt; siguiente;
}
} mientras(bandera
}
/*Intercambiar); dos enteros*/
void IntSwap(int *pt1, int *pt2)
{
Temperatura interna;
temp = * pt 1;
* pt 1 = * pt2;
* pt2 = temp
}
/ *Intercambiar dos números reales* /
void FloatSwap(float *pt1, float *pt2)
{
Temperatura de flotación;
temp = * pt 1;
* pt 1 = * pt2;
* pt2 = temp
}
/*Intercambia las dos cadenas */
void CharSwap(char *pt1, char *pt2)
{
Temperatura de carga[15];
strcpy(temp, pt 1 );
strcpy(pt1, pt2);
strcpy(pt2, temp);
}
/* Determinar si el los datos se ordenan en orden ascendente
int Ascending(int a, int b)
{
Devuelve a ltb;
}
/*Determine si los datos están ordenados en orden descendente, a gtSi b es verdadero, entonces ordene en orden descendente*/
int Descending(int a, int b)
{
devolver un gtb;
}
void Searchsalary(STU *head, const int m)
{
int número, I;
STU * findNode
Printf("Ingrese el número de registro que desea encontrar: ");
scanf("d ", número de amplificador);
findNode = SearchNode(head, number);
if (findNode == NULL)
<p>{
printf("¡No encontrado! \ n ");
}
Otros
{
printf("\nno.3d8s",findNode-gt; número, buscar nodo-gt;nombre);
for(I = 0;iltm;i)
{
printf("7d ", findNode- gt; salario [I]);
}
printf("9d9.2f\n ", findNode-); gt; suma, findNode- gt; promedio
}
}
void Printsalary(STU *head, const int m)
{
STU * p = cabeza
char str[100] = {'\0'}, temp[3];
int i, j = 1;
strcat(str, "nombre del número");
for(I = 1; i lt= m; i)
{
strcat(str, "salario");
itoa(i, temp, 10);
strcat(str, temp
<); p>strcat(str, " ");}
strcat(str, "suma promedio");
printf("s ", str) ; /*Imprimir encabezado*/
And (p!= NULL) /*Si no es un pie de página, imprimir en un bucle*/
{
printf("\nno.3d15s",p-gt;número,p-gt;nombre);
for(I = 0;iltm;i)
{
printf("7d ", p- gt; salario [I]);
}
printf("9d9.2f ", p- gt ;suma, p->average);
p = p- gt next; /*deje que p apunte al siguiente nodo*/
j;
}
printf(" \ n ");
}
STU *AppendNode(STU *head, const int m)
{
STU * p = NULL
STU * pr = head
int j;
p = (STU *)malloc (tamañode( UTE)).
/*Aplicar memoria para el nuevo nodo*/
If (p == NULL) /*Si la aplicación de memoria falla, imprime un mensaje de error y sale del programa*/
{
printf("No hay suficiente memoria para asignar");
Salir(0);
}
If (head = = NULL) /*Si la lista enlazada original está vacía, establezca el nuevo nodo como nodo principal*/
{
head = p;
}
De lo contrario /*Si la lista enlazada original no está vacía, agregue el nuevo nodo al pie de página*/
{
/*Si no se llega al pie de página , continúe moviendo el puntero pr, hasta que pr apunte al pie de página*/
while(pr->; next!=null)
{
pr = pr- gt; continuar hacia abajo;
}
pr- gt; next = p /*Agregar nuevo nodo al final de la lista enlazada*/
}
pr = p; /*Deje que pr apunte al nuevo nodo*/
printf("Ingrese los datos del nodo...");
printf("\nIngrese el número:") ;
scanf("d ", ampp->; número);
printf("Ingrese el nombre:
scanf("s ", p- gt; nombre);
for(j = 0; j ltm; j)
{
printf("Ingrese salario d:",j 1);
scanf("d ", p- gt; salario j
}
pr); - gt; next = NULL/* será nuevo El nodo creado se establece como pie de página*/
Devolver encabezado; /*Devuelve el puntero del nodo principal de la lista vinculada después de agregar el nodo*/
}
STU *ModifyNode (STU *head, int nodeNum, const int m)
{
int j;
STU * nuevoNodo
nuevoNodo = SearchNode (cabeza, nodoNum);
if (nuevoNodo == NULL)
{
printf("¡No encontrado!\n ");
}
Otros
{
printf("Ingrese los datos del nuevo nodo : \ n ");
printf(" Ingrese nombre: ");
scanf("s ", nuevo nodo- gt; nombre);
for(j = 0; j ltm; j )
{
printf("Ingrese el salario d: ", j
scanf("d); ", nuevo nodo- gt; salario j);
}
}
Devolver encabezado;
}
STU *DeleteNode(STU *head, int nodeNum)
{
STU *p = head, *pr = head;
If (head = = NULL) /*La lista enlazada está vacía y no tiene nodos.
No se puede eliminar el nodo*/
{
printf("¡No hay tabla de enlaces!\n ");
Return (head);
}
/*Si no se encuentra el nodo nodeNum y no se llega al final de la tabla, continuar buscando*/
mientras (nodeNum!= p->; cantidad y cantidad. ampp ->; siguiente! = vacío)
{
pr = p;
p = p- gt; p >}
if(nodeNum == p- gt;Number) /*Si se encuentra el nodo nodeNum, elimínelo*/
{
If ( p == head) /*Si el punto a truncar es el primer nodo, deje que head apunte al segundo nodo*/
{
head = p- gt;
}
De lo contrario /*Si el punto a podar no es el primer nodo, apunte el puntero del nodo anterior al nodo al lado del nodo actual*/
{
pr- gt; next = p- gt;
}
Libre (p); Memoria asignada*/
}
Else /*No se encontró el nodo a eliminar*/
{
printf(" ¡Este nodo no encontrado! \n ");
}
Devolver encabezado; /*Devuelve el puntero del nodo principal de la lista vinculada después de eliminar el nodo*/
}
STU *SearchNode(STU *head, int nodeNum)
{
STU * p = head
int j = 1;
p>Y (p!= NULL) /*Bucle si no es pie de página*/
{
Si (p->número == nodeNum) return p;
p = p- gt; next /*deje que p apunte al siguiente nodo*/
j;
}
Devolver NULL
}
void DeleteMemory(STU *head)
{
STU *p = head, * pr = NULL
Y (p! = NULL) /*Si no es pie de página, libera la memoria ocupada por el nodo*/
{
pr = p /* Guarda el puntero del nodo actual en pr */
p = p- gt /* Deja que p apunte al siguiente nodo */
}
}
Simplemente confórmate con él. y agregue usted mismo algunas funciones faltantes. . .