双链表 c teacherdoublenoheadnoloop

双链表 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