链表的基础知识

最新推荐文章于 2024-04-19 15:40:31 发布
最新推荐文章于 2024-04-19 15:40:31 发布
阅读量1.1k 收藏 17
点赞数
分类专栏： 学习笔记 文章标签： 代码 基础   链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Code_ZX/article/details/80024207
版权
//链表基础知识


typedef int DataType;


typedef struct ListNode
{
struct ListNode* _pNext;
DataType _data;
}ListNode,*PNode;


// 链表的初始化 
void SListInit(PNode* pHead);


//创建新结点
PNode BuyNewNode(DataType data);




// 尾插 
void SListPushBack(PNode* pHead, DataType data);


// 尾删 
void SListPopBack(PNode* pHead);


// 头插 
void SListPushFront(PNode* pHead, DataType data);


// 头删 
void SListPopFront(PNode* pHead);


// 在链表中查找值为data的元素，找到后返回值为data的结点 
PNode SListFind(PNode pHead, DataType data);


//求链表结点个数
int SListSize(PNode phead);


// 在pos位置插入值为data的结点 
void SListInsert(PNode* pHead, int pos, DataType data);


// 删除pos位置的结点 
void SListErase(PNode* pHead, int pos);


// 获取链表中值data的结点 
int SListDataSize(PNode pHead,DataType data);


// 判断链表是否为空 
int SListEmpty(PNode pHead);


// 销毁链表 
void SListDestroy(PNode* pHead);




///


//测试函数


void testSListInit();  //测试初始化


void testPushTail();     //测试尾插


void testSListPopBack();       //测试尾删


void testPushFront();        //测试头插


void testPopFront();           //测试头删


void testFind();      //测试找到值为data的结点，返回结点




void testInsert();        //测试在pos位置插入data


void testErase();     //测试删除pos位置结点




void testDataSize();          //测试获取值为data的结点


void testEmptyAndDestory();         测试摧毁链表和判断链表是否为空




// 链表的初始化 
void SListInit(PNode* pHead)
{
assert(pHead);


*pHead = NULL;          //将结点赋空

}


//创建新结点
PNode BuyNewNode(DataType data)
{
PNode pNew = NULL;


pNew = (PNode)malloc(sizeof(PNode));   //申请一块新结点的空间


if (NULL == pNew)                      //判断是否申请成功
{
printf("申请结点失败！！\n");
return NULL;
}


pNew->_data = data;
pNew->_pNext = NULL;
return pNew;


}


// 尾插 
void SListPushBack(PNode* pHead, DataType data)
{
assert(pHead);


PNode pCur;
PNode tail = BuyNewNode(data);             //创建新结点
pCur = *pHead;


if (NULL == pCur)                          // 判断头结点是否为空
{
*pHead = tail;
}


else{
while (pCur->_pNext)                      // 遍历链表 找到最后一个结点
{
pCur = pCur->_pNext;
}
pCur->_pNext = tail;                       //将最后结点的下一个结点改为新结点
}


}


// 尾删 
void SListPopBack(PNode* pHead)
{
assert(pHead);


PNode pCur = NULL;
PNode pDel = NULL;
pCur = *pHead;
pDel = pCur->_pNext;


if (NULL == *pHead)        //判断链表是否为空
return;

else if (pCur->_pNext == NULL)    //只有一个结点  直接令其为空
{
*pHead = NULL;
}
else
{
while (pDel->_pNext)            //遍历链表，找到最后结点
{
pCur = pDel;
pDel = pDel->_pNext;
}
}
//free(pDel);                          //防止野指针的产生
pCur->_pNext = NULL;              // 让最后一个结点为空


}


// 头插 
void SListPushFront(PNode* pHead, DataType data)
{
assert(pHead);


PNode pNewHead;
PNode pCur;
pCur = *pHead;
pNewHead = BuyNewNode(data);             //创建新结点


if (NULL == *pHead)
{
*pHead = pNewHead;                   //空链表，直接将新结点赋给原结点
}


else
{
DataType tem;
pNewHead->_pNext = pCur->_pNext;         //先将new与后面链接
pCur->_pNext = pNewHead;                //使phead下一个结点指向新结点
tem = pNewHead->_data;                   //交换两个结点的data
pNewHead->_data = pCur->_data;
pCur->_data = tem;
}
}


// 头删 
void SListPopFront(PNode* pHead)
{
assert(pHead);
PNode pCur;
PNode pDel;
pCur = *pHead;


if (NULL == *pHead)           //处理头结点
return;


else if (NULL == pCur->_pNext)     //处理 只有一个结点
{
*pHead = NULL;
}
else                          //处理多个结点
{
pDel = pCur->_pNext;
DataType tem = pCur->_data;
pCur->_data = pDel->_data;     
pDel->_data = tem;                   //交换data 删除第二个结点，   相当于删除第一个结点
pCur->_pNext = pDel->_pNext;
free(pDel);                 //释放删除后的结点


}
}


// 在链表中查找值为data的元素，找到后返回值为data的结点 
PNode SListFind(PNode pHead, DataType data)
{
//assert(pHead);


PNode pCur;
pCur = pHead;


if (pHead == NULL)                //处理空链表
{
return NULL;
}
else
{
while (pCur->_pNext)            //遍历链表
{
if (pCur->_data == data)
{
return pCur;                //找到值为data的结点  并返回
}
pCur = pCur->_pNext;
}
return NULL;                //没找到值为data的结点  返回空
}
}




//求链表结点个数
int SListSize(PNode phead)
{


PNode pCur;
int flag = 0;
pCur = phead;


while (pCur)
{
pCur = pCur->_pNext;
flag++;
}


return flag;
}


// 在pos位置插入值为data的结点 
void SListInsert(PNode* pHead, int pos, DataType data)
{
assert(pHead);


PNode pCur;
PNode pNew;
int size = 0;


pNew = BuyNewNode(data);
pCur = *pHead;
size = SListSize(*pHead);


if (size == 0)                  //处理空链表
{
return;
}
else
{
while (--pos && pCur)         //遍历链表  找到pos位置或者pcur为null
{
pCur = pCur->_pNext;
}
if (pCur == NULL)            //处理pcur为空
{
return;
}
else                       // 找到pos位置，插入到pcur后面，再交换二者数据
{
pNew->_pNext = pCur->_pNext;
pCur->_pNext = pNew;
int tem = 0;
tem = pNew->_data;
pNew->_data = pCur->_data;
pCur->_data = tem;
}
}
}


// 删除pos位置的结点 
void SListErase(PNode* pHead, int pos)
{
assert(pHead);


PNode pCur;
PNode pDel = NULL;
int size;


pCur = *pHead; 
size = SListSize(*pHead);


if (size == 0)
{
return;
}
while (--pos && pCur)
{
pCur = pCur->_pNext;
}
if (pCur == NULL)
{
return;
}
else
{
pDel = pCur->_pNext;
if (pDel == NULL)
{
SListPopBack(pHead);
}
else
{
pCur->_pNext = pDel->_pNext;
pCur->_data = pDel->_data;
//free(pDel);
}
}
}


// 获取链表中值data的结点 
int SListDataSize(PNode pHead, DataType data)
{
PNode pCur;
int count = 0;


pCur = pHead;


if (pHead == NULL)            //测试空链表
{
return -1;
}
else
{
while (pCur->_data != data)            //找到data  或者  遍历完链表后跳出循环
{
pCur = pCur->_pNext;
count++;
if (pCur == NULL)
{
return -1;
}
}
}
return count + 1;                    //返回data处在第几个结点
}


// 判断链表是否为空 
int SListEmpty(PNode pHead)
{
if (pHead == NULL)
return 0;
else 
return 1;
}


// 销毁链表 
void SListDestroy(PNode* pHead)
{
assert(pHead);


PNode pCur;
pCur = *pHead;


if (*pHead == NULL)
return;
else if (pCur->_pNext == NULL)
{
free(pCur);
}
else
{
pCur = pCur->_pNext;
SListDestroy(&pCur);
}
}



//测试初始化


void testSListInit()
{
PNode  pHead;



SListInit(&pHead);


}


//测试尾插


void testPushTail()
{
PNode phead;
SListInit(&phead);


SListPushBack(&phead, 5);


}


//测试尾删
void testSListPopBack()
{
PNode pHead;
SListInit(&pHead);


SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);


SListPopBack(&pHead);
}


//测试头插
void testPushFront()
{
PNode pHead;


SListInit(&pHead);


SListPushFront(&pHead, 1);


SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);


SListPushFront(&pHead, 0);
}


//测试头删
void testPopFront()
{
PNode pHead;


SListInit(&pHead);


SListPopFront(&pHead);          //测试空链表头删


SListPushBack(&pHead, 1);


SListPopFront(&pHead);          //测试只有一个结点头删


SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);


SListPushFront(&pHead, 1);         //头插


SListPopFront(&pHead);         // 测试多个结点头删


SListPushBack(&pHead, 4);


}


//测试找到值为data的结点，返回结点
void testFind()
{
PNode pHead;
PNode pFind;


SListInit(&pHead);
SListInit(&pFind);


pFind = SListFind(pHead, 1);           //测试空链表


SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);


pFind = SListFind(pHead, 2);          // 测试找到data


pFind = SListFind(pHead, 5);          //测试没找到data 
}


//测试在pos位置插入data


void testInsert()
{
PNode pHead;


SListInit(&pHead);


SListInsert(&pHead, 2, 1);       //测试空链表


SListPushBack(&pHead, 0);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);


SListInsert(&pHead, 6, 5);      //测试pos大于结点个数


SListInsert(&pHead, 3, 9);    //测试pos小于结点个数


}


//测试删除pos位置结点
void testErase()
{
PNode pHead;


SListInit(&pHead);


SListErase(&pHead, 2);             //测试空链表


SListPushBack(&pHead, 0);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);


SListErase(&pHead, 4);           //测试删除最后一个结点


SListErase(&pHead, 5);           //pos 大于 结点个数


SListErase(&pHead, 2);         //  pos小于 结点个数
}


//测试获取值为data的结点


void testDataSize()
{
PNode pHead;


SListInit(&pHead);


SListDataSize(pHead, 2);           // 空链表


SListPushBack(&pHead, 0);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);


SListDataSize(pHead, 5);            //没data 值


SListDataSize(pHead, 3);             //有data值
}




//测试摧毁链表和判断链表是否为空
void testEmptyAndDestory()
{
PNode pHead;


SListInit(&pHead);


SListEmpty(pHead);


SListPushBack(&pHead, 0);
SListPushBack(&pHead, 0);
SListPushBack(&pHead, 0);


SListEmpty(pHead);


SListDestroy(&pHead);
}

Code_zx
关注
专栏目录
数据结构之链表基础知识点
StormFang的博客
01-24 971
链表：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，链表比较方便插入和删除操作。 定义typedef int ElemType; typedef str
链表基础知识
m0_61435822的博客
10-16 419
C++链表
链表基础知识整理
xuan971130的博客
07-27 1007
关于链表最重要的是搞清楚指针的指向，next域存放的是下一个结点的地址。1：顺序建链表要定义头指针，游动指针，尾部指针； 逆序建立链表定义头指针和游动指针即可，每次将新的结点插在头指针后面。搞清楚指针的指向即可。2：删除结点。定义一个游动指针，还要定义一个指针，为了记后一个结点的地址。 顺序建表： #include #include struct node { int data
python的链表基础知识点
12-17
链表是一种重要的数据结构，它在Python中虽然不如数组或列表那样直接存在，但可以通过类和对象的概念来模拟实现。链表不同于数组，数组中所有元素在内存中是连续存储的，而链表的节点可以在内存的任何位置，每个节点...
关于链表基础知识的详解
07-20
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着不可或缺的角色。与数组不同，链表的元素在内存中不是连续存储的，而是通过指针或引用相互连接。这种特性使得链表在某些操作上具有优势，尤其是在动态...
链表基础知识梳理
c123nANDY的博客
12-17 314
链表是乱序的多组数据相互联系构成的 链表操作分为：初始化，创建，插入，删除，遍历，查询，逆序，是否有环 链表定义 typedef struct LinkList { int Element; LinkList * next; }LinkList; 初始化 linklist * List_init() { linklist *HeadNode= (linklist...
链表的理解
TheAI的博客
11-30 671
经过面试谈谈链表，发现掌握还是不全；     （含义）   链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。   （表述）链表(
链表基础知识详解（非常详细简单易懂）
最新发布
酒无忧的博客
04-19 1053
链表作为C语言中一种基础的数据结构，在平时写程序的时候用的并不多，但在操作系统里面使用的非常多。不管是RTOS还是Linux等使用非常广泛，所以必须要搞懂链表，链表分为单向链表和双向链表，单向链表很少用，使用最多的还是双向链表。单向链表懂了双向链表自然就会了。
链表基础知识总结
热门推荐
闲适_
02-28 1万+
什么是链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点都包括两部分：一是数据域，用来存储元素数值数据，另一个是存储直接后继结点地址的指针域，该指针一般称为next，用来指向下一个结点的位置。由于下一个结点也是链表类型，所以next的指针也要定义为链表类型。 链表中的一些基本定义和特点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中存储的第一个数据元素的结
链表入门
愿你饱经冷暖，仍保纯真
06-04 1082
在数据结构的线性结构中，数组虽然很方便，但是它有很多弊端。1.因为数组是利用连续内存空间进行数据的存取的，所以其长度有一定限制。2.虽然高版本的编程语言中强化了数组的储存类型，但是，刚刚解除编程的人如果入门就接触这种“高级数组”无疑是一种非常不好的习惯。3.数组一旦显式的被申明后，其大小就固定了，不能动态进行扩充。而链表则可以，可以动态生成节点并且添加到已有的链表后面。4.在删除几个元素时，链表的...
链表的基本知识1
wxn704414736的博客
11-20 338
链表的声明 首先要清楚链表是有数据和指向下一个地址的指针组成的。无论结构体里多少个数据，必须要有一个地址指针 typedef struct Node { ElemType data; struct Node *next; }Node; 为什么这个结构体声明为Node，结构体的指针域也是一个Node？ typedef struct Node { ElemType da
链表的基本知识
m0_52261367的博客
02-12 521
链表的优缺点 优点：易于插入和删除，内存利用率高 缺点：和数组相比需要更多内存，遍历困难，反向遍历更难。（双链表内存消耗更大） 创建节点 class Node { private int data; private Node next; public Node(int data) { this.data = data; this.next = next; } } 链表的
python链表基础知识
10-22
Python中的链表是一种数据结构，它由一组节点组成，每个节点包含一个数据项和一个指向下一个节点的链接。链表有两种类型：单链表和双链表。在Python中，我们可以使用类来定义链表和节点。链表的基本操作包括增、删、改、查四种情况。其中，创建空链表时，只需要把相应的链表头节点变量设置为空链接即可。在Python里可以将其设置为None。求线性链表的长度可以通过遍历链表并计数来实现。在链表中删除操作可以通过修改节点的链接来实现。具体实现可以参考链表的结构定义和操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值