链表常用操作

链表基本操作

头文件  linklist.h

//头文件

#ifndef _LIST_H
#define _LIST_H

#define SUCCESS　10000
#define FAILURE 10001
#define TURE 10002
#define FALSE 10003

typedef int ET;
struct Note
{
    ET *data;
    struct Note *next;
}

typedef struct Note note;

int listInit(note **l); //初始化
int listInsert(note *l,int n,ET e); //插入
int listtraverse(note l,void (*p)(ET)); 遍历链表，并打印
int listlength(note *l);  //求链表长度
int listEmpty(note *l);  //看链表是否为空
int GetElem(note *l,int p,ET *e); //查找p位置的元素，并把找到的元素保存在e中
int locateElem(note *l,ET e，int (*p)(ET,ET)); //确定元素e的位置
int listDelete(note *l,int p,ET *e); //删除位置p的元素，并将值保存在e中
int listClear(note *l);  //清空链表
int listDestroy(note **l); //销毁
int listReverse(note *l);  //链表逆序

#endif

 

子函数文件 list.c

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

int listInit(note **l) //初始化
{
    l = (note *)malloc(sizeof(note)*1);
    if(NULL == *l)
    {
        return FAILURE;
    }
    (*l)->next = NULL;
    return SUCCESS;
}

int listIsert(note *l,int n,ET e)   //插入
{
    note *p = l;
    if(NULL == l)
    {
        return FAILURE;
    }
    while(k < n && p != NULL)
    {
        p = p->next;
        k++;
    }
    if(k > n && p == NULL)
    {
        return FAILURE;
    }
    note *q = (note *)malloc(sizeof(note)*1);
    if(NULL ==q)
    {
        return FAILURE;
    }
    q->data = e;
    q->next = p->next;
    p->next = q;

    return SUCCESS;
}

int listtraverse(note *l,void (*p)(ET))  //遍历链表，并打印
{
    if(NULL == l)
    {
        return FAILURE;
    }
    note *q = l->next;

    while(q)
    {
        p(q->data);
        q = q->next;
    }
    return SUCCESS;
}

int listlength(note *l)  //求长度
{
    if(NULL == l)
    {
        return FAILURE;
    }
    int len = 0;
    note *p = l->next;
    while(p)
    {
        len++;
        p = p->next;
    }
    return SUCCESS;
}

int listEmpty(note *l)  //判断是否为空
{
    return (l->next == NULL)? TURE:FALSE;
}

int GetElem(note *l,int p,ET *e) //查找p位置的元素，并放在e中
{
    if(NULL == l)
    {
        return FAILURE;
    }
    note *q = l;
    int i;
    for(i = 0; i < p; i++)
    {
        q = q->next;
    }
    if(!q)
    {
        return FAILURE;
    }
    *e = q->data;
    return SUCCESS;
}

int locateElem(note *l,ET e,int (*p)(ET,ET)) //查找节点的位置
{
    if(NULL == l)
    {
        return FAILURE;
    }
    note *q = l->next;
    int len = 1;
    while(q)
    {
      if(p(e,q->data) == TURE)
         {
             return len;
         }
         q = q->next;
         len++;
     }
     return FAILURE;
}

int listDelete(note *l,int p,ET *e)  //删除指定位置的节点
{ 
    int k = 1;
    note *q=l;
    if(NULL == l)
    {
        return FAILURE;
    }
 
    while(k < p && q != NULL)
    {
        q = q->next;
        k++;
    }
   if(k > p || q == NULL)
   {
       return FAILURE;
    }
    note *n = q->next;
    *e = n->data;
    q->next = n->next;
    free(n);

    return SUCCESS;
}

int listClear(note *l)  //清空
{
    if(NULL == l)
    {
        return FAILURE;
    }
    note *p = l->next;
    while(p)
    {
       l->next = p->next;
       free(p);
       p = l->next;
    }
    return SUCCESS;
}

int listDestroy(note **l) //销毁
{
    if(l == NULL)
    {
        return FAILURE;
    }
    free(*l);
    *l = NULL;
    return SUCCESS;
}

int listReverse(note *l)  //链表逆序
{
    if(l == NULL)
    {
        return FAILURE;
    }
    note *p = l->next;
    l->next = NULL;
    while(p != NULL)
    {
        note *q = p;
        p = p->next;
        q->next = l->next;
        l->next = q;
    }
    return SUCCESS;
}

主函数 testlist.c

#include"linklist.h"
#include<stdio.h>
#include<time.h>

void print(ElemType e)
{
    printf("%d ",e);
}

int equal(ElemType e1,ElemType e2)
{
    return (e1 == e2)? TURE : FALSE;
}

int main()
{
    int ret,i;
    note *first = NULL;
    srand(time(NULL));

    ret = listInit(&first); //初始化
    if(ret == FAILURE)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init SUCCESS!\n");
    }
 
    for(i = 0; i < 10; i++)
    {
        ret = listInsert(first,i+1,rand() % 20); //插入10个随机值
        if(ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

    ret = listtraverse(first,print);  //遍历链表，并打印
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    ret = listReverse(first);  //逆序
    if(ret == FAILURE)
    {
        printf("Reverse Failure!\n");
    }
    else
    {
        printf("Reverse Success!\n");
    }

    ret = listtraverse(first,print);  //遍历链表，并打印
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }
 
    ret = listlength(first);  //求长度
    if(ret == FAILURE)
    {
        printf("Get length Failure!\n");
    }
    else
    {
        printf("length %d\n",ret);
    }
 
    ret = listEmpty(first);  //判断是否为空
    if(ret == TURE)
    {
        printf("List is empty!\n");
    }
    else if(ret == FALSE)
    {
        printf("List is not empty!\n");
    }

    int p = 3;
    ElemType e;
    ret = GetElem(first,p,&e);  //查找p位置的元素，把值放到e中
    if(ret == FAILURE)
    {
        printf("Get element Failure!\n");
    }
    else
    {
        printf("The %dth element is %d\n",p,e);
    }

    ret = locateElem(first,e,equal);  //查找e的位置
    if(ret == FAILURE)
    {
        printf("%d not exist!\n");
    }
    else
    {
        printf("%d is %dth element!\n",e,ret);
    }

    p = 3;
    ret = listDelete(first,p,&e);  //删除p位置节点，把值保存在e中
    if(FAILURE == ret)
    {       
        printf("Delete Failure!\n");
    }
    else
    {
        printf("Delete %d Success!\n",e);
    }

    ret = listtraverse(first,print); //遍历链表，并打印
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    ret = listClear(first);  //清空
    if(ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("Clear Failure!\n");
    }

    ret = listtraverse(first,print);  //遍历链表，并打印
    if(ret == FAILURE)
    {
       printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    ret = listDestroy(&first); //销毁
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }
 
    return 0;
}