Código fuente de envío mensual
# 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
{
int número /* Trabajo; número de cada trabajador*/
char name[15];/*Nombre de cada trabajador*/
int salario[MONTH_NUM];/*Cada trabajador Salario mensual*/
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 (vacío);
int Ascending( 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));
void Searchsalary (STU *head, const int m);
memoria de eliminación nula (STU *head);
main()
{
char ch
int m;
STU * head = NULL
Printf("Ingrese el mes a registrar (m
scanf ("%d ", & ampm);
mientras (1)
{
ch = Menú();
Cambiar (canal)
{
case ' 1 ':head = append salario(head, m);
Salario total (head, m
p>Descanso;
caso'2':Imprimirsalario
(cabeza, m);
Descanso;
case'3':cabeza = Eliminarsalario(cabeza, m
printf("\ndespués de la eliminación \); n ");
Printsalary(head, m);
Pausa;
Caso "4": modificar salario(head, m);
p>Salario total (cápita, m);
printf (" \ nDespués de la modificación\ n ");
Printsalary (cápita, m
);Pausa;
Caso '5':Buscarsalario(cabeza, m);
Pausa;
caso '6':Ordenarsalario(cabeza, m , orden descendente);
printf("\nEn orden descendente de la suma\n");
Printsalary(head, m);
Break;
p>
case'7':Sortsalary(head, m, orden ascendente);
printf(" \ nOrdenar por suma en orden ascendente\ n "); p>
Printsalary(head, m);
Break;
Caso "0": salir (0);
printf("¡El programa finaliza!");
Interrupción;
Valor predeterminado: printf("¡Error de entrada!");
Pausa;
}
}
}
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. Orden ascendente\ n " );
Printf(" 0.
Salir\n ");
Printf("Ingrese su elección:");
scanf(" %c ", & ampch); /* Agregar antes de %c Un espacio para leer el retorno de carro en el buffer */
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 ", &c); /*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;
Haga {
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); la lista enlazada actual*/
printf("¿Desea eliminar el nodo (Y/N)?");
scanf(" %c ", & ampc / *Hay un espacio antes de %c*/
i++;
} while(c == ' Y ' | | c == ' Y '); p>printf("¡%d nodos han sido eliminados!\n", I);
Devolver encabezado;
}
void Modifysalary(STU *head , const int m)
{
int i = 0, nodeNum
char c;
Hacer {
Printf("Ingrese el valor que desea Modificar el número de registro: ");
scanf("%d ", & ampnodeNum);
head = ModifyNode(head, nodeNum , m); /*Modificar el número de nodo a El nodo*/
printf("¿Quieres modificar el nodo (Y/N)? ");
scanf(" %c ", & ampc); /*Hay un espacio antes de %c*/
i++;
} mientras ( c == ' Y ' | | c == ' Y ');
printf("¡%d nodos han sido modificados!\n", I);
}
Salario total no válido (STU *head, const int m)
{
STU * p = head
int I;
p>
And (p!= NULL) /*Si no es un pie de página, bucle*/
{
p->;sum = 0;
for(I = 0;i<m;i++)
{
p->suma+= p->salario[I];
}
p->; promedio = (flotante)p->su
m/m;
p = p-& gt;Siguiente;/*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;
/* Si el salario 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 y el orden de los nodos permanece sin cambios, es decir, el contenido del siguiente puntero del nodo no se intercambia*/
while(pt-& gt ; siguiente!=null)
{
if((*comparación)(pt->siguiente->suma,pt->suma))
{
int swap(&pt->cantidad&pt->siguiente->número);
char swap(pt-> nombre, pt-> next->nombre);
for(I = 0;i<m;i++)
{
int swap(&pt->salario[ i], &pt->siguiente->salario[I]);
}
int swap(&pt->suma &pt->siguiente-> suma);
FloatSwap(&pt->average&pt-> next->average);
flag = 1;
}
pt = pt->siguiente;
}
} mientras(bandera);
}
/ *Intercambiar dos números enteros*/
void IntSwap(int *pt1, int *pt2)
{
Temperatura interna;
temp = * pt 1;
* pt 1 = * pt2;
* pt2 = temp
}
/*Intercambiar dos reales números*/
void FloatSwap(float *pt1, float *pt2)
{
Temperatura de flotación;
temp = * pt 1;
* pt 1 = * pt2;
* pt2 = temp
}
/*Intercambiar dos cadenas*/
void CharSwap(char *pt1, char * pt2)
{
Temperatura de carga[15];
strcpy(temp, pt 1);
strcpy(pt1, pt2 );
strcpy(pt2, temp);
}
/*Determinar si los datos se ordenan en orden ascendente
int Ascending(int a, int b)
{
Devuelve a <b;
}
/* Determine si los datos están ordenados en orden descendente, a & gtSi b es verdadero, ordene en orden descendente*/
int Descending(int a, int b)
{
devuelve 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 ", & amp número);
findNode = SearchNode(cabeza, número);
if (findNode == NULL)
{
printf("¡No encontrado! \ n ");
}
Otros
{
imprimir
f("\nNo.%3d%8s",findNode->número,buscar nodo->nombre);
for(I = 0;i<m;i++)
p>{
printf("%7d ",findNode-& gt; salario[I]);
}
printf("% 9d%9.2 f\n ",findNode->suma,findNode->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<= m;i++)
{
strcat(str, "salario");
itoa(i, temp, 10);
strcat(str, temp) ;
strcat(str, " ");
}
strcat(str, "promedio sumado");
printf( "%s ", str); /*Imprimir encabezado*/
Y (p!= NULL) /*Si no es un pie de página, imprimir en un bucle*/
{
printf(" \ nNo. %3d%15s ", p-& gt; número, p-& gt; nombre
for (I = 0;i<m; i++)
{
printf("%7d ",p->salario[I]);
}
printf ("%9d%9.2f ", p-& gt; suma, p->average
p = p-& gt; *Deje que p apunte al siguiente nodo*/
j++;
}
printf(" \ n ");
}
STU *AppendNode( STU *cabeza, const int m)
{
STU * p = NULL
STU * pr = cabeza
int j;
p = (STU *)malloc(tamaño de(STU)).
/*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; Next;
}
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("\nNúmero de entrada: ");
scanf("%d ",&p->; número);
printf("Ingrese 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/*Establecer el nodo recién creado como pie de página*/
Devolver encabezado /*Devuelve el puntero del nodo principal de la lista vinculada después; agregando el nodo*/
}
STU *ModifyNode(STU *head, int nodeNum, const int m)
{
int j;
STU * nuevoNodo
nuevoNodo = SearchNode(head, nodeNum);
if (nuevoNodo == NULL)
{
printf( "¡No encontrado! \ n "
}
Otros
{
); printf("Ingrese los datos del nuevo nodo:\ n ");
printf("Ingrese el nombre:");
scanf("%s ", nuevo nodo-& gt; nombre );
for (j = 0; j & ltm; j++)
{
printf("Ingrese el salario %d:", j+1) ;
scanf( "%d ", nuevo nodo-& gt; salario + j
}
}
Retorno); 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.
&p->¡Siguiente! = vacío)
{
pr = p;
p = p-& gt;Siguiente;
}
if(nodeNum == p->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;
Else /*Si el punto a podar no es el primer nodo, apunte el puntero del nodo anterior al siguiente nodo del nodo actual*/
{
pr-& gt; next = p-& gt; next;
}
Gratis /* Liberar asignación de memoria de nodos eliminados*/
}
Else /*No se encontró el nodo a eliminar*/
{
printf("Este nodo no se encontró ! \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;
Y (p!= NULL) /*Bucle si no es pie de página*/
{
Si (p->número == nodeNum) devuelve p ;
p = p-& gt;Next;/*Deje que p apunte al siguiente nodo*/
j++;
}
Devuelve NULL
}
void DeleteMemory(STU *head)
{
STU *p = head, * pr = NULL
Y (p! = NULL) /*Si no es un 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 */
Free (pr; ); / *Libera la memoria ocupada por el nodo actual señalado por pr*/
}
}
Simplemente conformate con ello y agrega algo que falta. funciona usted mismo. . .