双链表 c teacher-double-nohead-noloop

main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"

typedef struct girl {
char name[30];
int bra;
int beautiful;
} girl_t ;

void input_girl( girl_t * girl )
{
printf("Input girl name: ");
gets( girl->name );
printf("Input gril bra: ");
scanf("%d", &girl->bra );
printf("Input girl beautiful: ");
scanf("%d", &girl->beautiful );
getchar();
}

void print_girl( void * data )
{
girl_t * girl = ( girl_t * ) data;
printf("girl name: %s\n", girl->name );
printf("girl bra: %d\n", girl->bra );
printf("girl beautiful: %d\n\n", girl->beautiful );
}

int del_condition( void * data )
{
girl_t * girl = ( girl_t * ) data;
if( girl->bra > 80 || girl->bra < 40 || girl->beautiful < 6 )
return 1;
return 0;
}

int compare( void * data1, void * data2 )
{
girl_t * girl1 = ( girl_t * )data1;
girl_t * girl2 = ( girl_t * )data2;

if( girl1->beautiful > girl2->beautiful )
return -1;
return 1;
}

void menu( void )
{
printf("(1) insert from end .\n");
printf("(2) delete a node .\n");
printf("(3) sort list.\n" );
printf("(4) print list .\n");
printf("(5) save file.\n");
printf("(6) load file.\n");
printf("(0) exit.\n");
printf("Choice: ");
}

int main( int argc, char ** argv )
{
node_t * head = NULL;
char filename[30];

while( 1 ) {
menu();
int choice;
girl_t girl;

scanf( "%d", &choice );
getchar();
switch( choice ){
case 0:
destroy_list( &head );
exit( 0 );
case 1:
input_girl( &girl );
insert_node( &head, &girl, sizeof(girl_t) );
break;
case 2:
del_node( &head, del_condition );
break;
case 3:
sort_node( head, compare );
break;
case 4:
print_list( head, print_girl );
break;
case 5:
printf("Save as: ");
gets( filename );
save_list( head, sizeof(girl_t), filename );
break;
case 6:
printf("Input the filename: ");
gets( filename );
load_list( &head, sizeof(girl_t), filename );
break;
default:
printf("choice error.\n");
break;
}
}

return 0;
}

list.h

#ifndef _GEN_NOLOOP_SINGLE_
#define _GEN_NOLOOP_SINGLE_

typedef struct node node_t;
struct node {
void * data;
node_t * pre;
node_t * next;
};

#define TYPE_LEN 4
#define TYPE_NAME "LIST"

int length( node_t * head );
node_t * get_num( node_t * head, int num );
int insert_node( node_t ** head, void * data, int data_len );
int del_node( node_t ** head, int ( * condition )( void * ) );
int sort_node( node_t * head, int ( * compare )( void *, void * ) );
int print_list( node_t * head, void ( * print )( void * data ) );
int destroy_list( node_t ** head );
int save_list( node_t * head, int data_len, char * filename );
int load_list( node_t ** head, int data_len, char * filename );
#endif /* _GEN_NOLOOP_SINGLE_ */

list.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"

int insert_node( node_t ** head, void * data, int data_len )
{
node_t * node = ( node_t * )malloc( sizeof(node_t) );
node->data = malloc( data_len );
memcpy( node->data, data, data_len );
node->pre = NULL;

if( *head == NULL ) {
*head = node;
(*head)->next = NULL;
} else {
(*head)->pre = node;
node->next = *head;
*head = node;
}
}

int del_node( node_t ** head, int ( * condition )( void * ) )
{
node_t * temp = *head;

while( temp != NULL ) {
int ret = condition( temp->data );
if( ret == 1 ) {
if( temp == *head ) {
*head = temp->next;
free( temp->data );
free( temp );
if( *head != NULL )
(*head)->pre = NULL;
temp = *head;
} else {
node_t * temp_next = temp->next;
if( temp->next != NULL )
temp->next->pre = temp->pre;
temp->pre->next = temp->next;
free( temp->data );
free( temp );
temp = temp_next;
}
} else {
temp = temp->next;
}
}
}

node_t * get_num( node_t * head, int num )
{
while( head != NULL ) {
if( num -- == 0 )
return head;
head = head->next;
}

return NULL;
}

int length( node_t * head )
{
int i = 0;
while( head != NULL ) {
++ i;
head = head->next;
}
return i;
}

int sort_node( node_t * head, int ( * compare )( void *, void * ) )
{
node_t * temp = head;
int len = length( head );

int i, j;

for( i=0; i<len-1; ++i )
for( j=0; j<len-1-i; ++j ){
node_t * n1 = get_num( head, j );
node_t * n2 = get_num( head, j+1 );
int ret = compare( n1->data, n2->data );
if( ret > 0 ) {
void * temp_data;
temp_data = n1->data;
n1->data = n2->data;
n2->data = temp_data;
}
}
return 0;
}

int merge_list( node_t ** head1, node_t * head2 )
{
if( *head1 == NULL ) {
*head1 = head2;
} else {
if( head2 != NULL ) {
node_t * temp = *head1;
while( temp->next != NULL )
temp = temp->next;
temp->next = head2;
head2->pre = temp;
}
}
}

int print_list( node_t * head, void ( * print )( void * ) )
{
while( head != NULL ) {
print( head->data );
head = head->next;
}
}

int destroy_list( node_t ** head )
{
node_t * temp = *head;

while( temp != NULL ) {
temp = temp->next;
free( (*head)->data );
free( (*head) );
*head = temp;
}
return 0;
}

int save_list( node_t * head, int data_len , char * filename )
{
FILE * fp = fopen( filename, "wb" );
if( fp == NULL ) {
perror( "fopen" );
exit( 1 );
}

char magic[ TYPE_LEN + 1 ] = TYPE_NAME;
fwrite( magic, 4, 1, fp );

int ret;
while( head != NULL ) {
ret = fwrite( head->data, data_len, 1, fp );
if( ret != 1 )
continue;
head = head->next;
}
fclose( fp );
}

int load_list( node_t ** head, int data_len, char * filename )
{
FILE * fp = fopen( filename, "rb" );
if( fp == NULL ) {
perror( "fopen" );
return -1;
}

char * buf = ( char * )malloc( TYPE_LEN );
fread( buf, TYPE_LEN, 1, fp );
if( strncmp( buf, TYPE_NAME, 4 ) != 0 ) {
printf("Can't parse the file type.\n");
return -1;
}

destroy_list( head );

int ret;
void * data_buf = malloc( data_len );
while( feof( fp ) == 0 ) {
ret = fread( data_buf, data_len, 1, fp );
if( ret != 1 )
continue;
insert_node( head, data_buf, data_len );
}
fclose( fp );
}

Makefile

all: main

main: main.c list.c list.h Makefile
gcc -o main main.c list.c -g