数据结构之链表

1：有头节点、单向、不循环链表

对于这种有头节点的单向不循环链表插入数据如下图：

1)头部插入

 

2)尾部插入

代码如下 :

  #include "stdafx.h"
  #include<iostream>
  
  using namespace std;
  
  typedef int DATA;
  typedef struct node* LIST;
  
  struct node
  {
      DATA data;
      struct node* next; //指向下一个节点的指针
  };
  
  //创建头节点
  LIST ListCreate()
  {
      struct node* head = (struct node*) malloc(sizeof(*head));
      if (head == NULL)
      {
          return NULL;
      }
      //这个时候只有头节点，head->next = null;数据为空
      head->next = NULL;
      //返回指向头节点的头指针
      return head; 
  }
  
  //判断一个链表是否是空链表
  int ListIsEmpty( LIST l)
  {
      return l->next == NULL;
  }
  
  //判断是不是链表的最后一个元素
  int ListIsLast(LIST l, struct node* p)
  {
      return p->next == NULL;
  }
  
  //插入链表元素 其实这个地方主要分为尾部插入，还是头部插入
  int ListInsert(LIST l, struct node* prev,const DATA *data ) 
  {
      struct node* cur = (struct node*)malloc(sizeof(*cur));
      if (cur == NULL)
      {
          return -1;
      }
      cur->data = *data;
      cur->next = prev->next;
      prev->next = cur;
      return 0;
  }
  
  int ListInsertHead(LIST l, const DATA* data)
  {
      return ListInsert(l,l,data);
  }
  
  int ListInsertTail( LIST l, const DATA* data )
  {
      struct node* tail = l;
      for (; tail->next != NULL; tail = tail->next); //空循环，找到尾节点
      return ListInsert(l,tail,data);
  }
  
  //查找
  struct node* ListFind(LIST l,const DATA* data )
  {
      struct node* p = l->next; //要考虑到空链表的情况就是p != null 从头节点的next开始查找，是因为头节点是不存放数据的，所以从头节点开始查找是没有意义的。
      for (; p != NULL && p->data != *data; p = p->next);
      return p;
  }
  
  //查找前驱节点
  struct node* ListFindPrev(LIST l, const DATA* data)
  {
      struct node* p = l; //查找前驱的话不能再指向头节点的下一个节点了，如果是一个空链表的话，就没有意义了，
  
      for (;p->next != NULL && p->next->data != *data; p = p->next);
  
      return p;
  }
  
  //删除链表元素
  int ListDelete(LIST l, const DATA* data)
  {
      //头节点是不能删除的
      struct node* prev = ListFindPrev(l,data); //这里就能处理到找不到或者是头节点的情况
      if (!ListIsLast(l, prev)) 
      {
          struct node *q = prev->next; //即q就是要删除的元素；
          prev->next = q->next;
          free(q);
          return 0;
      }
      return -1;
  }
  
 //打印列表
 void ListDisplay(LIST l)
 {
     struct node * p = l->next;
     while (p != NULL )
     {
         printf("%d  ", p->data);
         p = p->next;
     }
     printf("
");
 }
 
 //销毁链表
 void ListDispose(LIST l)
 {
     struct node *p = l->next;
     struct node* q;
     while (p != NULL)
     {
         q = p;
         p = p->next;
         free(q);
     }
 
     free(l);
 }
 
 int main()
 {
     int i;
     DATA x;
 
     LIST head = ListCreate();
     if (head == NULL)
         return -1;
 
     //插入
     for (i = 0; i < 6; i++)
     {
         x = i + 1;
         //ListInsertHead(head,&x);
         ListInsertTail(head,&x);
     }
     printf("链表里面的元素:: ");
     ListDisplay(head);
 
     printf("从链表里面查找元素3
");
     DATA y = 3;
     //查找
     struct node* p = ListFind(head,&y);
     if (p == NULL)
         printf("not find!!!
");
     else
         printf("data = %d
", p->data);
 
     printf("从链表里面删除元素3
");
     ListDelete(head,&y);
     ListDisplay(head);
 
     //
     printf("销毁链表
");
     ListDispose(head);
     system("pause");
 
     return 0;
 }

 2:有头节点、单向、循环链表

 1):头部插入

2)尾部插入

代码如下：

// test04.cpp : Defines the entry point for the console application.
//有头节点、单向、循环链表

#include "stdafx.h"
#include<iostream>

using namespace std;

struct node;
typedef int DATA;
typedef struct node* LIST;

struct node
{
    DATA data;
    struct node* next;
};

//创建头节点
LIST ListCreate()
{
    LIST head = (struct node*)malloc(sizeof(*head));
    if ( head == NULL )
    {
        return NULL;
    }

    head->next = head;

    return head;
}

//插入
int ListInsert( LIST l, struct node* position, const DATA* data )
{
    struct node* cur = (struct node*)malloc(sizeof(*cur));
    if ( cur == NULL )
    {
        return 0;
    }
    cur->data = *data;
    cur->next = position->next;
    position->next = cur;

    return 0;
}

//头部插入
int ListHeadInsert(LIST l, const DATA* data)
{
    return ListInsert(l,l,data);
}

//尾部插入
int ListTailHead(LIST l, const DATA* data )
{
    struct node* tail = l;
    for (; tail->next != l; tail = tail->next);
    return ListInsert(l,tail,data);
}

//查找
struct node* ListFind( LIST l, const DATA* data )
{
    struct node* p = l->next;
    for (; p != l && p->data != *data; p = p->next);
    return p;
}

struct node* ListFindPrev(LIST l, const DATA* data)
{
    struct node* p = l;
    for (; p->next != l && p->next->data != *data; p = p->next);
    return p;
}
//删除
int ListDelete( LIST l, const DATA* data )
{
    struct node* prev = ListFindPrev( l, data );
    if ( prev != l) //不是头节点
    {
        struct node* q = prev->next;
        prev->next = q->next;
        free(q);
    }
    return 0;
}

//打印出来列表
void ListDisplay(LIST l)
{
    struct node* p = l->next;
    while (p != l)
    {
        printf("%d  ",p->data);
        p = p->next;
    }
    printf("
");
}

//消耗链表
void ListDispose(LIST l)
{
    struct node* p = l->next;
    struct node* q;
    while (p != l)
    {
        q = p;
        p = p->next;
        free(q);
    }
    free(l);
}

int main()
{
    int i;
    DATA x;
    LIST head = NULL;
    head = ListCreate();
    if (head == NULL)
    {
        return 0;
    }

    for (i = 0; i < 6; i++)
    {
        x = i + 1;
        //ListHeadInsert(head,&x);
        ListTailHead(head,&x);
    }
    //
    printf("打印链表::
");
    ListDisplay(head);

    DATA y = 3;
    struct node* p = ListFind(head,&y);
    if (p == NULL)
        printf("not find!!!!");
    else
        printf("找到元素%d
", p->data);

    //删除元素
    printf("删除元素之前，删除的元素是3
");
    ListDelete(head,&y);
    printf("删除元素之后
");
    ListDisplay(head);

    ListDispose(head);

    system("pause");
    return 0;
}

输出如下:

3:有头节点、双向、循环链表

1):头部插入

2):尾部插入

代码如下：

// test02.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include<iostream>

using namespace std;

typedef struct headnode* LIST;

typedef void print_s(const void*);
typedef int cmp(const void*, const void*);

#define HEADINSERT 1
#define TAILINSERT 2
#define NAMESIZE 24
//有头节点、双向、循环链表
typedef struct stuinfo
{
    int id;
    char name[NAMESIZE];
    int math;
} DATA;

struct listnode
{
    void* data;
    struct listnode* prev;
    struct listnode* next;
};
struct headnode
{
    int size;  //指向下面要插入数据的大小
    struct listnode head; //指向下一个节点的指针
};

//创建头节点
LIST ListCreate( int size )
{
    LIST handle = (struct headnode*)malloc(sizeof(*handle));
    if (handle == NULL)
    {
        return NULL;
    }
    handle->size = size;
    handle->head.data = NULL;
    handle->head.prev = handle->head.next = &handle->head;

    return handle;
}

//插入链表元素 其实这个地方主要分为尾部插入，还是头部插入
int ListInsert( LIST l,const void *data, int mode ) 
{
    struct listnode* cur = (struct listnode*)malloc(sizeof(*cur));
    if (cur == NULL)
    {
        return -1;
    }
    cur->data = malloc(l->size);
    if (cur->data == NULL)
    {
        free(cur);
        return -1;
    }
    memcpy(cur->data,data,l->size);
    if (mode == HEADINSERT) //首部插入
    {
        cur->prev = &l->head;
        cur->next = l->head.next;
        /////
        //cur->prev->next = cur;
        //cur->next->prev = cur;
    }
    else if (mode == TAILINSERT)
    {
        cur->next = &l->head;
        cur->prev = l->head.prev;
        ///////
        //cur->prev->next = cur;
        //cur->next->prev = cur; //可以把相同的两句话提取出来
    }
    else
    {
        free(cur->data);
        free(cur);
        return -1;
    }
    cur->prev->next = cur;
    cur->next->prev = cur;

    return 0;
}


//查找
struct listnode* ListFind(LIST l,const void* key,cmp* funp)
{
    struct listnode* p = l->head.next; //
    for (; p != &l->head && funp(key, p->data); p = p->next);

    return p;
}

//找到指定的元素
void* listfind(LIST l, const void* key, cmp* funp)
{
    return ListFind(l,key,funp)->data;
}

//删除链表元素
int ListDelete(LIST l, const void* key, cmp* funp )
{
    //找到指定的元素删除
    struct listnode* p = ListFind(l,key,funp);
    if ( p == &l->head ) //头节点不会删除掉
    {
        return 0;
    }

    p->prev->next = p->next;
    p->next->prev = p->prev;

    free(p->data);
    free(p);

    return 0;
}

//打印链表
void ListDisplay(LIST l, print_s* funp )
{
    struct listnode* p = l->head.next;
    while (p != &l->head)
    {
        funp(p->data);
        p = p->next;
    }
}

//销毁链表
void ListDispose( LIST l )
{
    struct listnode* p = l->head.next;
    struct listnode* q;

    while (p != &l->head)
    {
        q = p;
        p = p->next;

        free(q->data);
        free(q);
    }
    free(l);
}

static int IdCmp(const void* key, const void* data)
{
    const int *id = (const int*)key;
    const DATA* stup = (const DATA*)data;

    return (*id - stup->id);
}

static int NameCmp(const void* key, const void* data )
{
    const char* name = (const char*)key;
    const DATA* stup = (const DATA*)data;

    return strcmp(name,stup->name);
}

static void print(const void* data)
{
    const DATA* stup = (const DATA*)data;
    printf(" id::%d    name::%s   math::%d
",stup->id, stup->name, stup->math);

}

int main()
{
    int i;
    int id = 5;
    char name[NAMESIZE] = "stu3";
    DATA stu;

    LIST handle = NULL;
    handle = ListCreate(sizeof(DATA));
    if (handle == NULL )
        return 0;

    for (i = 0; i < 6; i++ )
    {
        stu.id = i + 1;
        snprintf(stu.name,NAMESIZE,"stu%d",i+1);

        stu.math = 100 - i;
        ListInsert(handle,&stu,HEADINSERT);//首部插入
    }
    printf("打印整个链表
");
    ListDisplay(handle, print);

    //
    printf("从链表查找元素id=5

");
    struct listnode* stup = ListFind(handle,&id,IdCmp);
    if (stup == NULL)
        printf("not find!!!
");
    else
        print_s(stup);
    printf("
");

    //删除元素
    printf("删除元素之前，删除的元素是id=5
");
    ListDelete(handle, &id, IdCmp);
    printf("删除元素之后
");
    ListDisplay(handle,print);

    printf("删除元素之前，删除的元素是name=stu3
");
    ListDelete(handle,name,NameCmp);
    printf("删除元素之后
");
    ListDisplay(handle, print);

    ListDispose(handle);
    
    system("pause");
    return 0;
}

输出的结果为

4:有头节点、双向、不循环列表

1）头部插入

2)尾部插入

代码如下

// test02.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include<iostream>

using namespace std;

typedef struct headnode* LIST;

typedef void print_s(const void*);
typedef int cmp(const void*, const void*);

#define HEADINSERT 1
#define TAILINSERT 2
#define NAMESIZE 24
//有头节点、双向、不循环链表
typedef struct stuinfo
{
    int id;
    char name[NAMESIZE];
    int math;
} DATA;

struct listnode
{
    void* data;
    struct listnode* prev;
    struct listnode* next;
};

struct headnode
{
    int size;  //指向下面要插入数据的大小
    struct listnode head; //指向下一个节点的指针
};

//创建头节点
LIST ListCreate( int size )
{
    LIST handle = (struct headnode*)malloc(sizeof(*handle));
    if (handle == NULL)
    {
        return NULL;
    }
    handle->size = size;
    handle->head.data = NULL;
    handle->head.next = NULL;
    handle->head.prev = NULL;

    return handle;
}

//插入链表元素 其实这个地方主要分为尾部插入，还是头部插入
int ListInsert( LIST l, struct listnode* position, const void *data ) 
{
    struct listnode* cur = (struct listnode*)malloc(sizeof(*cur));
    if (cur == NULL)
    {
        return -1;
    }
    cur->data = malloc(l->size);
    if (cur->data == NULL)
    {
        free(cur);
        return -1;
    }
    memcpy(cur->data, data, l->size);
    cur->next = position->next;
    cur->prev = position;
    if(cur->next != NULL)
        cur->next->prev = cur;
    cur->prev->next = cur;

    return 0;
}

int ListHeadInsert( LIST l, const void* data )
{
    return ListInsert(l,&l->head,data);
}

int ListTailInsert(LIST l, const void* data)
{
    struct listnode* tail = &l->head;
    for (; tail->next != NULL; tail = tail->next);
    return ListInsert(l,tail,data);
}

struct listnode* ListFind(LIST l,const void* key,cmp* funp)
{
    struct listnode* p = l->head.next; //
    for (; p != NULL && funp(key, p->data); p = p->next);

    return p;
}

//找到指定的元素
void* listfind(LIST l, const void* key, cmp* funp)
{
    return ListFind(l,key,funp)->data;
}

//删除链表元素
int ListDelete(LIST l, const void* key, cmp* funp )
{
    //找到指定的元素删除
    struct listnode* p = ListFind(l,key,funp);
    if (p == NULL)
    {
        return 0;
    }
    const DATA* stup = (const DATA*)(p->data);
    cout << stup->name << endl;
    if (p->next == NULL)
    {
        p->prev->next = NULL;
    }
    else
    {
        p->prev->next = p->next;
        p->next->prev = p->prev;
    }
    free(p->data);
    free(p);
    return 0;
}

//打印链表
void ListDisplay(LIST l, print_s* funp )
{
    struct listnode* p = l->head.next;
    while ( p != NULL )
    {
        funp(p->data);
        p = p->next;
    }
}

//销毁链表
void ListDispose( LIST l )
{
    struct listnode* p = l->head.next;
    struct listnode* q;

    while (p != NULL )
    {
        q = p;
        p = p->next;

        free(q->data);
        free(q);
    }
    free(l);
}

static int IdCmp(const void* key, const void* data)
{
    const int *id = (const int*)key;
    const DATA* stup = (const DATA*)data;

    return (*id - stup->id);
}

static int NameCmp(const void* key, const void* data )
{
    const char* name = (const char*)key;
    const DATA* stup = (const DATA*)data;

    return strcmp(name,stup->name);
}

static void print(const void* data)
{
    const DATA* stup = (const DATA*)data;
    printf(" id::%d    name::%s   math::%d
",stup->id, stup->name, stup->math);

}

int main()
{
    int i;
    int id = 5;
    char name[NAMESIZE] = "stu3";
    DATA stu;

    LIST handle = NULL;
    handle = ListCreate(sizeof(DATA));
    if (handle == NULL )
        return 0;

    for (i = 0; i < 6; i++ )
    {
        stu.id = i + 1;
        snprintf(stu.name,NAMESIZE,"stu%d",i+1);

        stu.math = 100 - i;
        ListHeadInsert(handle,&stu);//首部插入
    }
    printf("打印整个链表
");
    ListDisplay(handle, print);

    //
    printf("从链表查找元素id=5

");
    struct listnode* stup = ListFind(handle,&id,IdCmp);
    if (stup == NULL)
        printf("not find!!!
");
    else
        print(stup->data);
    printf("
");

    //删除元素
    printf("删除元素之前，删除的元素是id=5
");
    ListDelete(handle, &id, IdCmp);
    
    
    printf("删除元素之后
");
    ListDisplay(handle,print);

    printf("删除元素之前，删除的元素是name=stu3
");
    ListDelete(handle,name,NameCmp);
    printf("删除元素之后
");
    ListDisplay(handle, print);

    ListDispose(handle);
    
    system("pause");
    return 0;
}

输出结果为：