数据结构链表（单链表和双链表）

最新推荐文章于 2024-07-19 23:02:14 发布

Allen_Kao

最新推荐文章于 2024-07-19 23:02:14 发布

阅读量777

点赞数

分类专栏： C/C++ 数据结构

本文链接：https://blog.csdn.net/gsls181711/article/details/45055001

版权

C/C++ 同时被 2 个专栏收录

36 篇文章 1 订阅

订阅专栏

数据结构

6 篇文章 0 订阅

订阅专栏

什么是链表

简单的说，链表就是由多个结点离散分配，彼此通过指针相连，每个结点只有一个前驱结点和后继结点。首节点无前驱结点，为结点无后继结点的一种存储结构。

链表的结构

头结点：链表的第一个有效结点前面的结点，头结点并不存放有效数据，也就是数据域为空，加头结点的主要目的是为了方便链表的操作。

首节点：链表的第一个有效结点，结点包含数据域和指针域。

尾结点：尾结点的指针域为空。

头指针：指向头结点的指针变量，它存放了头结点的地址(在这里注意一下，指针变量存放的是地址，也就是说头指针存放的是头结点的地址,一般通过头指针对链表进行操作)。

具体实现

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
//定义链表节点
typedef struct Node
{
int data; //数据域
struct Node * pNext; //指针域
}NODE, * PNODE; //NODE等价于struct Node, PNODE等价于struct Node *

//函数声明
PNODE createLinkList(void);        //创建链表的函数
void traverseLinkList(PNODE pHead);      //遍历链表的函数
bool isEmpty(PNODE pHead);        //判断链表是否为空的函数
int getLength(PNODE pHead);        //获取链表长度的函数
bool insertElement(PNODE pHead, int pos, int val);  //向链表中插入元素的函数，三个参数依次为链表头结点、要插入元素的位置和要插入元素的值
bool deleteElement(PNODE pHead, int pos, int * pVal); //从链表中删除元素的函数，三个参数依次为链表头结点、要删除的元素的位置和删除的元素的值
void sort(PNODE pHead);         //对链表中的元素进行排序的函数(基于冒泡排序)
int main(void)
{
int val;     //用于保存删除的元素
PNODE pHead = NULL;   //PNODE等价于struct Node *
pHead = createLinkList(); //创建一个非循环单链表，并将该链表的头结点地址赋给pHead
traverseLinkList(pHead); //调用遍历链表的函数
if(isEmpty(pHead))
  printf("链表为空！\n");
else
  printf("链表不为空！\n");
printf("链表的长度为：%d\n", getLength(pHead));
//调用冒泡排序函数
sort(pHead);
//重新遍历
traverseLinkList(pHead);
//向链表中指定位置处插入一个元素
if(insertElement(pHead, 4, 30))
  printf("插入成功!插入的元素为：%d\n", 30);
else
  printf("插入失败!\n");
//重新遍历链表
traverseLinkList(pHead);
//删除元素测试
if(deleteElement(pHead, 3, &val))
  printf("元素删除成功!删除的元素是：%d\n", val);
else
  printf("元素删除失败!\n");

traverseLinkList(pHead);
system("pause");
return 0;
}

PNODE createLinkList(void)
{
int length;  //有效结点的长度
int i;
int value;  //用来存放用户输入的结点的值
//创建了一个不存放有效数据的头结点
PNODE pHead = (PNODE)malloc(sizeof(NODE));
if(NULL == pHead)
{
  printf("内存分配失败，程序退出！\n");
  exit(-1);
}
PNODE pTail = pHead; //pTail始终指向尾结点
pTail->pNext = NULL; //清空指针域
printf("请输入您想要创建链表结点的个数：len = ");
scanf("%d", &length);
for(i=0;i<length;i++)
{
  printf("请输入第%d个结点的值：", i+1);
  scanf("%d", &value);
  PNODE pNew = (PNODE)malloc(sizeof(NODE));
  if(NULL == pHead)
  {
   printf("内存分配失败，程序退出！\n");
   exit(-1);
  }
  pNew->data = value;  //向新结点中放入值
  pTail->pNext = pNew; //将尾结点指向新结点
  pNew->pNext = NULL;  //将新结点的指针域清空
  pTail = pNew;   //将新结点赋给pTail,使pTail始终指向为尾结点
}
return pHead;
}

void traverseLinkList(PNODE pHead)
{
PNODE p = pHead->pNext;
while(NULL != p)
{
  printf("%d  ", p->data);
  p = p->pNext;
}
printf("\n");
return;
}

bool isEmpty(PNODE pHead)
{
if(NULL == pHead->pNext)
  return true;
else
  return false;
}

int getLength(PNODE pHead)
{
PNODE p = pHead->pNext;   //指向首节点
int len = 0;     //记录链表长度的变量
while(NULL != p)
{
  len++;
  p = p->pNext;    //p指向下一结点
}
return len;
}

void sort(PNODE pHead)
{
int len = getLength(pHead);  //获取链表长度
int i, j, t;     //用于交换元素值的中间变量
PNODE p, q;      //用于比较的两个中间指针变量
for(i=0,p=pHead->pNext ; i<len-1 ; i++,p=p->pNext)
{
  for(j=i+1,q=p->pNext;j<len;j++,q=q->pNext)
  {
   if(p->data > q->data)
   {
    t = p->data;
    p->data = q->data;
    q->data = t;
   }
  }
}
return;
}

bool insertElement(PNODE pHead, int pos, int val)
{
int i = 0;
PNODE p = pHead;
//判断p是否为空并且使p最终指向pos位置的结点
while(NULL!=p && i<pos-1)
{
  p = p->pNext;
  i++;
}
if(NULL==p || i>pos-1)
  return false;
//创建一个新结点
PNODE pNew = (PNODE)malloc(sizeof(NODE));
if(NULL == pNew)
{
  printf("内存分配失败，程序退出!\n");
  exit(-1);
}
pNew->data = val;
//定义一个临时结点，指向当前p的下一结点
PNODE q = p->pNext;
//将p指向新结点
p->pNext = pNew;
//将q指向之前p指向的结点
pNew->pNext = q;
return true;
}

bool deleteElement(PNODE pHead, int pos, int * pVal)
{
int i = 0;
PNODE p = pHead;
//判断p是否为空并且使p最终指向pos结点
while(NULL!=p->pNext && i<pos-1)
{
  p = p->pNext;
  i++;
}
if(NULL==p->pNext || i>pos-1)
  return false;
//保存要删除的结点
* pVal = p->pNext->data;
//删除p后面的结点
PNODE q = p->pNext;
p->pNext = p->pNext->pNext;
free(q);
q = NULL;
  return true;
}

结尾语

上面实现的主要是单链表，另外还有双链表、循环链表、非循环链表等其他几种常见链表。双链表的特殊性表现在每个基本结点有两个指针域；循环链表的特性主要表现在，在循环链表中，通过任何一个结点可以找到其他所有结点。

网上很多对双向链表解释的文章都是用这个结构：

它们的连接情况是这样的：

相当的不直观，今天我要从详细的地址出发来解释双向链表的原理。

现定义一个结构体如下：

struct student

{char name;

struct student *next;

struct student *prior;

};

现在有5个人A,B,C,D,E.这五个人构成的链表如下：

虚线部分为地址值，这个是为了描述方便随便写的值，在创建上述的链表时其实不用关心地址值到底是多少，这些地址都会放到某个变量当中，只要对变量进行赋值传递就能实现链表的构建。这里完全是为了分析才这么写的。从图中很容易看出蓝色的箭头组成了一个单链表，红色的箭头又组成了一个单链表（逆向的）。

下面将分析链表的前插与删除的例子，理解了这两个功能，其他的功能都能自己分析出来了。

双链表的前插，下面这是代码和代码分析。

void InsertBefore(student *p,char x)
      {//在带头结点的双链表中，将值为x的新结点插入*p之前，设p≠NULL
        student *s=malloc(sizeof(student)); //申请一段内存空间，指针指向首地址0x0600
        s->name=x; //定义name为G
        s->prior=p->prior; // p->prior表示0x0500，将它赋给s->prior表示s->prior里面的值是0x0500，从而指向0x0500这个地址即q，如紫线
        s->next=p; //p是0x0700，将它赋给s->next，s->next中的值为0x0700，也即s->next指向了p，如绿色线
        p->prior->next=s; // p->prior 是0x0500，即指针q所指，所以p->prior->next相当于没插入s之前的0x0700，插入s后，将s的首地址即0x0600赋给这个位置，所以此时，由q 到p的蓝线断裂，这个蓝线目标变成了s，如黑线所示，此时q->next值为0x0600，图上没有改过来。
        p->prior=s; //同理，p->prior也指向了s，即p->prior中0x0500变成了0x0600（图上没有改过来），红线断裂。变成墨绿色线。至此前插完成。
       }

下面再分析删除，删除比较简单，代码如下：

void DeleteNode(student *p)
      {//在带头结点的双链表中，删除结点*p，设*p为非终端结点
          p->prior->next=p->next;// 将p->next即0x0700送到q->next中，即0x0500被替换成了0x0700（图中没改过来），如紫线。
          p->next->prior=p->prior;// p->prior为0x0300送到了s->prior即原本是0x0500的地方（图中没改过来），如绿线。
          free(p);//将p内存释放，同时将之前的四根红蓝线全部断裂，至此完成删除任务。