Versión en lenguaje C de diseño de curso de estructura de datos. Ahora estoy pidiendo una respuesta para el diseño de un curso. ¿Hay algún inmortal que pueda ayudarme? Solo puedo dar 100 puntos.

/*12.3.2 Programa fuente*/

/******Archivo de encabezado (.h)************** ****/

#include "stdio.h" /*Función de E/S*/

# include "bios.h" /*Función básica de entrada y salida de ROM* /

#include "dos.h" /*Función de interfaz dos*/

#include "conio.h" /*Función de operación de pantalla*/

#include "stdlib.h" / *Otras instrucciones*/

#include "string.h" /*Función de cadena*/

#include "mem.h" /*Memoria función de operación*/

#include "ctype.h" /*Función de operación de caracteres*/

#include "alloc.h" /*Función de asignación dinámica de direcciones*/

/** **Definición de variable*******/

typedef struct z1 /*Definir estructura de datos*/

{

char no[11]; /*Número*/

char nombre[15]; /*Nombre*/

float jbgz; /*Salario básico*/

float koukuan; / *deducción*/

float yfgz /*salarios adeudados*/

float shuijin /*impuestos*/

float; sfgz; /*Pagar salarios reales*/

struct z1 *prior;/*puntero precursor*/

struct z1 *next;/*puntero sucesor*/

}SALARIO; /*Nombre del tipo de estructura*/

struct z1 *Primero; /*Puntero de encabezado de lista doblemente enlazado*/

struct z1 *Último; puntero de cola*/

/******Prototipo de función************/

void init() /*Inicialización*/

void create (); /*Crear lista enlazada*/

void calc(); /*Calcular salarios adeudados*/

void delete(); /*Eliminar*/

void search(); /*Buscar*/

void save() /*Guardar archivo*/

void load( ); /*Leer archivo*/

void computer(); /*Calcular el número requerido de varios cupones*/

void insert() /*Insertar*/

void append (); /*Append*/

void copy() /*Copiar archivos*/

void sort() /*Ordenar*/

void index(); /*index*/

void total(); /*categoría total*/

void list(); todos los datos*/

void print(SALARIO *p); /*Generar un solo registro*/

void display() /*Mostrar uno por uno a voluntad*/<; /p>

fax flotante(flotante x );

Tax*/

int menu_select(); /*Menú principal*/

/**********Se inicia la función principal******* ****/

main()

{

int i;

clrscr();

for(;; )

{

switch(menu_select()) /*Llame a la función de menú para devolver un valor entero*/

{

case 0 :init();break; /*Inicialización*/

case 1:create();break; /*Ingresar datos para crear una lista doblemente enlazada*/

case 2:list() ;break; /*Mostrar todos los datos*/

case 3:display();break /*Pantalla única*/

case; 4:calc();break; /* Calcular salarios reales*/

case 5:search();break /*Buscar datos de información de empleados*/

case 6:delete; ();break; /*Eliminar registros */

case 7:insert();break; /*Insertar registro*/

case 8:append();break; *Agregar registro*/

case 9:save();break; /*Guardar el archivo*/

case 10:load() /*Leer el archivo* /

case 11 :copy();break; /*Copiar archivos*/

case 12:sort();break /*Ordenar en orden ascendente de salarios reales*/

case 13:computer ();break; /*Calcular el número requerido de cupones*/

case 14:index();break /*Indexar por número de empleado*/

caso 15:total( );break; /*Total por departamento*/

caso 16:exit(0); /*Salir*/

}

}

}

/*Función de menú, el valor de retorno de la función es un número entero que representa el elemento de menú seleccionado*/

menu_select()

{

char *f[]= { /*Definir matriz de cadenas de menú*/

"******** ******MENÚ*** **********", /*La línea de título del menú*/

" 0. init list", /*Inicializar el lista de doble enlace*/

" 1 . Ingresar lista", /*Ingresar datos y crear una lista de doble enlace*/

" 2. Listar todo \n", /*Mostrar todos los registros*/

" 3. Mostrar registro por paso", /*Mostrar un solo registro*/

" 4. Calcular el salario", /*Calcular el salario real* /

" 5. Buscar registro por nombre", /*Buscar registro*/

" 6. Eliminar un registro", /*Eliminar registro*/

" 7. Insertar registro en la lista", /*Insertar registro*/

" 8. Agregar registro a f

ile", /*Agregar registros*/

" 9. Guardar datos en el archivo", /*Guardar el archivo*/

" 10. Cargar datos desde el archivo", / *Leer el archivo*/

" 11. Copiar el archivo a un archivo nuevo", /*Copiar el archivo*/

" 12. Ordenar en sfgz", /*Ordenar */

" 13. Número de ticket de computadora", /*Calcular el número requerido de tickets*/

" 14. Índice del número", /*Índice*/

" 15. Total en número", /*Categoría total*/

" 16. Salir" } /*Salir*/

char s[80];

int i;

int key=0; /*Registra el valor de la tecla presionada*/

int c=0;

gotoxy(1 ,25); /*Mover el cursor*/

printf("presione cualquier tecla para ingresar al menú...\n");/*Presione cualquier tecla para ingresar al menú principal*/

getch();

clrscr(); /*Borrar pantalla*/

textcolor(YELLOW); /*Establecer color de texto en amarillo*/

textbackground(BLUE); /*Establece el color de fondo en azul*/

gotoxy(10,2);

putch(0xda); borde de la esquina superior izquierda┏ */

for(i=1;i<44;i++)

putch(0xc4); /*Emite la línea horizontal del borde superior*/

putch( 0xbf); /*Imprime el borde de la esquina superior derecha┓*/

for(i=3;i<22;i++)/*Imprime las líneas verticales a la izquierda y lados derechos*/

{

gotoxy(10,i);patch(0xb3);

gotoxy(54,i);patch(0xb3);

}

gotoxy(10,22);patch(0xc0); /*Generar el borde de la esquina superior izquierda┗*/

for(i=1 ;i<44;i++)

putch (0xc4); /*Imprime la línea horizontal del borde inferior*/

putch(0xd9); */

window(11,3,53,21) ; /* Crea una ventana para mostrar el menú, el tamaño se diseña de acuerdo con la cantidad de elementos del menú*/

clrscr(); /*Borrar la pantalla*/

for(i=0;i<18 ;i++)

{

gotoxy(10,i +1);

cprintf("%s",f[i]); /*matriz de elementos del menú de salida*/

}

i=1 ;

gotoxy(10,2); /*Establece la opción predeterminada en el primer elemento*/

textbackground(LIGHTGREEN);/*Establece el color de fondo en verde claro*/

cprintf("%s",f[1]); /*Elemento del menú de salida, indicando seleccionado* /<

/p>

gotoxy(10,2); /*Mover el cursor al primer elemento del menú*/

while(key!=13) /*Cuando la tecla presionada no es la Ingresar clave* /

{

while(bioskey(1)==0 /*Consultar si se presiona una tecla*/

key=bioskey; (0 ); /*Regresar a la siguiente tecla presionada en el teclado*/

key=key&0xff?key&0xff:key>>8 /*Juzgar la tecla presionada*/

gotoxy(10,i+1);

textbackground(BLUE);/*Establece el color de fondo en azul*/

cprintf("%s",f[i] ) ; /*Elemento del menú de salida*/

if(key==72) i=i==1?17:i-1 /*Si se presiona la tecla de cursor hacia arriba ↑, disminuiré en 1, como por ejemplo, si llegó a la primera línea y luego subió, irá a la última línea*/

if(key==80)i=i==17?1:i+ 1; /*Si presiona la tecla de cursor hacia abajo ↓, aumenta i en 1, si ha llegado a la última línea y luego baja, vaya a la primera línea*/

gotoxy(10,i+ 1); /*Mover el cursor al siguiente elemento de i*/

textbackground(LIGHTGREEN) /*Establecer el color de fondo en verde claro*/

cprintf("%); s",f[i]); /*Salida de elementos del menú*/

c=i-1; /*Asigne un valor al número entero que representa la opción del menú*/

}

textbackground(BLACK); /*Establecer el color de fondo en negro */

window(1,1,80,25) /*Restaurar el tamaño de la ventana original*/

return c; /*Devuelve el valor entero que representa la opción del menú*/

}

/*Función de inicialización*/

void init()

{

Primero=NULL

Último=NULL;

}

/ *Ingrese datos y cree una lista doblemente enlazada*/

void create()

{

int /*Registrar coordenadas de fila*/

int i; /*Registrar el número de registros de entrada*/

int flag= 0; /*Hacer una marca de final*/

float temp /*Definir variables temporales*/

SALARIO *info,*p /*Definir variables temporales*/

if(First!=NULL)

init(); /*Si el puntero principal es nulo, llame a la función de inicialización*/

p=First /*Puntero principal Inicio*/

for(;;)

if(flag==1)

break; /*if flag =1, finalizar entrada*/

i=0;

x=0; /*Determinar las coordenadas de la fila móvil*/

clrscr() / *Borrar pantalla*/

gotoxy(1,3);

printf("******************gongziguanli******* ******");/*Título de salida*/

tengo

oxy(1,4);

printf(" --Enter @ end--");/*Solicitar ingresar @end*/

gotoxy(1,5);

printf("|------------------------------------------------ ------|"); /*Muestra la línea inicial de la tabla*/

gotoxy(1,6);

printf("| no | name | jbgz |");/*Títulos de los campos de salida, preste atención al número de espacios*/

for(;;)

{

gotoxy(1 ,7+x);

printf( "|----------|----------------|----- ---|");/*Generar la línea horizontal de la tabla*/

info=(SALARY *)malloc(sizeof(SALARY));/*Solicitar un espacio de registro*/

if(!info)

{

printf("\nout of Memory");/*Si no se obtiene espacio, genera información de desbordamiento de memoria*/

exit(0);/*Salir del programa*/

}

info->next=NULL;/*El sucesor del nuevo nodo está vacío */

info->prior=NULL;/*El sucesor del nuevo nodo está vacío El predecesor está vacío*/

gotoxy(1,8+x);printf( "|"); /*La línea divisoria entre los datos de salida*/

gotoxy(12,8 +x);printf("|");

gotoxy(29,8 +x);printf("|");

gotoxy(38,8+x); printf("|");

gotoxy(2,8+x); /*El cursor va a la posición del número de entrada*/

inputs(info->no,10);/ *Ingresa el número y verifica que la longitud no exceda de 10*/

if(info->no[0]=='@')

{

bandera =1;

descanso;

} /*El primer carácter del número es @ para finalizar la entrada*/

gotoxy(13,8+x); /*Cursor Ir a la posición del nombre de entrada*/

inputs(info->name,14); /*Ingrese el nombre y verifique que la longitud no exceda 14*/

gotoxy(30,8+x ); al puesto donde se ingresa el salario base*/

scanf("%f",&temp /*Ingrese el salario base en la variable temporal*/

info->); jbgz =temp; /*Asignación de salario básico*/

info->koukuan=0; /*La deducción inicial es 0, ingrese al calcular el salario*/

info->sfgz = 0; /*El salario real inicial es 0 y se calculará cuando se calcule el salario*/

info->shuijin=0 /*El impuesto inicial es 0; se calculará cuando se vaya a calcular el salario*/

info->yfgz=0 /*El salario inicial a pagar es 0, y se calculará cuando se vaya a calcular el salario*/

if(p==NULL)/*Si p está vacío, indica que la entrada es el primer nodo*/

{

Primero

=Último=info;/*Puntero de cabeza y puntero de cola*/

Primero->prior=NULL /*El predecesor del puntero de cabeza es NULL*/

Último->; next= NULL /*El sucesor del puntero de cola es nulo*/

}

else /*El nodo insertado no es el primer nodo, entonces se inserta antes del encabezado. nodo*/

{

info->next=p;/*El sucesor del nuevo nodo apunta al nodo principal original*/

info- >prior=p- >prior;/*El predecesor del nuevo nodo apunta al predecesor del nodo principal original*/

p->prior=info;/*El predecesor del nodo original apunta al nuevo nodo*/

}

p=info; /*El nuevo nodo se convierte en el nodo p, el nodo principal temporal*/

Primero= info; /*Nuevo nodo Conviértete en el nodo principal*/

x+=2; /*Debido a la línea horizontal, mueve el cursor hacia abajo dos líneas*/

gotoxy(1, 8+x);

i++; /*Agregar 1 al número de registros de entrada*/

if(i%9==0)

break ; /*Ingrese 9 registros y cambie la página Ingrese */

}

gotoxy(1,8+x);

}

}

/*Entrada de cadena y función de verificación*/

entradas(char *s, int count)

{

char p[255];

do{

scanf("%s",p);/*Cadena de entrada*/

if(strlen(p )>count)printf("\n ¡demasiado largo! \n");/*Realice la verificación de longitud y vuelva a ingresar si el valor excede el recuento*/

} while(strlen(p)>count);

strcpy(s,p /*Copia la cadena de entrada a la cadena s*/

}

void list()

{

int i=0,n /*Registra el número de salida; líneas*/

SALARIO *p ; /*Definir el puntero en movimiento*/

clrscr() /*Borrar la pantalla*/

p=Primero /*Comienza desde el puntero principal*/

while(i%10==0&&p!=NULL) /*El bucle externo controla el cambio de página*/

{

i=0; /*Registrar el número de líneas de salida en una página* /

clrscr() /*Borrar pantalla*/

printf("\n\ n\n"); /*Ajustar tres líneas*/

printf("*************************** *********SALARIO********** ****************************** \n"); /*Título de salida*/

printf("|nO | nombre | jbgz | koukuan | yfgz

| shuijin | sfgz |\n"); /*Título del campo de salida*/

printf("|----------|----------- ----|---------|---------|---------|---------|----- ----|\n"); /*Línea horizontal de salida*/

while(p!=NULL) /*Cuando p no está vacío*/

{

printf("|%-10s|%-15s|%9.2f|%9.2f|%9.2f|%9.2f|%9.2f|\n",

p - >no,p->nombre,p->jbgz,p->koukuan,p->yfgz,p->shuijin,p->sfgz);

p=p->siguiente; * Mover el puntero hacia atrás*/

i++ /*Agregar 1 al número de línea de salida */

if(i%10==0)

break; /* Si hay 10 líneas, salte del bucle interno*/

}

printf("************** ********** ******************fin********************* *************** ****\n"); /*Imprimir la línea final de esta página*/

printf("Presione cualquier tecla para continuar. ..\n");

getch( ); /*Pausa la salida de una página y presiona cualquier tecla para continuar*/

} /*Regresa al bucle exterior y prepárate para la siguiente página de salida*/

}

/*Registro de visualización única*/

void display()

{

int ch; /*Carácter de opción de menú*/

SALARIO *p; /*Definir puntero temporal*/

clrscr() /*Borrar pantalla*/

p=First; /*Comienza desde el puntero principal*/

if(p==NULL) /*El puntero está vacío, es decir, la lista vinculada está vacía, regresa a la función principal*/

{

printf("¡el registro está vacío!\n");

return;

}

else

{

print(p ); /*Llame a la función de salida para mostrar la información del nodo del encabezado*/

para (;;) /*El ciclo comienza*/

{

printf(" \n\n0. Salir 1. Anterior 2. Siguiente 3. Primero 4.Último \n\ n");

/*Elemento de menú Salir Salir Anterior Anterior Siguiente Siguiente Primero Primero Último Último* /

printf("\npor favor seleccione 0~4:"); /*Preguntar para la opción de menú 0~4*/

scanf("%d",&ch / *Ingrese las opciones de menú 0~4*/

if(ch==0) break); /*Si la opción es 0, salir*/

switch(ch) /*Sentencia de cambio Juzgar según los caracteres de la opción*/

{

case; 1:p=p->

prior;if(p==NULL)p=First;break; /*Apunta al predecesor, ningún predecesor apunta al primero*/

case 2:p=p->next;if(p == NULL) p=Último;break; /*Apunta al sucesor, si no hay sucesor, apunta al último*/

case 3:p=Primero;break; al primer nodo*/

case 4:p=Last;break; /*Apunta al último nodo*/

}

print(p) /*Llame a la función de salida para mostrar la información del nodo del puntero*/

}

}

}

/*Emite el información del nodo señalado por el puntero*/

void print(SALARY *p)

{

if(p) /*Si el puntero no está vacío, mostrar información*/

{

clrscr() /*Borrar pantalla*/

printf("\n\n\n"); Nueva línea*/

printf ("************************************SALARIO *********** *************************\n"); /*Información del título de salida*/

printf("|no | nombre | jbgz | koukuan| yfgz | shuijin | sfgz |\n"); /*Título del campo de salida*/

printf("|---- ------|---- ----------|---------|---------|-------- -|-------- -|---------|\n"); /*Línea divisoria de salida*/

printf("|%-10s|% -15s|%9.2f|%9.2f |%9.2f|%9.2f|%9.2f|\n", p->no,p->nombre,

p->jbgz,p ->koukuan,p->yfgz,p ->shuijin,p->sfgz);/*Información del nodo de salida*/

printf("*************** *********** *******************fin******************* ********* *** ****\n"); /*Marca final de salida*/

}

}

/*Calcular salarios reales*/

void calc()

{

int x /*Coordenadas de fila*/

int i=0; /*Número de registros*/

float temp; /*Deducción de variable temporal*/

SALARIO *p;

clrscr(); /*Borrar pantalla */

p=Primero; /*Comenzar desde el puntero principal*/

while(p!=NULL) /*Cuando p no está vacío, es decir, cuando hay un registro, la página de control de bucle externo cambia*/

{

x=0;

clrscr( );

gotoxy(1,3);

printf("**********

****************gongziguanli********************************* *** ***"); /*Título de salida*/

gotoxy(1,5);

printf("|---------- --- ----------------------------------------------- --- -----------|");

gotoxy(1,6);/*Títulos de los campos de salida a continuación*/

printf(" | no | nombre | jbgz | koukuan | yfgz |shuijin |");

while(p!=NULL) /*Cuando p no está vacío, es decir, cuando hay un registro, El bucle interno controla y procesa 9 registros */

{

gotoxy(1,7+x);

printf("|------ ----|-- ---------------|--------|----------|--------------- -|------ --|--------|");

gotoxy(1,8+x);printf("|");

gotoxy(12,8 +x);printf("|");

gotoxy(29,8+x);printf("|");

gotoxy (38,8+x); printf("|");

gotoxy(49,8+x);printf("|");

gotoxy(58,8) +x);printf("| ");

gotoxy(67,8+x);printf("|");

gotoxy(76,8+x); printf("|");

gotoxy(2,8+x);

printf("%-10s",p->no); /*número de salida*/

gotoxy (13,8+x);

printf("%-15s",p->nombre); /*Nombre de salida*/

gotoxy(30,8+x) ;

printf("%.2f",p->jbgz /*Salario básico de salida*/

gotoxy(39,8+) x);

scanf("%f",&temp); /*Ingresar deducción*/

p->koukuan=temp /*Asignación del campo de deducción*/

p- >yfgz=p->jbgz-p->koukuan; /*Calcular salario a pagar = deducción del salario básico*/

gotoxy(50,8+x);

printf("%.2f",p->yfgz); /*Importar el salario adeudado*/

gotoxy(59,8+x);

p->shuijin= (p->yfgz-1000)*fax(p->yfgz); /*De lo contrario, el impuesto se calcula según la tasa impositiva*/

printf("%.2f ",p->shuijin); /*Impuestos sobre la producción*/

gotoxy(68,8+x);

p->sfgz=p->yfgz-p-> shuijin; /*Calcular salarios reales*/

printf

("%-8.2f",p->sfgz); /*Salarios reales de salida*/

x+=2; /*Mover las coordenadas de la fila dos líneas hacia abajo*/

i++; /*Aumentar el número de registros en 1*/

if(i%9==0)break; /*El número de registros excede 9, saltar fuera del bucle interno*/

p= p->next; /*Mover el puntero hacia atrás y procesar el siguiente elemento*/

}

gotoxy(1,7+x);

printf(" |----------|----------------|--------|--- -------|- -------|--------|--------|\n"); /*Fin de la línea de salida*/

printf("Presione cualquier tecla para continuar...\n");

getch();

}

}

/*Según el salario adeudado, calcular la tasa impositiva*/

float fax(float x)

{

float f1;

if(x<1000)

devuelve 0; /*menos de 1000, devuelve 0*/

switch((int)(x/1000))

{

caso 1:f1=0.05;break; /*1000~1999, devuelve 0.05*/

caso 2:f1=0.1;break; /*2000~2999, devuelve 0.1*/

caso 3:f1=0.15;break; /*3000~3999, devuelve 0.15*/

caso 4:f1=0.2; break; /*4000~4999, devuelve 0.2*/

default:f1=0.3;break; /*Por encima de 5000, devuelve 0.3*/

}

return f1;

}

/*Calcular el número de cupones*/

void computer()

{

SALARIO *p;

int i=0,a[7]={0},t100,t50,t20,t10,t5,t2,t1;/*Establecer la matriz y temporal variables para guardar el número de cupones*/

float t /*Variable de transición, guarda el salario restante actual*/

p=Primero /*Mueve el puntero comenzando desde el puntero de inicio*/

while(p!=NULL) /*Cuando p Cuando no está vacío*/

{

t100=(int)p-> sfgz/100; /*Calcular el número de hojas de 100 yuanes*/

a [0]=a[0]+t100; /*ahorro acumulado*/

t=p ->sfgz-t100*100; /*salario restante*/

t50= (int)(t/50); /*Calcular el número de hojas de 50 yuanes*/

a[1]=a[1]+t50; /*Ahorrar acumulativamente*/

t=t-t50*50; /*Salarios restantes*/

t20=(int )(t/20); /*Calcular el número de hojas de 20 yuanes*/

a[ 2]=a[2]+t20 /*acumular y guardar*/