手写链表底层实现对数据的增删改查

最新推荐文章于 2022-11-25 14:51:58 发布

向阳的小白

最新推荐文章于 2022-11-25 14:51:58 发布

阅读量211

点赞数

文章标签： c语言单链表

本文链接：https://blog.csdn.net/weixin_46889449/article/details/107677160

版权

1.头文件
#ifndef LINKEDDEMO0729_H_INCLUDED
#define LINKEDDEMO0729_H_INCLUDED

//创建节点类型
typedef struct LinkedNode{
char * pData;
struct LinkedNode *pNext;
}LinkedNode,*PLinkedNode;
//创建链表类型
typedef struct LinkedTable{
PLinkedNode pHead;
}LinkedTable,*PLinkedTable;

//初始化链表
void initLinkedTable(PLinkedTable pTable);

// 给链表中添加字符串
void addData2Table(PLinkedTable pTable,char * pData);

//将链表中的元素按正向输出，并释放节点
char * removeFirst(PLinkedTable pTable);

//统计并返回链表中元素的个数
int countElements(PLinkedTable pTable);

// 删除链表的末尾节点，返回该节点中的字符串
char * removeLast(PLinkedTable pTable);

//返回指定下标处的节点
PLinkedNode getNodeByIndex(PLinkedTable pTable,int index);

// 替换指定的下标处的元素
void replaceElementByIndex(PLinkedTable,int,char *);

// 返回指定下标处的元素值
char * getElementByIndex(PLinkedTable pTable,int index);

//查找链表中是否存在指定的元素，返回对应的下标，如果不存在，则返回-1
int findElement(PLinkedTable pTable,char * source);

// 给指定下标处插入新元素
void insertElementByIndex(PLinkedTable pTable,int index,char * pData);

//删除指定下标处的节点，返回元素值
char * removeNodeByIndex(PLinkedTable pTable,int index);

//将链表中的元素反转
void reversalLinkedTable(PLinkedTable pTable);
#endif // LINKEDDEMO0729_H_INCLUDED
2.实现代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include “LinkedDemo0729.h”

//初始化链表
void initLinkedTable(PLinkedTable pTable){
pTable->pHead=NULL;
}
// 给链表中添加字符串
void addData2Table(PLinkedTable pTable,char * pData){
//判断链表是否存在和输入字符串是否不为空
if(pTableNULL||pDataNULL){
return;
}
//将字符串拷贝到新空间
char *pChars=(char *)malloc(strlen(pData)+1);
strcpy(pChars,pData);
//创建新节点，储存数据
PLinkedNode pNewNode=(PLinkedNode)malloc(sizeof(LinkedNode));
pNewNode->pData=pChars;
pNewNode->pNext=NULL;

//将节点插入到链表中
//判断链表中是否有节点，如果没有插入到第一个
if(pTable->pHead==NULL){
    //链表中没有节点，插入到第一个
    pTable->pHead=pNewNode;
}else{
    //链表中已经有节点需要插入到最后一个
    //创建一个临时变量
    PLinkedNode pTemp=pTable->pHead;
    while(pTemp->pNext!=NULL){
        pTemp=pTemp->pNext;
    }
    //当循环完成时，已经找到最后一个节点
    pTemp->pNext=pNewNode;
}

}
//将链表中的元素按正向输出，并释放节点
//思路：找到第一个，将第一个节点中的数据储存，然后head指针下一一位，将节点释放
char * removeFirst(PLinkedTable pTable){
//判断链表是否存在，是否有第一个元素
if(pTableNULL ||pTable->pHeadNULL){
return NULL;
}
//创建一个中间量，用来存储需要删除的节点数据
PLinkedNode pTemp=pTable->pHead;
//头节点向下移动一位
pTable->pHead=pTemp->pNext;
char * pChars=pTemp->pData;
//释放节点
free(pTemp);
return pChars;
}

//统计并返回链表中元素的个数
//思路：创建一个中间量，采用移位的方法计算节点个数
int countElements(PLinkedTable pTable){
int count=0;
if(pTableNULL||pTable->pHeadNULL){
return 0;
}
//创建一个中间量
PLinkedNode pTemp=pTable->pHead;
count++;
while(pTemp->pNext!=NULL){
count++;
pTemp=pTemp->pNext;
}
//循环结束，此时pTemp->pNext=NULL;
return count;
}

// 删除链表的末尾节点，返回该节点中的字符串
//思路：找到链表中的最后一个节点（pNext=NULL），然后将前一个节点的pNext置为空
char * removeLast(PLinkedTable pTable){
//判断链表存在与是否有节点
if(pTableNULL||pTable->pHeadNULL){
return NULL;
}
char *pChars=NULL;
//如果链表中只有一个节点
if(pTable->pHead->pNextNULL){
//将节点中的数据储存，然后将pHead置为NULL
pChars=pTable->pHead->pData;
free(pTable->pHead);
pTable->pHead=NULL;
return pChars;
}else{
//链表中至少有两个节点，需要借助中间量来移位
PLinkedNode pTemp=pTable->pHead;
while(pTemp->pNext->pNext!=NULL){
pTemp=pTemp->pNext;
}
//循环结束时，pTemp->pNext->pNextNULL
pChars=pTemp->pNext->pData;
free(pTemp->pNext);
//将此时的pTemp->pNext=NULL;
pTemp->pNext=NULL;
return pChars;
}
return NULL;
}

//返回指定下标处的节点
PLinkedNode getNodeByIndex(PLinkedTable pTable,int index){
//判断链表是否存在，是否有节点
if(pTableNULL|| pTable->pHeadNULL ){
return NULL;
}
if(index<0||index>=countElements(pTable)){
return NULL;
}
//如果程序运行到此处说明链表存在，有节点并且输入的下标合法
//设置中间量
int count=0;
PLinkedNode pTemp=pTable->pHead;
//注意：如果index=0，不进入循环直接返回第一个节点
//根据下标移位找到需要找的节点
while(count<index){
count++;
pTemp=pTemp->pNext;
}

return pTemp;

}

// 返回指定下标处的元素值
//思路：调用指定下标返回节点函数，取出元素返回
char * getElementByIndex(PLinkedTable pTable,int index){
//判断链表是否合法
if(pTable==NULL||index<0||index>=countElements(pTable)){
return NULL;
}
//调用函数取出节点
PLinkedNode pTemp=getNodeByIndex(pTable,index);
if(pTemp!=NULL){
return pTemp->pData;
}
}

// 替换指定的下标处的元素
//思路，根据下标以为，找到对应的节点，将pData的值置换
void replaceElementByIndex(PLinkedTable pTable,int index,char * pDatas){

//判断链表是否存在，是否有节点
if(pTable==NULL||pTable->pHead==NULL){
    return ;
}
//判断输入的字符串和下标是否合法
if(pDatas==NULL||index<0||index>=countElements(pTable)){
    return ;
}

char *pChars=(char *)malloc(strlen(pDatas)+1);
strcpy(pChars,pDatas);
//调用上面的函数，找到我们需要替换数据的节点
PLinkedNode pTemp=getNodeByIndex(pTable,index);
//判断返回节点的合法性
if(pTemp!=NULL){
    free(pTemp->pData);
    pTemp->pData=pChars;
}

}

//查找链表中是否存在指定的元素，返回对应的下标，如果不存在，则返回-1
//思路：利用移位，直到数据与需要查找的数据相同为止(找到返回下标，没找到返回-1)
int findElement(PLinkedTable pTable,char * source){
//判断链表的合法性
if(pTableNULL||pTable->pHeadNULL){
return -1;
}
//判断输入的合法性
if(sourceNULL){
return -1;
}
int index=0;
//到此处时，输入及链表合法
PLinkedNode pTemp=pTable->pHead;
while(pTemp!=NULL&&strcmp(source,pTemp->pData)!=0){
index++;
pTemp=pTemp->pNext;
}
//如果循环完毕还没有找到输入的元素，此时移动到最后一位的下一位也就是说pTemp=NULL
if(pTempNULL){
return -1;
}
return index;
}

// 给指定下标处插入新元素
//思路：根据下标找到节点，节点后移，将创建的新节点链接到链表中
void insertElementByIndex(PLinkedTable pTable,int index,char * pData){
//判断链表的合法性
if(pTableNULL){
return ;
}
//判断输入下标的合法性
if(index<0||index>countElements(pTable)){
return ;
}
//判断输入数据的合法性
if(pDataNULL){
return ;
}
//程序运行到此处时，输入合法
//设置字符节点储存输入数据
char *pChars=(char *)malloc(strlen(pData)+1);
strcpy(pChars,pData);
//创建新节点
PLinkedNode pNewNode=(PLinkedNode)malloc(sizeof(PLinkedNode));
pNewNode->pData=pChars;
pNewNode->pNext=NULL;
//判断插入情况
PLinkedNode pTemp=NULL;
if(index0){
//插入到第一位
pNewNode->pNext=pTable->pHead;
pTable->pHead=pNewNode;
}else if(indexcountElements(pTable)){
//最后一位插入
//移位找到最后一位
pTemp=pTable->pHead;
while(pTemp->pNext!=NULL){
pTemp=pTemp->pNext;
}
//运行到这里时，pTemp指向最后一位
//将节点插入
pTemp->pNext=pNewNode;
}else{
//中间插入
//调用函数找到要插入节点的前一个节点
pTemp=getNodeByIndex(pTable,index-1);
//插入节点
pNewNode->pNext=pTemp->pNext;
pTemp->pNext=pNewNode;
}
}

//删除指定下标处的节点，返回元素值
//思路：调用函数找到节点，将节点从链表中去除
char * removeNodeByIndex(PLinkedTable pTable,int index){
//判断链表的合法性
if(pTableNULL||pTable->pHeadNULL){
return NULL;
}
//判断下标的合法性
if(index<0||index>=countElements(pTable)){
return NULL;
}
//设置中间量
PLinkedNode pTemp=NULL;
PLinkedNode pPreNode=NULL;

char *pChars=NULL;
//分三种情况处理删除节点的情况
if(index==0){
//删除头
pTemp=pTable->pHead;
pTable->pHead=pTemp->pNext;
pChars=pTemp->pData;
free(pTemp);

}else if(index==(countElements(pTable)-1)){
    //调用函数找到最后一个节点的数据返回
    //将前一个节点的pNext置为空
    //找到最后一个节点
    pTemp=getNodeByIndex(pTable,(countElements(pTable)-1));
    pPreNode=getNodeByIndex(pTable,(countElements(pTable)-2));

    pChars=pTemp->pData;
    pPreNode->pNext=NULL;
    free(pTemp);
}else{
    //删除中间节点
    pTemp=getNodeByIndex(pTable,index);
    pPreNode=getNodeByIndex(pTable,index-1);
    pChars=pTemp->pData;
    pPreNode->pNext=pTemp->pNext;
    free(pTemp);
}
return pChars;

}

//将链表中的元素反转
void reversalLinkedTable(PLinkedTable pTable){
//判断链表中的是否有节点
if(pTableNULL||pTable->pHeadNULL){
return;
}
//计算链表中节点的个数
int count=countElements(pTable);
char *preData=NULL;
char *nextData=NULL;
for(int i=0;i<(count/2);i++){
preData=getElementByIndex(pTable,i);
nextData=getElementByIndex(pTable,count-i-1);
//交换数据
getNodeByIndex(pTable,i)->pData=nextData;
getNodeByIndex(pTable,count-i-1)->pData=preData;
}
}
3.测试代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include “LinkedDemo0729.h”

int main()
{
char array[51];
//声明列表
LinkedTable table;
//table.pHead==NULL;

//PLinkedTable pTable;
//初始化
initLinkedTable(&table);
do{
    printf("请输入字符串(输入OK结束)：\n");
    gets(array);
    if(strcmp(array,"ok")==0){
        break;
    }
    //将array中的数据储存到链表中
    addData2Table(&table,array);
}while(1);

//测试将链表中数据反转
reversalLinkedTable(&table);
/*
//测试根据下标删除节点，并返回删除节点处的数据
char * removeChars=NULL;
removeChars=removeNodeByIndex(&table,4);
printf("%s\n",removeChars);

//测试根据元素返回节点下标
int index=findElement(&table,"abc");
printf("这个元素的下标是第%d位\n",index);

//测试将数据插入到指点下标处：
insertElementByIndex(&table,5,"aaaaaaaaa");
//计算链表中节点的个数
int count = countElements(&table);
printf("链表中节点的个数为：%d\n",count);

//测试将指定节点处的元素替换
replaceElementByIndex(&table,1,"jifei");

//测试根据 下标返回节点元素值
char * backChars=NULL;
backChars=getElementByIndex(&table,1);
printf("%s\n",backChars);

*/
//将链表中的元素正向输出
do{
    char *pChar=removeFirst(&table);
    if(pChar==NULL){
        break;
    }
    printf("%s\n",pChar);
    free(pChar);
}while(1);

/*
//将链表中的节点反向输出
do{
    char *pChar=removeLast(&table);
    if(pChar==NULL){
        break;
    }
    printf("%s\n",pChar);
    free(pChar);
}while(1);
*/




return 0;

}

向阳的小白

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
手写链表底层实现对数据的增删改查

1.头文件#ifndef LINKEDDEMO0729_H_INCLUDED#define LINKEDDEMO0729_H_INCLUDED//创建节点类型typedef struct LinkedNode{char * pData;struct LinkedNode *pNext;}LinkedNode,*PLinkedNode;//创建链表类型typedef struct LinkedTable{PLinkedNode pHead;}LinkedTable,*PLinkedTab
复制链接

扫一扫