/*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(;;)
<; p> {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);
}
<; p> printf("|---- ------|----------------|----------------|");/*Emitir el línea horizontal final*/}
/*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*/
}
<); p>/*Mostrar la lista enlazada*/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*/
0*20; /*Salarios residuales*/
t10=(int)(t/10); /*Calcular el número de hojas de 10 yuanes*/
a[3] =a [3]+t10; /*Acumular y ahorrar*/
t=t-t10*10; /*Salario restante*/
t5=(int)(t /5) ; /*Calcular el número de hojas de 5 yuanes*/
a[4]=a[4]+t5 /*Guardar acumulativamente*/
t=t; -t5*5; /*Salarios residuales*/
t2=(int)(t/2); /*Calcular el número de hojas de 2 yuanes*/
a[5); ]=a[5]+ t2; /*Acumular y ahorrar*/
t=t-t2*2; /*Salario restante*/
t1=(int)( t); /*Calcular 1 yuan Número de imágenes*/
a[6]=a[6]+t1 /*Acumulado y guardado*/
p=p-; >next; /*Mover el puntero hacia atrás y procesar el siguiente registro*/
}
clrscr() /*Borrar pantalla*/
printf(" \n\n\n**** *******número de billete******************\n"); /*Título de salida*/
printf("--100-- ---50------20-----10-----5------2------1-- ----\n");
/*Ingrese el número de títulos de imágenes*/
for(i=0;i<7;i++)
printf("%5d ",a[i] );/*Imprima el número requerido de hojas*/
printf("\n");/*Salto de línea*/
}
/*Presione Registro de búsqueda de número*/
SALARIO *find(char *no)
{
SALARIO *p; /*Definir puntero móvil*/
p=Primero; /*Comenzar desde el puntero principal*/
while(p) /*Cuando p no está vacío*/
{
if(!strcmp(no,p->no))
return p; /*Comparar igual, encontrar correctamente, devolver puntero*/
p=p->next; / *El puntero desigual se mueve hacia atrás*/
}
printf("not found\n"); *No encontrado*/
return NULL; / *devuelve como un puntero nulo*/
}