数据结构-单向有头不循环链表基本实例

单向有头不循环链表

list.c

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

#include "list.h"

//创建链表：创建一个空头链表
//失败返回NULL，成功返回list指针
list *list_create()
{

    list * me ;
    me = malloc(sizeof(*me));//创建头，申请空间
    if(me == NULL)//如果申请失败，返回NULL
        return NULL;
    me->next = NULL ;
    return me ;
}
//按位置插入，一般不用
//成功返回0
int list_insert_at(list *me ,int i ,datatype *data)
{
    int j = 0 ;
    list * node = me;
    list * newnode = NULL ;
    if(i < 0 )//如果位置号是错误的
        return -1 ;
    while (( j < i ) && (node->next != NULL))//找到前驱
    {
        node = node->next ;
        j++;
    }
    if(node !=NULL)
    {
        newnode = malloc(sizeof(*newnode));
        if(newnode == NULL)
            return -2 ;
        newnode->data = *data ;
        newnode->next = node->next ;
        node->next = newnode ;
        return 0 ;
    }
    else
        return -3 ;
}
//按顺序插入
int list_order_insert(list *me,datatype *data)
{
    list *p = me ,*q;
    while(p->next && p->next->data < *data)
        p = p->next ;
    q = malloc(sizeof(*q));
    if(q == NULL)
        return -1 ;
    q->data = *data ;
    q->next = p->next ;
    p->next = q ;
    return  0 ;
}
//带位置的删除
int list_delete_at(list *me ,int i ,datatype *data)
{
    list *p = me ,*q ;
    *data = 0  ;
    int j ;
    while (j < i  && p)
    {
        p = p->next ;
        j++ ;
    }
    if(p)
    {
        q = p->next ;
        p->next = q->next ;
        *data = q->data;
        free(q);
        q = NULL;
        return 0 ;
    }
    else
        return -1 ;
}
//按照数据删除
int list_delete(list *me ,datatype *data)
{
    list *p = me , *q;
    q = malloc(sizeof(*q));
    if(q == NULL)
        return -1 ;
    while(p->next && p->next->data != *data)
        p = p->next ;
    if(p->next == NULL)
        return -2 ;
    else
    {
        q = p->next ;
        p->next = q->next ;
        free(q);
    }
    return 0 ;
}
//是否为空
int list_isempty(list *me)
{
    if(me->next == NULL)
        return 0 ;
    return 1 ;
}
//遍历链表
void list_display(list *me)
{
    list *node = me->next;//因为头没有实际用处
    if(list_isempty(me) == 0)//如果链表为空
        return ;
    while(node != NULL)
    {
        printf("%d ",node->data);
        node = node->next ;
    }
    return ;
}

//销毁链表
void list_destroy(list *me)
{
    list *node ;
    list *next ;
    for(node = me->next ;node != NULL ; node = next)
    {
        next = node->next ;
        free(node);
    }
    free(me);
    return ;
}

list.h

#ifndef LIST_H__
#define LIST_H__

typedef int datatype  ;

typedef struct node_st
{
    datatype data ;
    struct node_st *next ;
}list;

list *list_create();//创建链表
int list_insert_at(list * ,int i ,datatype *);//带位置，一般不用
int list_order_insert(list *,datatype *);//按顺序插入
int list_delete_at(list * ,int i ,datatype *);//带位置的删除
int list_delete(list * ,datatype *);//按照数据删除
int list_isempty(list *);//是否为空
void list_display(list *);//遍历链表
void list_destroy(list *);//销毁链表
#endif

main.c

/*
 *单向有头不循环链表
 */

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

#include "list.h"
int main()
{
    list *l = NULL ;
    int i ,err;
    datatype arr[]={12,2,23,1,34,45,5};
    l = list_create();
    if(l == NULL)
        exit(1);
//  printf("%d",__LINE__);
    for(i = 0 ; i <sizeof(arr)/sizeof(*arr);i++)
    {   
    //  if(list_insert_at(l,0,&arr[i]))
        if(list_order_insert(l,&arr[i]))
            exit(1);
    }   

//  list_delete(l,&arr[2]);
    datatype value ;
    err = list_delete_at(l,0,&value);
    if(err)
    {   
        exit(1);
    }   
    list_display(l);
    list_destroy(l);
    exit(0);
}

Makefile

all:main

main:main.o list.o
    $(CC) $^ -o $@

clean:
    rm *.o main -rf