C语言之歌词解析

linuxcszl 2020-03-26 我要评论

0x00 脚下的路

不知道为啥要写这个小标题，可能是年轻的心想体验一下苍老的感觉，抑或是少年的一阵迷茫。混沌的四年，终究还是入了这一行。从初时的不知，到现在的刚开始，中间的间隔竟是四年之久，想起了陈奕迅的《十年》，但却不像医生所唱的十年那么有故事。或许这四年有这四年的价值，这四年也应有所积累。少年狂应少发，更不是什么老夫，当然也没有什么资格。之后的路应该在脚下，应是一步一步。比较喜欢的一句话，不去想目的地，才能轻松踏上旅途。少些心血来潮，多些精专。

聊以此记，舒心之惑，明己之志。

0x01 歌词解析

这是一个用c语言完成的小项目，大神们称之为玩具。不过对于对于知识的积累确有不小的作用。对于自己也是很好的训练，吃透每个小项目，吃透每一个细节，故总结之。

何为歌词解析？效果如何。刚开始必然是一片迷茫，可使用过各种播放器的我们应该对此熟悉。这是平日的歌曲播放器的部分截图：

管中窥豹，实现后的具体效果大致也应如此。当然，歌词解析吗？更应该了解歌词是什么样子的，有什么样子的格式(我们都明白，一切的神秘下面都隐藏着简单的道理)。这是某个词文件的部分截图：

如此，大致便可有些许想法了：将歌词文件读取出来，逐行显示在屏幕上，并随着歌曲播放时间逐行滚动。

0x02 流程分析

通过观察歌词，可以想到使用链表存储歌词信息比较方便，因为歌词要一行一行显示，并且事先并不了解每首歌的歌词有多少句。可以将歌词的每一句存入链表的一个节点。

整个流程大致可以分为如下几块：

读取歌词文件
按行切割歌词文件
逐行分析歌词头部歌曲信息部分
逐行分析歌词正文部分，并根据每行歌词前的时间将歌词插入链表
模拟时钟，根据时间显示歌词和播放歌曲
歌词滚屏，歌词反显(当前歌词突出显示)

0x03 读取歌词文件

文本文件的读取大致分如下步骤：

打开歌词文件
计算歌词文件的大小
分配内存空间
将歌词读入内存
关闭歌词文件

/*读取歌词*/
void read_lrc(char *p_lrc, char **lrc_data)
{
    /*打开歌词文件*/
    FILE *fp = fopen(p_lrc, "r");
    if(fp == NULL)
    {
        perror("fopen");
        return;
    }
    
    /*计算歌词文件的大小*/
    fseek(fp, 0, 2);
    long lrc_len = ftell(fp);
    rewind(fp);
    
    /*分配内存空间*/
    *lrc_data = (char *)calloc(1, lrc_len);
    if(*lrc_data == NULL)
    {
        perror("ralloc");
        return;
    }
    
    /*将歌词读入内存*/
    fread(*lrc_data, lrc_len, 1, fp);
    
    /*关闭文件*/
    fclose(fp); 
    return;
}

0x04 按行切割歌词文件

歌词切割应注意如下(百度百科)：

/*将歌词逐行分割*/
void lrctok(char ** buf, char *lrc_data)
{
    buf[0] = lrc_data;
    int i = 0;
    while((buf[i] = (char *)strtok(buf[i], "\r\n")))
        i++;
    return;
}

0x05 逐行分析歌词头部

歌词头部信息格式(百度百科)：

由于头部信息比较简单，所以并不把头部信息存入链表，而是直接分析后显示：

/*分析歌词头部信息*/
int analysis_lrc_head(char **buf)
{
    clear_screen();
    cusor_moveto(0, 0);
    set_fg_color(COLOR_GREEN);
    
    /*逐行分析头部*/
    int i = 0;
    while(*(buf[i] + 1) > '0')/*解释歌词信息*/
    {
        /*读取头部信息内容*/
        char lrc[128]="";
        sscanf(buf[i],"%*[^:]:%[^]]", lrc);
        
        /*读取头部信息标签*/
        char tags[10] = "";
        sscanf(buf[i], "[%[^:]", tags);
        
        cusor_moveto(35, i+1);
        
        
        if(strcmp(tags, "ti") == 0)
        {
            printf("歌名:");
        }
        else if(strcmp(tags, "ar") == 0)
        {
            printf("歌手:");
        }
        else if(strcmp(tags, "al") == 0)
        {
            printf("专辑:");
        }
        else if(strcmp(tags, "by") == 0)
        {
            printf("制作:");
        }
        else if(strcmp(tags, "offset") == 0)
        {
            printf("offset:");
        }
        printf("%s\n", lrc);
        i++;
    }
    
    //printf("%d\n", i);
    return i;
}

0x06 逐行分析歌词正文

对于歌词正文部分，要处理的有两个方面：一方面分析每句歌词前面的时间，另一方面，将根据前面的时间将歌词插入链表。

/*分析歌词正文部分*/
int analysis_lrc_body(char **buf,int star_num, List *list)
{
    int i = star_num;/*从头部信息之后开始分析*/
    while(buf[i])/*解析歌词正文*/
    {
        char *str_lrc = buf[i];
    
        while(*str_lrc == '[')/*寻找歌词位置*/
            str_lrc +=10;
            
        //printf("%s\n", str_lrc);/*打印当前歌词测试*/
        
        char *str_time = buf[i];/*解析每句歌词前的时间*/
        while(*str_time == '[')
        {
            int m = 0,s = 0;
            sscanf(str_time,"[%d:%d.%*d]", &m, &s);
            int time = m*60+s;//以秒为单位
           
            /*将时间和歌词 --对应 放入结构体*/
            LRC *tmp = (LRC *)calloc(1, sizeof(LRC));
            if(tmp == NULL)
            {
                perror("calloc");
                return i;
            }
            tmp->time = time;
            strcpy(tmp->lrc, str_lrc);
       
            //调用链表的有序插入函数
            list_ins_sort(list, tmp);
           
            //分析下一个时间
            str_time  += 10;
        }   
        i++;
    }
    return i;
}

0x07 模拟时钟

使用模拟时钟的目的是模拟实现歌曲播放与歌词同步，模拟时钟和歌曲播放器同时启动，然后根据模拟时钟的时间在歌词链表中查找。

int i = 0;/*模拟计时器*/
while(1)
{

        /*根据时间i到链表中查找，并且打印歌词*/

    time_delay(1);
    i++;
}

0x08 歌词滚屏、歌词反选

/*模拟时钟*/
int i = 0;/*模拟计时器*/
char show[5][128] = {"","","","",""};
while(1)
{

    /*显示进度条*/
    int base = 15;/*进度条从第base列起始*/
    set_fg_color(COLOR_RED);
    cusor_moveto(base, line + 9);
    printf("%02d:%02d|",i/60,i%60);/*以mm:ss格式打印时间*/
    fflush(stdout);
    
    int endtime = ((LRC *)(list.tail->data))->time;
    int length = (i*1.0)/endtime*45;
    cusor_moveto(base + 6, line + 9);
    int j = 0;
    for(; j < length; j++)
    {
        printf(">");
    }
    cusor_moveto(base + 51, line + 9);
    printf("|%02d:%02d",endtime/60, endtime%60);
    
    
    /*查找此时的歌词*/
    int offset = 0;/*调整歌词与歌曲同步偏差*/
    LRC tmp;/*按时间查找歌词*/
    tmp.time = i + offset;/*初始化查找时间*/
    strcpy(tmp.lrc, "");
    
    Node *ret = list_search(&list, &tmp);/*返回查找歌词在链表中的位置*/
    
    if(ret != NULL)
    {
        /*滚动显示歌词*/
        strcpy(show[0], show[1]);
        strcpy(show[1], show[2]);
        strcpy(show[2], show[3]);
        strcpy(show[3], show[4]);
        strcpy(show[4], ((LRC *)(ret->data))->lrc);
            
        cusor_moveto(30, line+2);
        set_fg_color(COLOR_WHITE);
        printf("%s                             \n", show[0]);
        fflush(stdout);
        
        cusor_moveto(30, line+3);
        printf("%s                             \n", show[1]);
        fflush(stdout);
        
        cusor_moveto(30, line+4);
        printf("%s                             \n", show[2]);
        fflush(stdout);
        
        cusor_moveto(30, line+5);
        printf("%s                             \n", show[3]);
        fflush(stdout);
        
        cusor_moveto(30, line+6);
        set_fg_color(COLOR_BLUE);
        printf("%s                             \n", show[4]);
        set_fg_color(COLOR_WHITE);
        fflush(stdout);
        
        if(ret->next == NULL)
        {           
            cusor_moveto(0, line+25);
            cusor_show();
            break;
        }
        
    }
    time_delay(1);
    i++;
}

0x09 运行结果

0x10 全部程序

[my_lrc]tree
.
├── list
│   ├── list.c
│   └── list.h
├── lrc
│   ├── coffe.lrc
│   ├── 邓紫棋-存在.lrc
│   ├── 邓紫棋-喜欢你.lrc
│   └── 简单爱.lrc
├── lrc.c
├── lrc.h
├── main
├── main.c
├── makefile
├── mplayer
│   ├── start_mplayer.c
│   └── start_mplayer.h
├── pos
│   ├── console.c
│   └── console.h
├── song
│   ├── coffe.mp3
│   ├── 邓紫棋-存在.mp3
│   ├── 邓紫棋-喜欢你.mp3
│   └── 简单爱.mp3
└── time_delay
    ├── time_delay.c
    └── time_delay.h

makefile

CC=gcc
obj=main.o lrc.o list.o start_mplayer.o console.o time_delay.o list.o
target=main
CFLAGS=-Wall 

$(target):$(obj)
    @$(CC) $^ -o $@ $(CFLAGS)
main.o:main.c 
    @$(CC) -c $< -o $@ $(CFLAGS)
lrc.o:lrc.c
    @$(CC) -c $< -o $@ $(CFLAGS)
start_mplayer.o:./mplayer/start_mplayer.c
    @$(CC) -c $< -o $@ $(CFLAGS)
console.o:./pos/console.c 
    @$(CC) -c $< -o $@ $(CFLAGS)
time_delay.o:./time_delay/time_delay.c 
    @$(CC) -c $< -o $@ $(CFLAGS)
list.o:./list/list.c 
    @$(CC) -c $< -o $@ $(CFLAGS)
clean:
    @rm $(obj)  -rf

main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "time_delay/time_delay.h"
#include "mplayer/start_mplayer.h"
#include "list/list.h"
#include "pos/console.h"
#include "lrc.h"

int main(int argc, char *argv[])
{
    /*读取歌词文件*/
    char *lrc_data = NULL;
    read_lrc("./lrc/coffe.lrc", &lrc_data);
    
    /*将歌词按行分割*/
    char *buf[128]={NULL};
    lrctok(buf, lrc_data);
    
    /*逐行解析歌词*/
    List list;/*创建歌词链表*/
    list_init(&list, destroy, print, time_cmp);
    
    cusor_hide();
    int line = analysis_lrc_head(buf);/*分析歌词头部信息*/
    analysis_lrc_body(buf, line, &list);/*分析歌词正文*/
    
    //print_list(&list);/*打印歌词链表调试*/
    
    /*启动maplayer*/
    mplayer_play("./song/coffe.mp3");
    
    /*模拟时钟*/
    int i = 0;/*模拟计时器*/
    char show[5][128] = {"","","","",""};
    while(1)
    {

        /*显示进度条*/
        int base = 15;/*进度条从第base列起始*/
        set_fg_color(COLOR_RED);
        cusor_moveto(base, line + 9);
        printf("%02d:%02d|",i/60,i%60);/*以mm:ss格式打印时间*/
        fflush(stdout);
        
        int endtime = ((LRC *)(list.tail->data))->time;
        int length = (i*1.0)/endtime*45;
        cusor_moveto(base + 6, line + 9);
        int j = 0;
        for(; j < length; j++)
        {
            printf(">");
        }
        cusor_moveto(base + 51, line + 9);
        printf("|%02d:%02d",endtime/60, endtime%60);
        
        
        /*查找此时的歌词*/
        int offset = 0;/*调整歌词与歌曲同步偏差*/
        LRC tmp;/*按时间查找歌词*/
        tmp.time = i + offset;/*初始化查找时间*/
        strcpy(tmp.lrc, "");
        
        Node *ret = list_search(&list, &tmp);/*返回查找歌词在链表中的位置*/
        
        if(ret != NULL)
        {
            /*滚动显示歌词*/
            strcpy(show[0], show[1]);
            strcpy(show[1], show[2]);
            strcpy(show[2], show[3]);
            strcpy(show[3], show[4]);
            strcpy(show[4], ((LRC *)(ret->data))->lrc);
                
            cusor_moveto(30, line+2);
            set_fg_color(COLOR_WHITE);
            printf("%s                             \n", show[0]);
            fflush(stdout);
            
            cusor_moveto(30, line+3);
            printf("%s                             \n", show[1]);
            fflush(stdout);
            
            cusor_moveto(30, line+4);
            printf("%s                             \n", show[2]);
            fflush(stdout);
            
            cusor_moveto(30, line+5);
            printf("%s                             \n", show[3]);
            fflush(stdout);
            
            cusor_moveto(30, line+6);
            set_fg_color(COLOR_BLUE);
            printf("%s                             \n", show[4]);
            set_fg_color(COLOR_WHITE);
            fflush(stdout);
            
            if(ret->next == NULL)
            {           
                cusor_moveto(0, line+25);
                cusor_show();
                break;
            }
            
        }
        time_delay(1);
        i++;
    }
    /*释放空间*/
    if(lrc_data != NULL)
    {
        free(lrc_data);
        lrc_data = NULL;
    }
    list_destroy(&list);
    return 0;
}

lrc.h

#ifndef __LRC_H__
#define __LRC_H__

#include "list/list.h"
typedef struct lrc
{
    //数据域
    int time;
    char lrc[128];
}LRC;

extern void print(const void *data);/*打印歌词结构体*/
extern int time_cmp(const void *key1, const void *key2);/*歌词结构的比较,按时间比较*/
extern void destroy(void *data);/*歌词结构体空间的释放*/
extern void read_lrc(char *p_lrc, char **lrc_data);/*读取歌词文件,将内容写入制定内存空间,函数外部分配空间*/
extern void lrctok(char ** buf, char *lrc_data);/*逐行分割歌词*/
extern int analysis_lrc_head(char **buf);/*分析歌词头部信息*/
extern int analysis_lrc_body(char **buf,int star_num, List *list);/*分析歌词正文信息*/


#endif  //__LRC_H__

lrc.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lrc.h"
#include "list/list.h"
#include "pos/console.h"

/*定义歌词结构的打印方式*/
void print(const void *data)
{
    LRC *lrc_data = (LRC *)data;
    printf("%s\n", lrc_data->lrc);

    return;
}

/*定义歌词结构的比较方式,此处以时间比较*/
int time_cmp(const void *key1, const void *key2)
{

    LRC *tm1 = (LRC *)key1;
    LRC *tm2 = (LRC *)key2;
    if(tm1->time > tm2->time)
        return 1;
    else if(tm1->time < tm2->time)
        return -1;
    else
        return 0;
}
/*定义歌词结构的空间的释放方式*/
void destroy(void *data)
{
    if(data != NULL)
    {
        free(data);
        data = NULL;
    }
    return;
}

/*读取歌词*/
void read_lrc(char *p_lrc, char **lrc_data)
{
    /*打开歌词文件*/
    FILE *fp = fopen(p_lrc, "r");
    if(fp == NULL)
    {
        perror("fopen");
        return;
    }
    
    /*计算歌词文件的大小*/
    fseek(fp, 0, 2);
    long lrc_len = ftell(fp);
    rewind(fp);
    
    /*分配内存空间*/
    *lrc_data = (char *)calloc(1, lrc_len);
    if(*lrc_data == NULL)
    {
        perror("ralloc");
        return;
    }
    
    /*将歌词读入内存*/
    fread(*lrc_data, lrc_len, 1, fp);
    
    /*关闭文件*/
    fclose(fp);
    
    return;
}

/*将歌词逐行分割*/
void lrctok(char ** buf, char *lrc_data)
{
    buf[0] = lrc_data;
    int i = 0;
    while((buf[i] = (char *)strtok(buf[i], "\r\n")))
        i++;
    return;
}

/*分析歌词头部信息*/
int analysis_lrc_head(char **buf)
{
    clear_screen();
    cusor_moveto(0, 0);
    set_fg_color(COLOR_GREEN);
    
    /*逐行分析头部*/
    int i = 0;
    while(*(buf[i] + 1) > '0')/*解释歌词信息*/
    {
        /*读取头部信息内容*/
        char lrc[128]="";
        sscanf(buf[i],"%*[^:]:%[^]]", lrc);
        
        /*读取头部信息标签*/
        char tags[10] = "";
        sscanf(buf[i], "[%[^:]", tags);
        
        cusor_moveto(35, i+1);
        
        
        if(strcmp(tags, "ti") == 0)
        {
            printf("歌名:");
        }
        else if(strcmp(tags, "ar") == 0)
        {
            printf("歌手:");
        }
        else if(strcmp(tags, "al") == 0)
        {
            printf("专辑:");
        }
        else if(strcmp(tags, "by") == 0)
        {
            printf("制作:");
        }
        else if(strcmp(tags, "offset") == 0)
        {
            printf("offset:");
        }
        printf("%s\n", lrc);
        i++;
    }
    
    //printf("%d\n", i);
    return i;
}

/*分析歌词正文部分*/
int analysis_lrc_body(char **buf,int star_num, List *list)
{
    int i = star_num;/*从头部信息之后开始分析*/
    while(buf[i])/*解析歌词正文*/
    {
        char *str_lrc = buf[i];
    
        while(*str_lrc == '[')/*寻找歌词位置*/
            str_lrc +=10;
            
        //printf("%s\n", str_lrc);/*打印当前歌词测试*/
        
        char *str_time = buf[i];/*解析每句歌词前的时间*/
        while(*str_time == '[')
        {
            int m = 0,s = 0;
            sscanf(str_time,"[%d:%d.%*d]", &m, &s);
            int time = m*60+s;//以秒为单位
           
            /*将时间和歌词 --对应 放入结构体*/
            LRC *tmp = (LRC *)calloc(1, sizeof(LRC));
            if(tmp == NULL)
            {
                perror("calloc");
                return i;
            }
            tmp->time = time;
            strcpy(tmp->lrc, str_lrc);
       
            //调用链表的有序插入函数
            list_ins_sort(list, tmp);
           
            //分析下一个时间
            str_time  += 10;
        }
            
        i++;
    }
    return i;
}

mplayer_play.h

#ifndef __START_MPLAYER_H__
#define __START_MPLAYER_H__
//启动mplayer播放器 
//参数song_path 为歌曲的路径
extern void mplayer_play(char * song_path);
#endif

mplayer_play.c

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
//启动mplayer播放器 
//参数song_path 为歌曲的路径
void mplayer_play(char * song_path)
{
    pid_t pid;
    pid=fork();
    if(pid<0)
    {
        perror("fork");
    }
    else if(pid==0)
    {
        close(1);
        close(2);
        execlp("mplayer","mplayer","-slave","-quiet",song_path,NULL);
        exit(0);
    }
    else
        ;
}

console.h

#ifndef  _CONSOLE_H_
#define  _CONSOLE_H_

#define     COLOR_RED              31
#define     COLOR_BLACK            30
#define     COLOR_GREEN            32
#define     COLOR_BLUE             34
#define     COLOR_YELLOW           33
#define     COLOR_WHITE            37
#define     COLOR_CYAN             36
#define     COLOR_MAGENTA          35
/*
COLOR_RED              红
COLOR_BLACK            黑
COLOR_GREEN            绿
COLOR_BLUE             蓝
COLOR_YELLOW           黄
COLOR_WHITE            白
COLOR_CYAN             青
COLOR_MAGENTA          洋红
*/

extern void cusor_moveto(int x, int y);//光标跳转到 y行 x列
extern void cusor_get_pos(void);//保存光标位置
extern void cusor_hide(void);//隐藏光标
extern void cusor_show(void);//显示光标
extern void cusor_set_pos(void);//恢复光标位置
extern void clear_screen(void);//清屏
extern void set_fg_color(int color);//设置字体前景色
extern void set_bg_color(int color);//设置字体背景色

#endif  //_CONSOLE_H_

console.c

#include <stdio.h>
#include <stdlib.h>
#include "console.h"

void cusor_moveto(int x, int y)
{// ESC[y;xH
    printf("\033[%d;%dH",y,x);
    fflush(stdout);
} 

//保存光标位置
void cusor_get_pos(void)
{// ESC[s
    printf("\033[s");
    fflush(stdout);
} 

//恢复光标位置
void cusor_set_pos(void)
{// ESC[u
    printf("\033[u");
    fflush(stdout);
} 
//隐藏光标
void cusor_hide(void)
{
    printf("\033[?25l");
}
//显示光标
void cusor_show(void)
{
    printf("\33[?25h");
}
//清屏
void clear_screen(void)
{// ESC[2J
    printf("\033[2J");
    fflush(stdout);
}

/*
COLOR_RED              红
COLOR_BLACK            黑
COLOR_GREEN            绿
COLOR_BLUE             蓝
COLOR_YELLOW           黄
COLOR_WHITE            白
COLOR_CYAN             青
COLOR_MAGENTA          洋红
*/
//设置前景颜色
void set_fg_color(int color)
{// ESC[#m
    printf("\033[%dm",color);
    fflush(stdout);
}

//设置背景颜色
void set_bg_color(int color)
{// ESC[#m
    printf("\033[%dm",(color+10));
    fflush(stdout);
}

time_delay.h

#ifndef __TIME_DELAY__
#define __TIME_DELAY__

extern void time_delay(int sec);

#endif  //__TIME_DELAY__

time_delay.c

#include <stdio.h>
#include <time.h>
void time_delay(int sec)
{
    int s_time,e_time;
    s_time=time(NULL);
    while(1)
    {
        e_time=time(NULL);
        if(e_time==s_time+sec)
            break;
    }
}

list.h

#ifndef LINK_H
#define LINK_H

typedef struct node//链表元素的结构
{
        void *data;/*节点中的数据域，设置为无类型指针，数据类型大小由使用者定义*/
        struct node *next;/*指向下一节点的指针*/
}Node;

typedef struct list/*链表的结构*/
{
        int size;/*链表中节点个数*/
        void (*destroy)(void *data);/*由于链表节点中的数据是用户自定义的，故需要调用者提供释放空间的函数*/
        void (*print_data)(const void *data);/*同，由用户自定义打印数据的函数*/
        int (*match)(const void *key1, const void *key2);/*同，由用户自定义数据的比较方式*/

        Node *head;/*记录链表的头部位置*/
        Node *tail;/*记录链表的尾部位置*/
}List;

extern void list_init(List *list, void (*destroy)(void *data), void (*print_data)(const void *data), \
            int (*match)(const void *key1, const void *key2));/*初始化一个链表*/
extern int list_ins_head(List *list, const void *data);/*链表的插入，将节点从头部插入*/
extern int list_ins_tail(List *list, const void *data);/*链表的插入，将节点从尾部插入*/
extern int list_ins_sort(List *list, const void *data);/*链表的插入，插入后链表是一个有序的链表*/
extern void* list_search(List *list, const void *data);/*在链表中查找指定数据，若找到返回链表中的位置*/
extern void* list_remove(List *list, const void *data);/*在链表中删除指定数据，若找到删除节点并将数据地址返回*/
extern void list_reverse(List *list);//将链表逆置*/
extern void list_sort(List *list);/*将链表按照一定方式排序*/
extern void print_list(List *list);/*打印链表*/
extern void list_destroy(List *list);/*删除整个链表*/

#define list_size(list) (list->size)  /*返回链表节点个数*/
#endif // LINK_H

list.c

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

/*初始化链表*/
void list_init(List *list, void (*destroy)(void *data), void (*print_data)(const void *data), \
    int (*match)(const void *key1, const void *key2))
{
    list->size = 0;
    list->head = NULL;
    list->tail = NULL;
    list->match = match;
    list->destroy = destroy;
    list->print_data = print_data;

    return;
}

/*打印整个链表*/
void print_list(List *list)
{

    if(list->head == NULL)//链表为空
    {
        printf("list is empty\n");
    }
    else //链表非空
    {
        Node * p_cur = list->head;
        while (p_cur)/*遍历链表*/
        {
            list->print_data(p_cur->data);
            p_cur = p_cur->next;
        }
    }

    return;
}

/*在链表的头部插入数据*/
int list_ins_head(List *list, const void *data)
{
    Node *new_node = (Node *)calloc(1, sizeof (Node)); //创建插入的节点
    if(new_node == NULL)
        return -1;

    new_node->data = (void *)data;//关联节点与数据
/*
    if(list_size(list) == 0)//链表为空时，插入节点
    {
        list->tail = new_node;
        new_node->next = NULL;
        list->head = new_node;
    }
    else //链表非空时将节点插入头部
    {
        new_node->next = list->head;
        list->head = new_node;
    }
*/
    if(list_size(list) == 0)//链表为空时，插入节点
        list->tail = new_node;

    new_node->next = list->head;
    list->head = new_node;

    list->size ++;

    return 0;
}
/*在链表的尾部插入数据*/
int list_ins_tail(List *list, const void *data)
{

    Node *new_node = (Node *)calloc(1, sizeof (Node)); //创建插入的节点
    if(new_node == NULL)
        return -1;
    new_node->data = (void *)data;//关联节点与数据

    if(list_size(list) == 0)
        list->head = new_node;
    else
        list->tail->next = new_node;

    list->tail = new_node;
    new_node->next = NULL;

    list->size ++;
    return 0;
}

/*在链表的有序插入数据*/
int list_ins_sort(List *list, const void *data)
{
    Node *new_node = (Node *)calloc(1, sizeof (Node)); //创建插入的节点
    if(new_node == NULL)
        return -1;
    new_node->data = (void *)data;//关联节点与数据

    if(list_size(list) == 0)//链表为空时，插入节点
    {
        list->tail = new_node;
        new_node->next = NULL;
        list->head = new_node;
    }
    else//链表非空时
    {
        Node *p_cur = list->head;
        Node *p_pre = list->head;

        while(p_cur != NULL && list->match(new_node->data, p_cur->data) > 0)//查找链表的插入位置
        {
            p_pre = p_cur;
            p_cur = p_cur->next;
        }
        if(p_cur != NULL)//插入位置在头部和中间时
        {
            if(p_cur == list->head)//插入位置在头部
            {
                new_node->next = list->head;
                list->head = new_node;
            }
            else//位置在链表中间
            {
                new_node->next = p_pre->next;
                p_pre->next = new_node;
            }
        }
        else//插入位置在链表尾部
        {
            list->tail->next = new_node;
            list->tail = new_node;
            new_node = NULL;
        }

    }
    list->size ++;
    return 0;
}

/*查找链表中与数据匹配的节点，并返回节点指针*/
void* list_search(List *list, const void *data)
{
    if(list_size(list) == 0)
    {
        printf("list is empty\n");
        return NULL;
    }
    else
    {
        Node *p_cur = list->head;
        
        while(p_cur != NULL && list->match(p_cur->data, data) != 0)//查找数据在链表中的位置
        {
            p_cur = p_cur->next;
        }
        return p_cur;
    }

}
/*删除指定数据的节点*/
void* list_remove(List *list, const void *data)
{
    void *old_data = NULL;
    Node *p_cur = list->head;
    Node *p_pre = list->head;
    while (p_cur != NULL && list->match(p_cur->data, data) !=0)
    {
        p_pre = p_cur;
        p_cur = p_cur->next;
    }
    if(p_cur != NULL && list->match(p_cur->data, data) ==0)//删除位置在头部和中间时
    {
        if(p_cur == list->head)//删除位置在头部
        {
            list->head = p_cur->next;
            if(p_cur->next == NULL)
                list->tail = NULL;

        }
        else//中部时或尾部
        {
            p_pre->next = p_cur->next;
            if(p_cur->next == NULL)
                list->tail = p_pre;
        }
        old_data = p_cur->data;
        free(p_cur);
        list->size --;
    }
    return old_data;
}
/*将链表逆置*/
void list_reverse(List *list)
{
    if(list_size(list) != 0)
    {
        Node *p_pre = list->head;
        Node *p_cur = list->head->next;
        list->head->next = NULL;
        list->tail = list->head;
        while(p_cur!= NULL)
        {
            p_pre = p_cur;
            p_cur = p_cur->next;
            p_pre->next = list->head;
            list->head = p_pre;
        }
    }
    return;
}

/*给链表排序*/
void list_sort(List *list)
{
    if(list_size(list) != 0)
    {
        Node *p_i = list->head;
        while(p_i->next != NULL)
        {
            Node *p_min = p_i;
            Node *p_j = p_min->next;
            while (p_j != NULL)
            {
                if(list->match(p_min->data, p_j->data) > 0)
                    p_min = p_j;
                p_j = p_j->next;
            }
            if(p_min != p_i)
            {
                void *data = p_i->data;
                p_i->data = p_min->data;
                p_min->data = data;
            }
            p_i = p_i->next;
        }
    }
    return;
}

/*摧毁链表*/
void list_destroy(List *list)
{
    Node *p_cur = list->head;
    while (p_cur != NULL)
    {
        list->head = list->head->next;
        list->destroy(p_cur->data);//释放节点中的数据
        free(p_cur);//释放节点
        p_cur = list->head;
    }
    memset(list, 0, sizeof (List));
    return;
}

猜您喜欢

03-26koa2框架介绍
03-26理解Golang组件protobuf
03-26五分钟学Java：一篇文章带你搞懂spring全家桶套餐
03-26spring的ioc依赖注入的三种方法(xml方式)
03-26STL篇--list容器
03-26[SQL]3.26--175+176+177+178+180+181+182
03-26学习笔记----C语言的面向对象
03-26JavaScript(8)--- 闭包
03-26CMDB_Agent版本
03-26阿里笔试题(3.23)——走迷宫
03-26轻音少女美图分享
03-26c# winform 访问WebServices （通过Http方式）
03-26理解Raft协议
03-26HTTP2.0学习与 Nginx和Tomcat配置HTTP2.0
03-26for循环与串行化、并行化Stream流性能对比
03-26使用TensorFlow进行训练识别视频图像中物体
03-26FormData/Go分片/分块文件上传
03-26Java程序员应该知道的20个有用的lib开源库