【数据结构】链表

于 2019-05-06 15:23:27 发布
阅读量276 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyyyyc/article/details/89882182
版权

1.链表
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
分类：
（1）单链表、双向链表
在这里插入图片描述
（2）不带头单链表、带头链表
在这里插入图片描述
（3）单链表、循环单链表
在这里插入图片描述
（4）无头单相非循环链表、带头双向循环链表
在这里插入图片描述
2.带头节点和不带头节点的区别
带头节点和不带头节点的区别体现在清空和销毁上，不带头节点链表中，请空链表和销毁链表作用相同，而带头节点链表的清空是清空除头节点以外的所有节点，销毁则是将头节点在内的所有节点清空。
3.单链表程序
（1）链表的节点

//链表的节点
typedef struct SListNode
{
 SDataType _data;
 struct SListNode* _pNext;
}Node,*PNode;

（2）链表结构

typedef struct SList
{
 PNode _pHead;//指向链表中的第一个节点
}SList;

（3）初始化

void SListInit(SList* s)
{
 assert(s);
 s->_pHead = NULL;
}

（4）创建节点

PNode BuySListNode(SDataType data)
{
 PNode pNewNode = (PNode)malloc(sizeof(Node));
 if (NULL == pNewNode)
 {
  assert(0);
  return NULL;
 }
 pNewNode->_data = data;
 pNewNode->_pNext = NULL;
 return pNewNode;
}

（5）尾插

void SListPushBack(SList* s, SDataType data)
{
 assert(s);
 PNode pNewNode = BuySListNode(data);
 if (NULL == s->_pHead)//空链表
 {
  s->_pHead = pNewNode;
 }
 else//链表非空
 {
  //找链表中最后一个节点
  PNode pCur = s->_pHead;
  while (NULL != pCur->_pNext)
  {
   pCur = pCur->_pNext;
  }
  pCur->_pNext = pNewNode;
 }
}

（6）尾删

void SListPopBack(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)//空链表
 {
  return;
 }
 else if (s->_pHead->_pNext ==NULL)//链表只有一个节点
 {
  free(s->_pHead);
  s->_pHead = NULL;
 }
 else//链表有多个节点
 {
  PNode pPre = NULL;
  PNode pCur = s->_pHead;
  while (pCur->_pNext)
  {
   pPre = pCur;
   pCur = pCur->_pNext;
  }
  free(pCur);
  pPre->_pNext = NULL;
 }
}

（7）头插

void SListPushFront(SList* s, SDataType data)
{
 assert(s);
 PNode pNewNode = BuySListNode(data);
 pNewNode->_pNext = s->_pHead;
 s->_pHead = pNewNode;
}

（8）头删

void SListPopFront(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)
 {
  return;
 }
 else
 {
  PNode pDelNode = s->_pHead;
  s->_pHead = pDelNode->_pNext;
  free(pDelNode);
 }
}

（9）任意位置插入

void SListInsert(PNode pos, SDataType data)
{
 if (pos == NULL)
 {
  return;
 }
 else
 {
  PNode pNewNode = BuySListNode(data);
  pNewNode->_pNext = pos->_pNext;
  pos->_pNext = pNewNode;
 }
}

（10）任意位置删除

void SListErase(SList* s, PNode pos)
{
 assert(s);
 if (pos == NULL || s->_pHead == NULL)
 {
  return;
 }
 else if(s->_pHead==pos)
 {
  s->_pHead = pos->_pNext;
 }
 else
 {
  PNode pPrePos = s->_pHead;;
  while (pPrePos && pPrePos->_pNext != pos)
  {
   pPrePos = pPrePos->_pNext;
  }
  if (pPrePos)
  {
   pPrePos->_pNext = pos->_pNext;
  }
 }
 free(pos);
}

（11）查找

PNode SListFind(SList* s, SDataType data)
{
 assert(s);
 PNode pCur = s->_pHead;
 while (pCur)
 {
  if (pCur->_data == data)
  {
   return pCur;
  }
  else
  {
   pCur = pCur->_pNext;
  }
 }
 return NULL;
}

（12）节点个数

size_t SListSize(SList* s)
{
 assert(s);
 PNode pCur = s->_pHead;
 size_t count = 0;
 while (pCur)
 {
  count++;
  pCur = pCur->_pNext;
  
 }
 return count;
}

（13）判空

int SListEmpty(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)
 {
  return;
 }
}

（14）清空

void SListClear(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)
 {
  return;
 }
 s->_pHead->_pNext = NULL;
}

（15）销毁

void SListDestroy(SList* s)
{
 s->_pHead = NULL;
}

链表代码
头文件

#pragma once
typedef int SDataType;
//链表的节点
typedef struct SListNode
{
 SDataType _data;
 struct SListNode* _pNext;
}Node,*PNode;
typedef struct SList
{
 PNode _pHead;//指向链表中的第一个节点
}SList;
void SListInit(SList* s);
void SListPushBack(SList* s, SDataType data);
void SListPopBack(SList* s);
void SListPushFront(SList* s, SDataType data);
void SListPopFront(SList* s);
void SListInsert(PNode pos, SDataType data);
void SListErase(SList* s,PNode pos);
PNode SListFind(SList* s, SDataType data);
int SListSize(SList* s);
int SListEmpty(SList* s);
void SListClear(SList* s);
void SListDestroy(SList* s);
void TestSList();

源文件

#include"SList.h"
#include<stdio.h>
#include<assert.h>
#include<malloc.h>
void SListInit(SList* s)
{
 assert(s);
 s->_pHead = NULL;
}
PNode BuySListNode(SDataType data)
{
 PNode pNewNode = (PNode)malloc(sizeof(Node));
 if (NULL == pNewNode)
 {
  assert(0);
  return NULL;
 }
 pNewNode->_data = data;
 pNewNode->_pNext = NULL;
 return pNewNode;
}
void SListPushBack(SList* s, SDataType data)
{
 assert(s);
 PNode pNewNode = BuySListNode(data);
 if (NULL == s->_pHead)//空链表
 {
  s->_pHead = pNewNode;
 }
 else//链表非空
 {
  //找链表中最后一个节点
  PNode pCur = s->_pHead;
  while (NULL != pCur->_pNext)
  {
   pCur = pCur->_pNext;
  }
  pCur->_pNext = pNewNode;
 }
}
void SListPopBack(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)//空链表
 {
  return;
 }
 else if (s->_pHead->_pNext ==NULL)//链表只有一个节点
 {
  free(s->_pHead);
  s->_pHead = NULL;
 }
 else//链表有多个节点
 {
  PNode pPre = NULL;
  PNode pCur = s->_pHead;
  while (pCur->_pNext)
  {
   pPre = pCur;
   pCur = pCur->_pNext;
  }
  free(pCur);
  pPre->_pNext = NULL;
 }
}
void SListPushFront(SList* s, SDataType data)
{
 assert(s);
 PNode pNewNode = BuySListNode(data);
 pNewNode->_pNext = s->_pHead;
 s->_pHead = pNewNode;
}
void SListPopFront(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)
 {
  return;
 }
 else
 {
  PNode pDelNode = s->_pHead;
  s->_pHead = pDelNode->_pNext;
  free(pDelNode);
 }
}
void SListInsert(PNode pos, SDataType data)
{
 if (pos == NULL)
 {
  return;
 }
 else
 {
  PNode pNewNode = BuySListNode(data);
  pNewNode->_pNext = pos->_pNext;
  pos->_pNext = pNewNode;
 }
}
void SListErase(SList* s, PNode pos)
{
 assert(s);
 if (pos == NULL || s->_pHead == NULL)
 {
  return;
 }
 else if(s->_pHead==pos)
 {
  s->_pHead = pos->_pNext;
 }
 else
 {
  PNode pPrePos = s->_pHead;;
  while (pPrePos && pPrePos->_pNext != pos)
  {
   pPrePos = pPrePos->_pNext;
  }
  if (pPrePos)
  {
   pPrePos->_pNext = pos->_pNext;
  }
 }
 free(pos);
}
PNode SListFind(SList* s, SDataType data)
{
 assert(s);
 PNode pCur = s->_pHead;
 while (pCur)
 {
  if (pCur->_data == data)
  {
   return pCur;
  }
  else
  {
   pCur = pCur->_pNext;
  }
 }
 return NULL;
}
int SListSize(SList* s)
{
 assert(s);
 PNode pCur = s->_pHead;
 size_t count = 0;
 while (pCur)
 {
  count++;
  pCur = pCur->_pNext;
  
 }
 printf("size=%d", count);
 printf("\n");
 return count;
}int SListEmpty(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)
 {
  return;
 }
}void SListClear(SList* s)
{
 assert(s);
 if (s->_pHead == NULL)
 {
  return;
 }
 s->_pHead->_pNext = NULL;
}void SListDestroy(SList* s)
{
 s->_pHead = NULL;
}
void PrintSList(SList* s)
{
 assert(s);
 PNode pCur = s->_pHead;
 while (pCur)
 {
  printf("%d--->", pCur->_data);
  pCur = pCur->_pNext;
 }
 printf("NULL\n");
}
void TestSList1()
{
 SList s;
 SListInit(&s);
 SListPushBack(&s, 1);
 SListPushBack(&s, 2);
 SListPushBack(&s, 3);
 SListPushBack(&s, 4);
 SListPushBack(&s, 5);
 PrintSList(&s);
 SListPopBack(&s);
 SListPopBack(&s);
 SListPopBack(&s);
 SListPopBack(&s);
 SListPopBack(&s);
 SListPopBack(&s);
 PrintSList(&s);
}
void TestSList2()
{
 SList s;
 SListInit(&s);
 SListPushFront(&s, 1);
 SListPushFront(&s, 2);
 SListPushFront(&s, 3);
 SListPushFront(&s, 4);
 SListPushFront(&s, 5);
 PrintSList(&s);
 SListSize(&s);
 SListPopFront(&s);
 PrintSList(&s);
 SListPopFront(&s);
 SListPopFront(&s);
 SListPopFront(&s);
 SListPopFront(&s);
 SListPopFront(&s);
 SListPopFront(&s);
 PrintSList(&s);
 SListDestroy(&s);
 PrintSList(&s);
}
void TestSList()
{
 TestSList1();
 TestSList2();
}
#include"SList.h"
int main()
{
 TestSList();
 return 0;
}

在这里插入图片描述

额贼3
关注
专栏目录
轻松搞定面试中的链表题目
计算机的艺术
04-21 6万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7393134 链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。本文对链
C语言 数据结构链表的实例（十九种操作）
08-29
C语言数据结构链表的实例（十九种操作） 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。今天，我们将讨论C语言中的数据结构链表...
链表
北望花村
03-12 546
一、测试链表程序 介绍如何创建，打印，删除链表程序。 #include&lt;iostream&gt; using namespace std; struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ListNode* createLinkedList(int a...
湖南大学数据结构链表实验1.zip
03-08
在本实验中，我们将深入探讨数据结构中的一个重要概念——链表。链表是一种线性数据结构，与数组不同，它不连续存储元素。在链表中，每个元素（称为节点）包含两部分：数据和指向下一个节点的指针。这个实验来自湖南...
数据结构链表入门.docx
最新发布
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
pp.zip_数据结构链表实验
09-21
在"pp.zip_数据结构链表实验"中，我们聚焦于一个具体的应用场景——学生信息管理。这个实验旨在帮助学生深入理解链表的运作机制，并能够实际操作链表来解决实际问题。 链表是一种线性数据结构，与数组不同，它的...
链表笔试题
weixin_34151004的博客
11-10 153
链表： 1、注意是否有带头结点。 2、单链表的建立：顺序建表（尾插法）、逆序建表（头插法）。单链表插入、删除操作需要寻找前驱结点。 3、双向链表和单向链表相比，多了一个前驱指针，单向链表在删除结点时候要遍历链表，双向链表在删除不需要遍历。 一、判断两个链表是否相交：（假设两个链表都没有环）  1、判断第一个链表的每个节点是否在第二个链表中  2、把第二个链表连接到第一个后面，判断得到的链...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值