双向链表

最新推荐文章于 2024-10-31 19:10:01 发布

yanghope

最新推荐文章于 2024-10-31 19:10:01 发布

阅读量457

点赞数

分类专栏：汇编、C/C++ 文章标签： null search struct 数据结构 insert list

本文链接：https://blog.csdn.net/yanghope/article/details/5648725

版权

汇编、C/C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

最近时间比较宽裕，所以就封装了一个双向链表，其中包含了栈，和队列的机制，对链表的删除，查找，添加操作都以函数定位，和数字序号定位两种定位方式实现，所有的函数都经过我的测试(估计还会用不妥的地方)，分享给大家，以后用到链式存储的数据结构时，拿来就用就行啦，下面是数据类型，函数声明，定义的代码，（测试函数不再提供）：

函数头文件dlist.h

#ifndef _LIST_H_
#define _LIST_H_

/*定义bool型变量*/
typedef enum{false,true} bool;

/*定义结点成员*/
typedef struct data{
int age;
char name[10];
}Item;

/*定义构造双向链表的结点*/
typedef struct node{
Item item;
struct node * pre;
struct node * next;
}Node;

/*定义指向结点的指针*/
typedef Node * pNode;

/*定义头结点，记录链表头结点，尾结点的地址，及链表结点数*/
typedef struct head{
int nodenum;
Node * head;
Node * trail;
}Head;

/*
功能：初始化头结点
参数：指向头结点的指针
返回值类型：void
*/
void InitlizeList(Head * phead);

/*
功能：返回链表的成员数量
参数：指向头结点的指针
返回值类型：int
*/
int ListCount(const Head * phead);

/*
功能：判断链表是否为空
参数：指向头结点的指针
返回值类型：bool
*/
bool IsEmpty(const Head * phead);

/*
功能：将新结点追加到最后
参数：指向头结点指针，Item
返回值：bool
*/
bool PushStack(Head * phead,Item item);

/*
功能：出栈
参数：指向头结点的指针
返回值：出栈的元素
*/
bool PopStack(Head * phead,Item * pitem);

/*
功能：入队列
参数：指向头结点的指针，指向数据的指针
返回值：bool
*/
bool EnQueue(Head * phead,Item item);

/*
功能：出队列
参数：指向头结点的指针,指向数据的指针
返回值：bool
*/
bool OutQueue(Head * phead,Item * pitem);

/*
功能：结构体赋值
参数：指向结点的指针，Item
返回值：void
*/
void CopyToNode(Node * pnode,Item item);

/*
功能：将出栈或出队列的数据赋值给指定的item
参数：要出栈或出队列的指针
返回值：void
*/
void CopyToItem(Node * pnode,Item * pitem);

/*
功能：删除一个结点
参数：指向头结点的指针，指向该结点的指针
返回值：bool
*/
bool DelTheNode(Head * phead,Node * pnode);

/*
功能：遍历链表
参数：指向头结点的指针，判断是否符合条件的函数指针
返回值：指向符合条件的结点的指针
*/
Node * Search(Head * phead,bool (*)(Item item));

/*
功能：找到第n个元素的头结点
参数：指向头结点的指针，n
返回值：指向该结点的指针
*/
Node * Find(Head * phead,int n);

/*
功能：删除符合条件的结点
参数：指向头结点的指针，判断是否符合条件的函数指针
返回值：bool
*/
bool DelOne(Head * phead,bool (*)(Item item));

/*
功能：删除指定位置的结点
参数：指向头结点的指针
返回值：bool
*/
bool DelAppointedOne(Head * phead,int n);

/*
功能：添加一个item到链表
参数：指向头结点的指针，item，n
返回值：bool
*/
bool InsertOne(Head * phead,Item item,int n);

/*
功能：添加一个结点到指定位置
参数：指向该位置前一个结点的指针，新成员Item
返回值：bool
*/
bool InsertTheOne(Head * phead,Node * pnode,Item item);

/*
功能：制造一个新节点
参数：Item
返回值：指向新节点的指针
*/
Node * MakeNewNode(Item item);

/*
功能：遍历整个链表，对每个成员进行处理
参数：指向头结点的指针，用户自定义的函数指针
返回值：void
*/
void Traverse(Head * phead,void (*)(Item item));

/*
功能：释放所有结点
参数：指向头结点的指针
返回值：void
*/
void DelAll(Head * phead);

/*
功能：销毁链表
参数：指向头结点的指针
返回值：void
*/
void DestroyList(Head * phead);

#endif

下面是函数实现部分dlist.c

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

void InitlizeList(Head * phead)
{
phead ->nodenum = 0;
phead ->head = NULL;
phead ->trail = NULL;
}

int ListCount(const Head * phead)
{
return phead ->nodenum;
}

bool IsEmpty(const Head * phead)
{
if(phead ->nodenum == 0)
return true;
return false;
}

bool PushStack(Head * phead,Item item)
{
Node * pnew;
pnew = MakeNewNode(item);
if(pnew == NULL)
  return false;
if(phead ->nodenum == 0)
{
  phead ->head = pnew;
  phead ->trail = pnew;
  phead ->nodenum++;
  return true;
}
phead ->trail ->next = pnew;
pnew ->pre = phead ->trail;
phead ->trail = pnew;

phead ->nodenum++;
return true;
}

bool PopStack(Head * phead,Item * pitem)
{
if(phead ->nodenum == 0)
  return false;
CopyToItem(phead ->trail,pitem);
phead ->trail = phead ->trail ->pre;

if(phead ->trail == NULL)
{
  free(phead ->head);
  phead ->head = NULL;
}
else
{
  free(phead ->trail ->next);
  phead ->trail ->next = NULL;
}
phead ->nodenum--;
return true;
}

bool EnQueue(Head * phead,Item item)
{
return PushStack(phead,item);
}

bool OutQueue(Head * phead,Item * pitem)
{
Node * temp = phead ->head;

if(phead ->nodenum == 0)
  return false;
CopyToItem(phead ->head,pitem);
if(phead ->nodenum == 1)
{
  phead ->head = NULL;
  phead ->trail = NULL;
}
else
{
  phead ->head = phead ->head ->next;
phead ->head ->pre = NULL;
}
free(temp);
phead ->nodenum--;
return true;
}

void CopyToNode(Node * pnode,Item item)
{
pnode ->item = item;
}

void CopyToItem(Node * pnode,Item * pitem)
{
*pitem = pnode ->item;
}

bool DelTheNode(Head * phead,Node * pnode)
{
Item item;
// phead ->nodenum--;

if(pnode ->next == NULL)
{
  PopStack(phead,&item);
  return true;
}
if(pnode ->pre == NULL)
{
  OutQueue(phead,&item);
  return true;
}
pnode ->pre ->next = pnode ->next;
pnode ->next ->pre = pnode ->pre;
phead ->nodenum--;
free(pnode);
return true;
}

Node * Search(Head * phead,bool (* pfun)(Item item))
{
Node * pt;
pt = phead ->head;

while(pt)
{
  if(pfun(pt ->item))
   return pt;
  pt = pt ->next;
}
return NULL;
}

Node * Find(Head * phead,int n)
{
Node * ptemp;
Node * pt = phead ->head;
int i = 1;

if(n == 1)
  return pt;
while(pt && (i != n))
{
  pt = pt ->next;
  i++;
}
return pt;
}

bool DelOne(Head * phead,bool(* pfun)(Item item))
{
Node * pt;

pt = Search(phead,pfun);
if(pt)
return DelTheNode(phead,pt);
}

bool DelAppointedOne(Head * phead,int n)
{

Node * pt;

if(phead ->nodenum < n || n <= 0)
{
printf("Sorry!The one is not exist!");
return false;
}
pt = Find(phead,n);
return DelTheNode(phead,pt);
}

bool InsertOne(Head * phead,Item item,int n)
{
Node * pt;
Node * pnode;
int i = 1;
if(n <= 0 || n > phead ->nodenum + 1)
{
  printf("The serial number is too large or too small,we can't insert to this place.");
  return false;
}
pt = MakeNewNode(item);

pnode = phead ->head;

if(pnode == NULL && n == 1)
{
  phead ->head = pt;
  phead ->trail = pt;
  phead ->nodenum++;
  return true;
}
else if(n == 1)
{
  pt ->next= pnode;
  pnode ->pre = pt;
  phead ->head = pt;
  phead ->nodenum++;
  return true;
}
else
{
  while(pnode && i != n)
  {
   pnode = pnode ->next;
   i++;
  }
  if(pnode == NULL && i != n)
   return false;
  else if(pnode == NULL && i == n)
  {
   phead ->trail ->next = pt;
   pt ->pre = phead ->trail;
   phead ->trail = pt;
   phead ->nodenum++;
   return true;
  }
  else
  {
   pnode ->pre ->next = pt;
   pt ->pre = pnode ->pre;
   pt ->next = pnode;
   pnode ->pre = pt;
   phead ->nodenum++;
   return true;
  }

}
}

/*
bool InsertTheOne(Head * phead,Node * pnode,Item item)
{
Node * ptemp;
ptemp = MakeNewNode(item);

if(pnode == NULL)
{
  phead ->head = ptemp;
  phead ->trail = ptemp;
}
else if(pnode ->next == NULL)
{
  phead ->trail ->next = ptemp;
  phead ->trail = ptemp;
}
else if(pnode ->pre == NULL)
{

}
}
*/

Node * MakeNewNode(Item item)
{
Node * pt;
pt = (Node *)malloc(sizeof(Node));
CopyToNode(pt,item);

pt ->pre = NULL;
pt ->next = NULL;

return pt;
}

void Traverse(Head * phead,void (* pfun)(Item item))
{
Node * pt;
pt = phead ->head;
while(pt)
{
pfun(pt ->item);
pt = pt ->next;
}
}

void DelAll(Head * phead)
{
Node * pt,* ptemp;
pt = phead ->head;

while(pt)
{
  ptemp = pt ->next;
  free(pt);
  pt = ptemp;
  phead ->nodenum--;
}
}

void DestroyList(Head * phead)
{
DelAll(phead);
free(phead);
}