c语言单链表源码

简介: c语言,单链表源码

总代码:

1、SList.h文件

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//相当于下面的重定义
//struct SListNode
//{
//  STLDataType data;
//  struct SListNode* next;
//};
//typedef struct SListNode SLTNode;
//void SLTPushBack(SLTDataType x)
//{
//  SLTNode node;//这样定义的结点出作用域销毁
//}
typedef int SLTDataType;//重定义数据类型,方便切换数据类型
typedef struct SListNode//定义单链表结构   32位环境下共8个字节,
{
  SLTDataType data;//定义数据
  struct SListNode* next;//指向下一个结构的指针,指向同类
  //SLTNode* next;
}SLTNode;//重定义 缩写,在本行之后起效,在结构体中不能使用
SLTNode* BuySLTNode(SLTDataType x);
SLTNode* CreateSList(int n);
void SLTPrint(SLTNode* phead);
//尾插尾删
void SLTPushBack(SLTNode** phead, SLTDataType x);
void SLTPopBack(SLTNode** phead);
//头插头删
void SLTPushFront(SLTNode** phead, SLTDataType x);
void SLTPopFront(SLTNode** phead);
//查找数据指定位置pos
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//在pos位置之后插入x
void SListInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置之后的值
void SListEraseAfter(SLTNode* pos);
//在pos位置之前插入x
void SListInsert(SLTNode** phead,SLTNode* pos, SLTDataType x);
//删除pos位置
void SListErase(SLTNode** phead, SLTNode* pos);
//单链表的释放
void SLTDestory(SLTNode** phead);

2、SList.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"
//直接用malloc需要自行赋值,检查空,很烦,所以封装一个函数
SLTNode* BuySLTNode(SLTDataType x)
{
  SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    exit(-1);//未开辟成功,结束程序
  }
  newnode->data = x;
  newnode->next = NULL;//最后一个结点默认为空
  return newnode;
}
SLTNode* CreateSList(int n)
{
  SLTNode* phead = NULL, * ptail = NULL;
  /*int x = 0;*/
  for (int i = 0; i < n; ++i)
  {
    /*scanf("%d", &x);
    SLTNode* newnode = BuySLTNode(x);*/
    SLTNode* newnode = BuySLTNode(i);
    if (phead == NULL)
    {
      ptail = phead = newnode;
    }
    else
    {
      ptail->next = newnode;
      ptail = newnode;
    }
  }
  return phead;
}
//打印函数封装
void SLTPrint(SLTNode* phead)
{
  SLTNode* cur = phead;
  while (cur != NULL)
  {
    printf("[%d|%p]->", cur->data,cur->next);
    cur = cur->next;
  }
  printf("NULL\n");
}
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
  SLTNode* newnode = BuySLTNode(x);
  if (*pphead == NULL)
  {
    *pphead = newnode;
  }
  else
  {
    SLTNode* tail = *pphead;
    //找尾
    while (tail->next)
    {
      tail = tail->next;//不是结尾,tail向后移动。
    }
    tail->next = newnode;//是结尾,tail->next链接新结点
  }
}
//尾删
//void SLTPopBack(SLTNode* phead)
//{
//  SLTNode* tail = phead;
//  SLTNode* prev = NULL;
//  while (tail->next)
//  {
//    prev = tail;
//    tail = tail->next;
//  }
//  free(tail);
//  prev->next = NULL;
//}
//尾删
void SLTPopBack(SLTNode** phead)
{
  assert(*phead);
  if ((*phead)->next == NULL)
  {
    free(*phead);
    *phead = NULL;
  }
  else
  {
    SLTNode* tail = *phead;
    while (tail->next->next)
    {
      tail = tail->next;
    }
    free(tail->next);
    tail->next = NULL;
  }
}
//头插
void SLTPushFront(SLTNode** phead, SLTDataType x)
{
  SLTNode* newnode = BuySLTNode(x);
  newnode->next = *phead;
  *phead = newnode;
}
//头删
void SLTPopFront(SLTNode** phead)
{
  assert(*phead);
  SLTNode* next = (*phead)->next;
  free(*phead);
  *phead = next;
}
//查找数据指定位置pos
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
  SLTNode* cur = phead;
  while (cur)
  {
    if (cur->data == x)
    {
      return cur;
    }
    cur = cur->next;
  }
}
//在pos位置之后插入x
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
  assert(pos);
  SLTNode* newnode = BuySLTNode(x);
  newnode->next = pos->next;
  pos->next = newnode;
}
//在pos位置之前插入x
void SListInsert(SLTNode** phead, SLTNode* pos, SLTDataType x)
{
  assert(pos);
  if (*phead == pos)
  {
    SLTPushFront(phead, x);
  }
  else
  {
    SLTNode* prev = *phead;
    while (prev->next != pos)
    {
      prev = prev->next;
    }
    SLTNode* newnode = BuySLTNode(x);
    prev->next = newnode;
    newnode->next = pos;
  }
}
//删除pos位置之后的值
void SListEraseAfter(SLTNode* pos)
{
  assert(pos);
  if (pos->next == NULL)
  {
    return;
  }
  else
  {
    /*free(pos->next);
    pos->next = pos->next->next;*///错误,释放了后一个,这个空间被置为随机值,找不到后面的结点
    SLTNode* nextNode = pos->next;
    pos->next = nextNode->next;
    free(nextNode);
  }
}
//删除pos位置
void SListErase(SLTNode** phead, SLTNode* pos)
{
  assert(pos);
  if (pos == *phead)
  {
    SLTPopFront(phead);
  }
  else
  {
    SLTNode* prev = *phead;
    while (prev->next != pos)
    {
      prev = prev->next;
    }
    prev->next = pos->next;
    free(pos);
  }
}
//单链表的释放
void SLTDestory(SLTNode** phead)
{
  SLTNode* cur = *phead;
  while (cur)
  {
    SLTNode* next = cur->next;
    free(cur);
    cur = next;
  }
  *phead = NULL;//plist置空,防止释放后再调用
}

3、test.c测试文件

#include"SList.h"
void TestSList1()
{
  //SLTNode* n1 = malloc();//直接用malloc需要自行赋值,检查空,很烦,所以封装一个函数
  SLTNode* n1 = BuySLTNode(1);
  SLTNode* n2 = BuySLTNode(2);
  SLTNode* n3 = BuySLTNode(3);
  SLTNode* n4 = BuySLTNode(4);
  n1->next = n2;
  n2->next = n3;
  n3->next = n4;
  n4->next = NULL;
  //SLTNode n1;//为什么不直接定义结构体变量
  //SLTNode n2;
  //n1.next = &n2;//这样也可以链接,但是不可行
  //SLTNode* plist = CreateSList(5);
  //SLTPrint(plist);
}
//初始测试代码
void TestSList2()
{
  SLTNode* plist = CreateSList(5);
  SLTPushBack(&plist, 100);
  SLTPushBack(&plist, 200);
  SLTPushBack(&plist, 300);
  SLTPrint(plist);
}
void TestSList3()
{
  SLTNode* plist = NULL;
  SLTPushBack(&plist, 100);
  SLTPushBack(&plist, 200);
  SLTPushBack(&plist, 300);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
}
void TestSList4()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 100);
  SLTPushFront(&plist, 200);
  SLTPushFront(&plist, 300);
  SLTPushFront(&plist, 400);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
}
void TestSList5()
{
  SLTNode* plist = NULL;
  SLTPushBack(&plist, 1);
  SLTPushBack(&plist, 2);
  SLTPushBack(&plist, 3);
  SLTPushBack(&plist, 4);
  SLTPushBack(&plist, 5);
  SLTPrint(plist);
  SLTNode* pos = SListFind(plist, 3);
  SListInsertAfter(pos, 30);
  pos = SListFind(plist, 2);
  SListInsert(&plist, pos, 200);
  SLTPrint(plist);
  //  if (pos)
  //  {
  //    SListInsertAfter(pos, 30);//找到之后在后面插入30
  //    printf("找到了\n");
  //
  //  }
  //  else
  //  {
  //    printf("找不到\n");
  //  }
  //  SLTPrint(plist);
}
void TestSList6()
{
  SLTNode* plist = NULL;
  SLTPushBack(&plist, 1);
  SLTPushBack(&plist, 2);
  SLTPushBack(&plist, 3);
  SLTPushBack(&plist, 4);
  SLTPushBack(&plist, 5);
  SLTPrint(plist);
  SLTNode* pos = SListFind(plist, 3);
  SListEraseAfter(pos);
  SLTPrint(plist);
  pos = SListFind(plist, 3);
  SListErase(&plist,pos);
  pos = NULL;
  SLTPrint(plist);
  SLTDestory(&plist);
  SLTPrint(plist);
}
int main()
{
  //TestSList1();
  //TestSList2();
  //TestSList3();
  //TestSList4();
  //TestSList5();
  TestSList6();
  return 0;
}
////二级指针经典例子
//void Swap1(int* p1, int* p2)
//{
//  int tmp = *p1;
//  *p1 = *p2;
//  *p2 = tmp;
//}
//void Swap2(int** pp1, int** pp2)
//{
//  int tmp = *pp1;
//  *pp1 = *pp2;
//  *pp2 = tmp;
//}
//
//int main()
//{
//  int a = 0, b = 1;
//  swap1(&a, &b);
//  
//  int* ptr1 = &a, * ptr2 = &b;
//  swap2(&ptr1, &ptr2);
//
//  return 0;
//
//}

注意:

如果不用二级指针,我们可以用返回值,但是每次返回得接收,c++中可以用引用

不需要修改头指针就用一级,需要修改就用二级,必须将实参的地址传给形参


结语:

这里本章内容就介绍完了,文章中某些内容我们之前有介绍,所以只是一笔带过,还请谅解。希望以上内容对大家有所帮助👀,如有不足望指出🙏

前路漫漫!努力变强💪💪 吧!!


相关文章
|
2月前
|
C语言
【数据结构】栈和队列(c语言实现)(附源码)
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表,遵循“先进后出”原则;队列则在一端插入、另一端删除,遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现,并提供了完整的代码示例。栈和队列在实际应用中非常广泛,如二叉树的层序遍历和快速排序的非递归实现等。
266 9
|
3月前
|
存储 C语言
【C语言篇】深入理解指针3(附转移表源码)
【C语言篇】深入理解指针3(附转移表源码)
53 1
|
2月前
|
存储 搜索推荐 算法
【数据结构】树型结构详解 + 堆的实现(c语言)(附源码)
本文介绍了树和二叉树的基本概念及结构,重点讲解了堆这一重要的数据结构。堆是一种特殊的完全二叉树,常用于实现优先队列和高效的排序算法(如堆排序)。文章详细描述了堆的性质、存储方式及其实现方法,包括插入、删除和取堆顶数据等操作的具体实现。通过这些内容,读者可以全面了解堆的原理和应用。
118 16
|
2月前
|
搜索推荐 算法 C语言
【排序算法】八大排序(下)(c语言实现)(附源码)
本文继续学习并实现了八大排序算法中的后四种:堆排序、快速排序、归并排序和计数排序。详细介绍了每种排序算法的原理、步骤和代码实现,并通过测试数据展示了它们的性能表现。堆排序利用堆的特性进行排序,快速排序通过递归和多种划分方法实现高效排序,归并排序通过分治法将问题分解后再合并,计数排序则通过统计每个元素的出现次数实现非比较排序。最后,文章还对比了这些排序算法在处理一百万个整形数据时的运行时间,帮助读者了解不同算法的优劣。
165 7
|
2月前
|
搜索推荐 算法 C语言
【排序算法】八大排序(上)(c语言实现)(附源码)
本文介绍了四种常见的排序算法:冒泡排序、选择排序、插入排序和希尔排序。通过具体的代码实现和测试数据,详细解释了每种算法的工作原理和性能特点。冒泡排序通过不断交换相邻元素来排序,选择排序通过选择最小元素进行交换,插入排序通过逐步插入元素到已排序部分,而希尔排序则是插入排序的改进版,通过预排序使数据更接近有序,从而提高效率。文章最后总结了这四种算法的空间和时间复杂度,以及它们的稳定性。
137 8
|
2月前
|
C语言
【数据结构】二叉树(c语言)(附源码)
本文介绍了如何使用链式结构实现二叉树的基本功能,包括前序、中序、后序和层序遍历,统计节点个数和树的高度,查找节点,判断是否为完全二叉树,以及销毁二叉树。通过手动创建一棵二叉树,详细讲解了每个功能的实现方法和代码示例,帮助读者深入理解递归和数据结构的应用。
161 8
|
2月前
|
C语言 Windows
C语言课设项目之2048游戏源码
C语言课设项目之2048游戏源码,可作为课程设计项目参考,代码有详细的注释,另外编译可运行文件也已经打包,windows电脑双击即可运行效果
44 1
|
2月前
|
存储 C语言
【数据结构】手把手教你单链表(c语言)(附源码)
本文介绍了单链表的基本概念、结构定义及其实现方法。单链表是一种内存地址不连续但逻辑顺序连续的数据结构,每个节点包含数据域和指针域。文章详细讲解了单链表的常见操作,如头插、尾插、头删、尾删、查找、指定位置插入和删除等,并提供了完整的C语言代码示例。通过学习单链表,可以更好地理解数据结构的底层逻辑,提高编程能力。
130 4
|
2月前
|
存储 C语言
【数据结构】顺序表(c语言实现)(附源码)
本文介绍了线性表和顺序表的基本概念及其实现。线性表是一种有限序列,常见的线性表有顺序表、链表、栈、队列等。顺序表是一种基于连续内存地址存储数据的数据结构,其底层逻辑是数组。文章详细讲解了静态顺序表和动态顺序表的区别,并重点介绍了动态顺序表的实现,包括初始化、销毁、打印、增删查改等操作。最后,文章总结了顺序表的时间复杂度和局限性,并预告了后续关于链表的内容。
95 3
|
3月前
|
存储 C语言
C语言单链表实现
一个用C语言编写的简单学生信息管理系统,该系统具备信息输入、成绩计算、排序、删除、查找、修改、保存和读取文件等功能。
35 0
C语言单链表实现