#include lt;stdio.hgt;
#include lt;string.hgt;
#include lt;ctype.hgt;
#include lt;stdlib.hgt;
#define MONTH_NUM 5 /* El mes más*/
estructura trabajador
{
int number; /* El número de trabajo de cada trabajador*/
char name[15] /* El nombre de cada trabajador*/
int salario[MONTH_NUM]; /* Salario M-mes de cada trabajador*/
int suma; /* Salario total de cada trabajador*/
promedio flotante /* Salario promedio de cada trabajador* /
estructura trabajador *siguiente;
};
typedef estructura trabajador STU;
char Menú(void);
int Ascendente(int a, int b);
int Descendente(int a, int b);
void IntSwap(int *pt1, int *pt2
void CharSwap(char *pt1, char *pt2);
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 Modifysalary(STU *head, const int m);
void Sortsalary(STU *head, const int m, int (*compare)(int a, int b));
p>void Searchsalary(STU *head, const int m);
void DeleteMemory(STU *head);
main()
{
char ch;
int m;
>
STU *head = NULL;
printf("Ingrese el mes a registrar (mlt; 10): ");
scanf("d", amp; m );
mientras (1)
{
ch = Menú()
cambiar (ch)
;{
case'1': head = Appendsalary(head, m);
Totalsalary(head, m
break; p >
case'2': Printsalary(head, m);
break;
case'3': head = Deletesalary(head, m); >
printf("\nDespués de eliminado\n");
Printsalary(head, m
break
case'4'; Modificarsalario(cabeza, m);
Salario total(cabeza, m);
printf("\nDespués de modificado\n"); m );
descanso;
caso'5': Searchsalary(head, m
descanso
caso'6); ' ：Ordenarsalario(cabeza, m, Descendente);
printf("\nordenado en orden descendente por suma\n"); >
break;
case'7': Sortsalary(head, m, Ascendente);
printf("\nordenado en orden ascendente por suma\n"); /p> p>
Printsalary(head, m);
break;
case'0': exit(0); head);
printf("¡Fin del programa!");
break;
default: printf("¡Error de entrada!"); >
break;
}
}
}
char Menú(void)
{
char ch;
printf("\nAdministrar el trabajo de los trabajadores
Información\n");
printf(" 1.Agregar registros\n");
printf(" 2.Enumerar registros\n");
printf(" 3. Eliminar registro\n");
printf(" 4. Modificar registro\n");
printf(" 5. Buscar registro\n" )
printf(" 6. Ordenar en orden descendente\n");
printf(" 7. Ordenar en orden ascendente\n"); printf(" 0.Exit\n");
printf("Ingrese su elección:");
scanf(" c", amp; ch /* before); c Agregue un espacio y lea el carácter de retorno de carro almacenado en el búfer en */
return ch;
}
STU *Appendsalary(STU *head, const int m)
{
int i = 0
char c
hacer{
head = AppendNode(head, m); /*Agregar un nodo al final de la lista vinculada*/
printf("¿Quieres agregar un nuevo registro (Y/N)?");
scanf(" c", amp; c /*Hay un espacio antes de c*/
i;
} while (c== 'Y' | c=='y');
printf("¡Se han añadido d nuevos nodos!\n", i);
return head;
}
STU *Deletesalary(STU *head, const int m)
{
int i = 0, nodeNum;
char c;
do{
printf("Ingrese el número de registro que desea eliminar: "); , amp; nodeNum) ;
head = DeleteNode(head, nodeNum); /*Eliminar la información del trabajador con el número de trabajador nodeNum*/
Printsalary(head, m); *Mostrar los trabajadores en la lista vinculada actual Información sobre cada nodo*/
printf("¿Quieres eliminar un nodo(S/N)?");
scanf( " c", amp; c); / *Hay un espacio antes de c*/
i;
} while (c=='Y' || c==' y');
printf("¡Se han eliminado d nodos!\n", i
return head
}
<); p>void Modificarsalario(STU *head, const int m){
int i = 0, nodeNum
char
hacer{
>
printf("Ingrese el número de registro que desea modificar: ");
scanf("d", amp; nodeNum
head = ModifyNode(head); , nodeNum, m); /*Modificar el nodo con el número de trabajador nodeNum*/
printf("¿Quieres modificar un nodo(Y/N)?");
scanf ("c",amp;c); /*Hay un espacio antes de c*/
i;
} while (c=='Y' || c ==' y');
printf("¡los nodos d han sido modificados!\n", i);
}
void Totalsalary(STU * cabeza, const int m)
{
STU *p = cabeza
int i
mientras (p != NULL; ) /* Si no es el final de la tabla, entonces bucle */
{
p-gt; sum =
for (i; =0; ilt; m; i )
{
p-gt; suma = p-gt; >
p-gt; promedio = (float)p-gt; sum / m;
p = p-gt; /*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, i;
hacer{
bandera = 0; >
pt = head;
/*Si el salario total del último nodo es mayor que el salario total del nodo anterior, intercambie los datos en los dos nodos
Tenga en cuenta que solo se intercambian los datos del nodo y 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 ((*comparar) (pt-gt; next-gt; suma, pt-gt; suma))
{
IntSwap(amp; pt-gt; número, amp; pt-gt; siguiente -gt; número
CharSwap(pt-gt; nombre, pt-gt; next-gt; nombre);
for (i=0; ilt; m; i )
{
IntSwap(amp;pt-gt;salario[i], amp;pt-gt;next-gt;salario[i]);
<p> }
IntSwap(amp; pt-gt; suma, amp; pt-gt; next-gt; suma
FloatSwap(amp; pt-gt; promedio, amp;pt-gt;next-gt;average);
bandera = 1;
}
pt = pt-gt;next;
}
} while(bandera);
}
/*Intercambiar dos enteros*/
void IntSwap( int *pt1, int *pt2)
{
int temp
temp = *pt1
*pt1 = *pt2; ;
*pt2 = temp;
}
/*Intercambiar dos números reales*/
void FloatSwap (float *pt1, flotante *pt2)
{
temperatura flotante
temp = *pt1
*pt1 = * pt2;
*pt2 = temp;
}
/*Intercambiar dos cadenas*/
void CharSwap(char * pt1, char *pt2)
{
char temp[15];
strcpy(temp, pt1);
strcpy( pt1, pt2);
strcpy(pt2, temp);
}
/* Determine si los datos están ordenados en orden ascendente, alt; si b es verdadero, entonces Ordene en orden ascendente; orden*/
int Ascendente(int a, int b)
{
return a lt;
}
p>
/* Determine si los datos se ordenan en orden descendente, agt; si b es verdadero, entonces se ordenan en orden descendente*/
int Descending(int a, int b)
{
return a gt; b;
}
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);
findNode = SearchNode(head, number);
if (findNode == NULL)
{
printf("¡No encontrado!\n");
}
else
{
printf ("\nNo.3d8s", findNode-gt; número, findNode-gt; nombre
for (i=0; ilt;
m; i )
{
printf("7d", findNode-gt; salario[i]); printf("9d9.2f\n", findNode-gt; suma, findNode-gt; promedio
}
}
void Printsalary(STU); *cabeza, const int m)
{
STU *p = cabeza;
char str[100] = {'\0'}, temp[ 3];
int i, j = 1;
strcat(str, "Nombre del número "); m; i )
{
strcat(str, "salario");
itoa(i, temp, 10); > strcat(str, temp);
strcat(str, " ");
}
strcat(str, " suma promedio" p>
printf("s", str); /*Imprime el encabezado de la tabla*/
while (p != NULL) /*Si no es el final de la tabla, imprimir en un bucle*/
{
printf("\nNo.3d15s", p-gt; número, p-gt; nombre
); for (i=0; ilt; m ; i )
{
printf("7d", p-gt; salario[i]); }
printf ("9d9.2f", p-gt; suma, p-gt; promedio);
p = p-gt /*Deje que p apunte a el siguiente nodo*/
j;
}
printf("\n"); p>STU *AppendNode(STU *cabeza, const int m)
{
STU *p = NULL
STU *pr = cabeza
int j;
p>
p = (STU *)malloc(sizeof(STU)); /*Aplicar memoria para el nodo recién agregado*/
if (p == NULL) /*Si la aplicación de memoria falla, imprima un mensaje de error y salga del programa*/
{
printf("No hay suficiente memoria para asignar ");
exit(0);
p>
}
if (head == NULL) /*Si la lista enlazada original es vacío, establezca el nuevo nodo como el primer nodo*/
{
head = p;
}
else /*Si la lista enlazada original no está vacía, agregue el nuevo nodo al final de la lista*/
{
/*Si no ha alcanzado el final de la lista, continúe moviendo el puntero pr , hasta que pr apunte al final de la tabla*/
while (pr-gt; next != NULL)
{
pr = pr-gt; next;
}
pr-gt; next = p; */
}
pr = p; /*Deje que pr apunte al nuevo nodo*/
printf("Ingrese datos del nodo...") ;
printf("\nNúmero de entrada:") ;
scanf("d", amp;p-gt;número);
printf(" Nombre de entrada: ");
scanf("s ", p-gt; nombre);
for (j=0; jlt; m; j)
{
printf("Entrada salariod:", j 1
scanf("d", p-gt; salario j
); }
pr-gt; next = NULL; / *Establece el nuevo nodo al final de la lista*/
return head /*Devuelve el puntero del nodo principal del vinculado. lista después de agregar el nodo*/
}
STU *ModifyNode(STU *head, int nodeNum, const int m)
{
int j;
STU *newNode;
newNode = SearchNode(head, nodeNum);
if (newNode == NULL)
{
printf("¡No encontrado!\n");
}
else
{
printf("Ingrese los datos del nuevo nodo:\n");
printf("Ingrese el nombre:
scanf("s", newNode-gt; nombre);
for (j=0; jlt; m; j)
{
printf("Entrada salariod: ", j 1); /p>
scanf("d", newNode-gt; salario j
}
}
return head;
}
STU *DeleteNode(STU *head, int nodeNum)
{
STU *p = head, *pr = head;
if (head == NULL) /*La lista enlazada es
Vacío, sin nodo, el nodo no se puede eliminar*/
{
printf("¡No hay tabla vinculada!\n");
return(head);
}
/*Si no se encuentra el nodo nodeNum y no se llega al final de la tabla, continúe buscando*/
while (nodeNum != p-gt; número amp ;amp; p-gt; siguiente != NULL)
{
pr = p
p = p-gt; next;
}
if (nodeNum == p-gt; number) /*Si se encuentra el nodo nodeNum, elimine el nodo*/
{
if (p == head) /*Si el nodo a eliminar es el primer nodo, deje que head apunte al segundo nodo*/
{
head = p-gt; next;
}
else /*Si el nodo que se va a eliminar no es el primer nodo, apunte el puntero del nodo anterior al siguiente nodo del actual. nodo*/
{
pr-gt; siguiente = p-gt;
}
libre(p); /*Liberar la memoria asignada para el nodo eliminado*/
}
else /*No se encontró el nodo a eliminar*/
{
printf("¡Este nodo no ha sido encontrado!\ n");
}
return head /*Devuelve el puntero del nodo principal de la lista enlazada después. eliminando el nodo*/
}
STU *SearchNode(STU *head, int nodeNum)
{
STU *p = head;
int j = 1;
while (p != NULL) /*Si no es el final de la tabla, bucle*/
{
if (p-gt; number == nodeNum) return p;
p = p-gt; /*Deje que p apunte al siguiente nodo*/
j;
}
return NULL ;
}
void DeleteMemory(STU *head)
{
STU *p = head, *pr = NULL;
while (p != NULL) /*Si no es el final de la tabla, suelte la memoria ocupada por el nodo*/
{
pr = p /*In Guarda el puntero del nodo actual en pr*/
p =; p-gt; next; /*Deje que p apunte al siguiente nodo*/
free(pr);
/*Libera la memoria ocupada por el nodo actual señalado por pr*/
}
}
Simplemente conformate con ello, solo agrega algunas funciones faltantes tú mismo. . .