链表题

最新推荐文章于 2022-10-21 23:12:07 发布
最新推荐文章于 2022-10-21 23:12:07 发布
阅读量107 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40192867/article/details/80151950
版权

SList.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
typedef struct SList
{
    DataType data;
    struct SList *p_next;


}SList,*PNode;


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


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


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


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


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


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


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


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


int SListSize(PNode pHead);// 获取链表的长度 


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


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


void PrintSList(PNode pHead);//打印链表的值


void PrintListTailToHead(PNode pHead);//逆序打印链表值


void DelNotTailNode(PNode pos);//删除链表节点


void InsertNotHead(PNode pos, DataType data);//在无头单链表的一个非头节点前插入一个节点


void FormCyc(PNode *pHead);//使链表形成一个环


PNode JosephCircle(PNode pHead, int M);//约瑟夫环


void yuesefu(PNode pHead,PNode pCur);//约瑟夫环输出


PNode FindelastkNode(PNode pHead,int k);//找到倒数第K个节点


void printfzhizhen(PNode pHead);//打印指针位置元素的值


void delastkNode(PNode pHead,int k);//删除倒数第K个节点


PNode FindelastkNode2(PNode pHead,int k);//返回前一个节点


void ReverseSList(PNode* pHead);//逆序链表


void maopao(PNode *pHead);//冒泡排序



SList.c


#include"SList.h"
PNode BuyNewNode(DataType data)
{
    PNode pCur = NULL;
    pCur = (PNode )malloc(sizeof(SList));
    pCur->data = data;
    return pCur;
}
void SListInit(PNode* pHead)// 链表的初始化 
{
    *pHead = NULL;


}
void SListPushBack(PNode* pHead, DataType data)// 尾插
{
    PNode pCur = NULL;
    PNode pRet = NULL;
    assert(pHead);
    if (*pHead == NULL)
    {
        *pHead =BuyNewNode(data);
        (*pHead)->p_next = NULL;
        return;
    }
    else
    {
        pCur = *pHead;
        while (pCur->p_next)
        {
            pCur = pCur->p_next;
        }
        pRet = BuyNewNode(data);
         pCur->p_next= pRet;
         pRet->p_next = NULL;
    }
    return;
}
void SListPopBack(PNode* pHead)// 尾删
{
    PNode pCur = *pHead;
    PNode pPre = NULL;
    assert(pHead);
    if (*pHead == NULL)
    {
        printf("链表已空，无法删除!!!\n");
        return;
    }


    while (pCur->p_next)
    {
        pPre = pCur;
        pCur = pCur->p_next;
    }
    pPre->p_next = NULL;
    free(pCur);


#if 0
    while (pCur->p_next->p_next)
    {
        pCur = pCur->p_next;
    }
    PNode pNext = NULL;
    pNext = pCur->p_next;
    pCur->p_next = NULL;
    free(pNext);
#endif
}




void SListPushFront(PNode* pHead, DataType data)// 头插 
{
    PNode pCur = *pHead;
    PNode pRet = NULL;
    assert(pHead);
    if (*pHead == NULL)
    {
        *pHead = BuyNewNode(data);
        (*pHead)->p_next = NULL;
    }
    else
    {
        pRet = BuyNewNode(data);
        pRet->p_next = pCur;
        *pHead = pRet;
    }
}
void SListPopFront(PNode* pHead)// 头删 
{
    PNode pCur = NULL;
    //判断pHead是否合法
    assert(pHead);
    //检测链表是否为空
    if (NULL == *pHead)
    {
        printf("链表为空，无法删除!!!\n");
        return;
    }
    else
    {
        //链表不为空
        pCur = *pHead;
        *pHead = (*pHead)->p_next;
        free(pCur);
    }
}
PNode SListFind(PNode pHead, DataType data)// 在链表中查找值为data的元素，找到后返回值为data的结点
{
    PNode pCur = pHead;
    //检测链表是否为空
    if (pHead == NULL)
    {
        printf("链表中无元素!!!\n");
        return NULL;
    }
    //链表不为空
    while (pCur)
    {
        if (pCur->data == data)
            return pCur;
        pCur = pCur->p_next;
    }
    return NULL;
}
void SListInsert(PNode* pHead, PNode pos, DataType data)// 在pos位置插入值为data的结点
{
    PNode pCur = *pHead;
    PNode pRet = NULL;
    PNode pPre = NULL;
    //检测pHead合法性
    assert(pHead);
    //链表为空
    if (*pHead == NULL )
    {
        printf("链表为空，无法插入!!!\n");
        return;
    }
    if (pos == NULL)
    {
        printf("插入位置无效,无法插入!!!\n");
    }
    else
    {
        //链表不为空
        pCur = *pHead;
        while(pCur!=pos&&pCur)      
        {
            pPre = pCur;
            pCur = pCur->p_next;
        }
        if (pCur == NULL)
        {
            printf("链表中无该位置,无法插入!!!\n");
            return;
        }
        else
        {
            pRet = BuyNewNode(data);
            pRet->p_next = pCur;
            pPre->p_next = pRet;
        }
    }
    return;
}
void SListErase(PNode* pHead, PNode pos)// 删除pos位置的结点 
{
    PNode pCur = *pHead;
    PNode pPre = NULL;
    assert(pHead);
    if (*pHead == NULL)
    {
        printf("链表为空，无法删除!!!\n");
        return;
    }
    while (pCur != pos&&pCur)
    {
        pPre = pCur;
        pCur = pCur->p_next;
    }
    if (!pCur)
    {
        printf("链表中无该结点!!!\n");
        return;
    }
    else
    {
        pPre->p_next = pCur->p_next;
        free(pCur);
    }
}
int SListSize(PNode pHead)// 获取链表的长度
{
    PNode pCur = pHead;


    int count = 0;
    if (pHead == NULL)
        return  0;
    while (pCur)
    {
        count++;
        pCur = pCur->p_next;
    }
    return count;
}


int SListEmpty(PNode pHead)// 判断链表是否为空 
{
    if (pHead == NULL)
        return 0;
    else return 1;
}
void SListDestroy(PNode* pHead)// 销毁聊表 
{
    PNode pCur = *pHead;
    PNode pPre = NULL;
    assert(pHead);
    if (*pHead == NULL)
        return;
    while (pCur)
    {
        pPre = pCur;
        pCur = pCur->p_next;    
        free(pPre);
    }
    *pHead = NULL;
}
void PrintSList(PNode pHead)//打印链表的值
{
    PNode pCur = NULL;
    pCur = pHead;
    while (pCur)
    {
        printf("%d ", pCur->data);
        pCur = pCur->p_next;
    }
    printf("\n");
}
//逆序打印链表
//原理：通过函数自己调用自己，
void PrintListTailToHead(PNode pHead)
{
if(pHead != NULL)
{
PrintListTailToHead(pHead->p_next);
//执行到这里返回，直到next为空，为空进入
//下一个if else 表达式，返回时候的函数就返回到这里继续执行


if(pHead->p_next == NULL)
printf("%d",pHead->data);
else
{
printf("->%d",pHead->data);

}

}

}
//删除一个无头单链表的非尾节点
void DelNotTailNode(PNode pos)
{
PNode cur = NULL;

assert(pos);
if(NULL == pos ->p_next)
return;
else
{
DataType temp = 0;
//交换pos和pos->n_next的数据，问题变成删除pos指向的节点的下一个节点
temp = pos->data;
pos->data = pos->p_next->data;
pos->p_next->data = temp;
cur = pos->p_next;
pos->p_next = pos->p_next->p_next;
        free(cur);
        cur = NULL;
}


}




void InsertNotHead(PNode pos, DataType data)//在无头单链表的一个非头节点前插入一个节点
{
PNode cur;
DataType i;
assert(pos);

i = pos->data;
pos->data = data;
data = i;
cur = BuyNewNode(data);
cur->p_next = pos->p_next;
pos->p_next = cur;


}


void FormCyc(PNode *pHead)//使链表形成一个环
{
PNode cur = *pHead;
assert(pHead);




while(cur->p_next)
{

cur = cur->p_next;
}
cur ->p_next = (*pHead);

}




PNode JosephCircle(PNode pHead, int M)//约瑟夫环
{

PNode cur = pHead;
PNode per = NULL;
PNode der = NULL;
DataType temp = M;
if ((NULL == pHead) || (M <=0))
    {
        return NULL;
    }
else
{
FormCyc(&pHead);
while(cur->p_next != cur)
{
temp = M;
per = cur;
while(temp)
{
per = cur;
cur = cur ->p_next;
--temp;
}
der = cur;
cur = cur->p_next;
per->p_next = cur;
free(der);
der = NULL;


}
 
if(M == 1)
{
free(cur);
cur = NULL;
return NULL;
}
else
{
cur -> p_next = NULL;

}
return cur;
}


}


void yuesefu(PNode pHead,PNode pCur)//约瑟夫环输出
{


PNode t = pHead;
if(pCur == NULL)
 {
 printf("输入错误或输入为1，剩下的节点为%d\n ",t->data);
 }
 else
 {
 printf("剩余的节点为%d\n",pCur->data);
 }
 


}


PNode FindelastkNode(PNode pHead,int k)
{
PNode pFast = pHead;
PNode last = pHead;
if(pHead == NULL || k <=0 )
{
return NULL;


}
while(k--)
{
if(pFast == NULL)
{
printf("K大于链表中节点个数");
return NULL;
}
pFast = pFast->p_next;
}


//慢指针一起走
while(pFast)
{
last = last->p_next;
pFast = pFast->p_next;
}
return last;


}


PNode FindelastkNode2(PNode pHead,int k)//返回前一个节点
{
PNode pFast = pHead;
PNode last = pHead;
PNode per = NULL;


if(pHead == NULL || k <=0 )
{
return NULL;


}
while(k--)
{
if(pFast == NULL)
{
printf("K大于链表中节点个数");
return NULL;
}
pFast = pFast->p_next;
}


//慢指针一起走
while(pFast)
{
per = last;
last = last->p_next;
pFast = pFast->p_next;
}
return per;


}
void printfzhizhen(PNode t)//打印指针位置元素的值
{
printf("节点值为%d\n",t->data);


}


void delastkNode(PNode pHead,int k)//删除倒数第K个节点
{
PNode cur;
PNode pur;
cur = FindelastkNode2(pHead,k);
pur = cur->p_next;
cur ->p_next = pur->p_next;
free(pur);

}


void ReverseSList(PNode* pHead)
{
PNode pur,cur,tur;
assert(pHead);
pur = NULL;
cur = *pHead;
tur = NULL;
while(cur)
{
tur = cur->p_next;
cur->p_next = pur;
pur = cur;
cur = tur;
}
(*pHead) = pur;

}
void maopao(PNode *pHead)
{
PNode pur,cur,tur;
int i;
int max = 0;
pur = NULL;
tur = (*pHead);







while(tur)
{
cur = *pHead;
max = cur->data;




while(cur)
{

if(cur->p_next == NULL)
break;



if( cur->p_next->data < cur->data)
{
max = cur->data;
cur ->data = cur->p_next->data;
cur->p_next->data = max;
}

cur = cur->p_next;

}


tur = tur->p_next;


}
}


Test.c

#include"SList.h"
int main()
{
    SList List;
    PNode  pHead ;


    PNode  pCur = NULL;


    SListInit(&pHead);//链表初始化
    //尾插测试
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    SListPushBack(&pHead, 7);
    SListPushBack(&pHead, 8);
    SListPushBack(&pHead, 9);
    PrintSList(pHead);  //打印
    //头插测试
    SListPushFront(&pHead, 4);  
    SListPushFront(&pHead, 3);
    SListPushFront(&pHead, 2);
    SListPushFront(&pHead, 1);
    SListPushFront(&pHead, 0);
    PrintSList(pHead);  //打印
//PrintListTailToHead(5);
PrintListTailToHead(pHead);//逆序打印
printf("\n");



pCur = SListFind(pHead, 2); //先获取pos位置


DelNotTailNode(pCur);


 PrintSList(pHead);




 pCur = SListFind(pHead, 3);


 InsertNotHead(pCur, 8);//在无头单链表的一个非头节点前插入一个节点


 PrintSList(pHead);


  /*ReverseSList(&pHead);


  printf("haha");*/


  PrintSList(pHead);


  maopao(&pHead);


  PrintSList(pHead);



  
// pCur = JosephCircle(pHead, 8);


//  yuesefu(pHead,pCur);//约瑟夫环的输出


// pCur = FindelastkNode(pHead,5);


// printfzhizhen(pCur);


//   PrintSList(pHead);


//delastkNode(pHead,9);//删除倒数第K个节点


//PrintSList(pHead);

















    任意位置插入测试
   // pCur = SListFind(pHead, 2); //先获取pos位置


    //SListInsert(&pHead, pCur, 10); PrintSList(pHead);//打印


    //SListInsert(&pHead, NULL, 100); PrintSList(pHead);//打印


    任意位置删除
    //pCur = SListFind(pHead, 10);
    //SListErase(&pHead, pCur); PrintSList(pHead); //打印
    尾删测试
    //SListPopBack(&pHead); PrintSList(pHead);//打印
    头删测试
    //SListPopFront(&pHead); PrintSList(pHead);//打印
    打印链表的长度
    //printf("链表长度是:%d\n",SListSize(pHead));
    判断链表是否为空
    //printf("链表是否为空:%d\n", SListEmpty(pHead));
    销毁链表
    //SListDestroy(&pHead);
    再次判断是否为空
    //printf("链表是否为空:%d\n", SListEmpty(pHead));
    system("pause");
    return 0;
}



























爱学习的大白白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构【双链表、Leetcode链表题--4】
我心如火
05-17 1286
双链表：带头双向循环链表，这是最优链表，任意地方插入删除时间复杂度都是O(1)。Leetcode链表刷题
C语言题库数组，指针，结构体，链表习题
12-28
整理的一些关于C语言的练习题，题目答案都有，需要的可以下载看一下
C语言链栈
Connor的博客
05-16 182
#include<stdio.h> #include<stdlib.h> typedef int DataType; typedef struct node { DataType data; struct node *next; } Node; void InitStack(Node *top) { top = (Node *)malloc(sizeof(Node)); top->next = NULL; } int Push(Node *top, DataT.
循环双链表（C语言实现）
Mr_John
10-27 328
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef int DataType; typedef struct Node { DataType data; // 数据域 struct Node * prior; // 前趋指针 struct Node * next; // 后继指针 }Li...
Bug 记录
xrdshx的博客
09-15 521
Bug记录 CocosCreator打包出现 Error：Program type already present: android.support.v4.os.ResultReceiver$MyResultReceiver 解决方法： 在\build\jsb-link\frameworks\runtime-src\proj.android-studio\gradle.properties中加入下面两行 android.useAndroidX=true android.enableJetifier=true
数据结构 --- c语言实现无头单链表(再封装写法)
weixin_60569662的博客
02-14 655
再封装的方式，用 c++ 的思想做无头链表 链表的结构体描述(节点) #include <stdio.h> #include <stdlib.h> #include <assert.h> //断言处理 宏 typedef int DataType; typedef struct Node { DataType data; struct Node* next; }NODE,*LPNODE; 再定义一个结构体(链表) 通过记录头节.....
数据结构第三次上机题
weixin_52326703的博客
10-17 3406
第三次上机题1.链表基础概念2. 顺序表逆置 (10 分))3. 单链表逆置 (10 分)4.找出顺序表中的最小值 (15 分)5.删除顺序表中指定值元素 (15 分)6.删除循环链表中已知结点的前驱 (10 分)7. 从单链表LA指定位置删除连续n个元素并插入单链表LB的指定位置 (15 分)8. 两个单链表元素交叉合并 (15 分) 1.链表基础概念 2-1 链表不具有的特点是______B_____? A.插入、删除不需要移动元素 B.可随机访问任意元素 C.不必事先估计存储空间 D.所需空间与线性长
链表试题（Python实现）
Zincy星辰
10-21 829
1. 反转链表 2.链表内指定区间反转（反转链表 II） 3. 链表中的节点每k个一组翻转 4. 链表相加（反转链表） 5. 链表的中间结点（快慢指针） 6. 链表中倒数第k个结点（快慢指针） 7. 删除链表的倒数第n个节点（快慢指针） 8. 回文链表（判断是否为回文：快慢指针+反转链表） 9. 合并两个有序链表 10. 合并k个已排序的链表 11. 相交链表（两个链表的公共结点） 12. 判断链表中是否有环（环形链表） 13. 链表中环的入口结点 14. 单链表的排序 15. 链表的奇偶位置重排
leetcode链表习题总结
盛夏与微风
10-13 2254
1.链表题中经常给链表添加一个假头，使得头结点也能受到检查 2.链表的遍历通常设定一个指针指向头部，然后遍历直至指针指的结点不为NullListNode cur = head; while(cur != null) { .... cur = cur.next; }3.删除结点操作：构建两个指针，一个指针遍历链表，另一个指针紧跟后面进行删除操作ListNode fakeHead =
链表经典 10题
mu_tong_的博客
10-12 2183
链表10 道经典例题
lianbiao.rar_数据结构作业_链表题
09-20
数据结构链表作业题，经调试通过，可做作业参考
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
链表试题可以学习很好
11-29
这个是视频讲解链表相关 的习题的，对于喜欢编程的有一定帮助，非常适合学习
链表习题答案
10-30
"链表习题答案" 链表是一种重要的数据结构，在计算机科学中有广泛的应用。链表的习题答案是学习链表的重要一步骤。下面是链表习题答案的知识点总结： 1. 删除链表中的结点 删除链表中的结点是链表操作中的一种...
Linux基础 - 环境变量.mp4
06-18
Linux基础 - 环境变量.mp4大厂内部培训资料，都是干货！
模拟退火巡检顺序判定 使用MATLAB实现的机器人导航模拟退火巡检顺序判定，课运行.zip
06-18
模拟退火巡检顺序判定 使用MATLAB实现的机器人导航模拟退火巡检顺序判定，课运行
mcuisp串口下载软件
最新发布
06-18
mcuisp串口下载软件
Java文本编辑器应用程序（含源码）+GUI界面+使用说明+可做毕设
06-18
项目简介 JavaFX文本编辑器应用程序是一个简单的类似记事本的应用程序。在这个应用程序中，您可以轻松创建文本文档。该系统在编辑文本文件或文档时为您提供了更大的灵活性。该系统内置了各种功能，提供了编辑和样式化文本的控制。 系统简介 顾名思义，该项目主要用于编辑和创建文本文档。该项目增加了许多新功能，例如选择字体和字体粗细，以及字体样式（如加粗、斜体或下划线）。不仅如此，您还可以使用颜色格式突出显示文本，或者直接选择文本并为其着色。您还可以进行单词搜索，这有助于控制段落中的拼写错误。您还可以使用菜单栏中的注释符号引用您喜欢的句子。 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
给一个链表习题，难度大一点
07-16
好的，让我们来解决一个难度较大的链表问题。请考虑以下链表问题： 问题描述：给定一个单链表，编写一个函数来交换链表中每两个相邻的节点，并返回交换后的链表。不能修改节点的值，只能修改节点本身。 例如，给定...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值