单链表的定义和操作(超详细——C语言)

已于 2022-10-16 11:04:22 修改
阅读量3k 收藏 37
点赞数 4
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-10-15 11:43:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47783699/article/details/127303630
版权

一、链表的概念

  定义：

         链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

   特点：

           链表是一系列节点组成，节点在运行时动态生成（malloc），每一个节点包括两个部分。

     一 个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域


 链表是一种线性存储结构,线性存储结构又可分两类：

        一类是 顺序存储结构（即 数组的存储方式），其特点是是逻辑关系上相邻的两个元素在物理位置上也相邻，即在连续的地址块中存储一系列数据。

         一类是 链式存储结构（链表的存储方式），其特点为不需要逻辑上相邻的元素在物理位置上也相邻，即在不连续的地址中存储一系列数据 ，所以链表不能向数组一样通过下标随机访问。

那么链表之间的元素又是如何相互关联的呢？

        它是由一系列的存储数据元素的单元通过指针串接来确定元素之间相互关系的,因此每个单元至少都有两个域—数据域和指针域，这样的单元也被称为节点(Node)。

二、为什么要用链表

     我们学完c语言之后，我们至少可以通过两种结构来存储数据，一种是“数组”，另外一种是“链表”。为什么还要学习链表呢，因为数组是连续的。

          1、数组的缺点

      1）因为他是连续。内存需要一块连续的空间。如果存储数据大的话，系统必须得找一块连续且大的空闲空间，如果找不到，就分配不成功。     

      2）数组不可以插入，删除里面的元素，满足不了我们项目的需求。                               

       3）数组存放数据时，必须事先定义固定的长度                               

           2、链表的优点 

       1）链表不需要连续地分配内存空间，每一个元素之间不是连续而是分开的，所以不需要很大的内存空间。

       2）链表可以插入，删除和添加等操作，且效率高

       3） 链表不需要像数组预先指定空间的长度，可以现用现分配。

            3、链表的缺点

        1）由于链表的每一个元素里面都有一个地址。相对而已，会占用比较多的内存，空间的开销会比较大。 

三、链表分类

链表可大致分为

        1）单链表（最普通的链表）

        2）双向链表（有两个指针域）

        3）循环链表（首尾相接）

        4）静态链表（链表的数组表示法）

四、链表的构成：（以上图为例）

#define MAX 20                  
typedef struct Node｛           //  Node 结构体名，可以随便去，但不能是关键字
   
     int data;
     strutc Node *next;

}linkList;                          //linkList 等效于 struct Node

 五，链表的操作

 1、链表的创建CreateLinkList

#include<stdio.h>
#include<srdlib.h>

#define ERROR O
#define  OK   1
//初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
typedef struct Node         
{
   //数据域
     int data;         

   //指针域
     struct Node *next;
}STU;

 
 STU * CreateLinkList(void)         
{
   STU * head = NULL;
 
   head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
   if(head==NULL)
  {
     exit(0);
   }
    head ->next = NULL;
    return head;
}

2、 链表赋值

#include<stdio.h>
#include<stdlib.h>


#define ERROR O
#define  OK   1
//初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
typedef struct Node         
{
   //数据域
     int data;         

   //指针域
     struct Node *next;
}STU;

 

 
 STU * CreateLinkList(void)         
{
   STU * head = NULL;
 
   head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
   if(head==NULL)
  {
      exit(0);
   }
    head ->next = NULL;
    return head;
}


void PrintList(STU *head)      //封装打印链表函数
{
   STU *pmove = head->next;       
    while(pmove)
  {
    printf("%d",pmove->data);     
    pmove=pmove->next;
  }   
   
    printf("\n");
   
}

 
   int nmain()
{
    int i=0;
    int num=0;
    STU * link = NULL;
    STU * p_new = NULL;
    link= CreateLinkList();
    printf("请输入链表的初始个数：\n");
    scanf("%d\n",&num);
    for(i=0;i<num;i++)
   {
      p_new=(STU *)malloc(sizeof(STU));
      printf("请输入数据：\n");
      scanf("%d\n",&p_new->data);
    }      
   
     PrintList(link);

    return 0;
}

3、创建新的单个节点 CreateNode


STU *CreateNode(int data)
{
   STU * newhead = ( STU *)malloc(sizeof(STU));

   newhead->data=data;
   newhead->next=NULL;
   
   return newhead;
}

4、打印链表PrintList()

void PrintList(STU *head)
{

   STU *pmove = head->next;   //头结点数据是0，因此，从头结点下一个数据开始打印，即head->next
    
     while(pmove)
  {
    printf("%d",pmove->data);     
    pmove=pmove->next;
  }   
   
    printf("\n");
   
}

5、插入节点（头插法）


STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
                                   //方便使用
{
   STU * newhead = ( STU *)malloc(sizeof(STU));

   newhead->data=data;
   newhead->next=NULL;
   
   return newNode;
}

void InsertHeadNode(STU *head,int data)
{
    STU * newNode =CreateNode(int data); 

    newNode->next = head->next;
    head-> = newNode;


}

5.1简单的头插法使用（完整代码）

#include<stdio.h>
#include<stdlib.h>

#define ERROR O
#define  OK  1
//初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
typedef struct Node         
{
   //数据域
     int data;         

   //指针域
     struct Node *next;
}STU;

STU * CreateLinkList()         
{
   STU * head = NULL;
 
   head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
   if(head==NULL)
  {
     exit(0);
   }
    head ->next = NULL;
    return head;
}

STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
                                   //方便使用
{
   STU * newNode = ( STU *)malloc(sizeof(STU));

   newNode->data=data;
   newNode->next=NULL;
   
   return newNode;
}

void InsertHeadNode(STU *head,int data)
{
    STU * newNode =CreateNode(data); 

    newNode->next = head->next;
    head->next=newNode;
    
}

void PrintList(STU *head)
{

   STU *pmove = head->next;       
    while(pmove)
  {
    printf("%d",pmove->data);     
    pmove=pmove->next;
  }   
   
    printf("\n");
   
}
  int main()
  {
      
    int i;
    STU *link=NULL;
    link =CreateLinkList();
      
   InsertHeadNode(link, 1);
   InsertHeadNode(link, 2);
   InsertHeadNode(link, 3);
   InsertHeadNode(link, 4);
   PrintList(link);     
      
     return 0; 
      
  }

运行结果

4321

 6、链表插入（中间插入）

//在哪个表插入，第几个位置，插入什么数据
void InsertNode(STU *head,int where，int data)  
{
    int k=0;
    STU *q=head;
    STU * newNode2 =CreateNode(int data); 
 
   for( k ; k<where ; k++)
  {
    if(q==NULL)
   {
    printf("create  q fail\n");
     exit(0);
   }
      q =q->next;
 
  }

    newNode2->next = q->next;
      
     q->next = newNode2;


}

6.1简单的插入（中间）法使用（完整代码）

#include<stdio.h>
#include<stdlib.h>

#define ERROR O
#define  OK  1
//初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
typedef struct Node         
{
   //数据域
     int data;         

   //指针域
     struct Node *next;
}STU;

STU * CreateLinkList()         
{
   STU * head = NULL;
 
   head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
   if(head==NULL)
  {
     exit(0);
   }
    head ->next = NULL;
    return head;
}

STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
                                   //方便使用
{
   STU * newNode = ( STU *)malloc(sizeof(STU));

   newNode->data=data;
   newNode->next=NULL;
   
   return newNode;
}

void InsertHeadNode(STU *head,int data)
{
    STU * newNode =CreateNode(data); 

    newNode->next = head->next;
    head->next=newNode;
    
}

void PrintList(STU *head)
{

   STU *pmove = head->next;       
    while(pmove)
  {
    printf("%d",pmove->data);     
    pmove=pmove->next;
  }   
   
    printf("\n");
   
}
//在哪个表插入，第几个位置，插入什么数据
void InsertNode(STU *head,int data)  
{
    int k=0;
    int num;
    STU *q=head;
    STU * newNode2 = CreateNode(data); 
    printf("请输入插入中间第几个数：\n");
    scanf("%d",&num);
    
  for(k=1; k<=num;k++)
  {
    if(q==NULL)
   {
    printf("create  q fail\n");
     exit(0);
   }
      q =q->next;
  }

    newNode2->next = q->next;
      
     q->next = newNode2;
}
  int main()
  {
      
    int i;
    STU *link=NULL;
    link =CreateLinkList();
      
   InsertHeadNode(link, 1);
   InsertHeadNode(link, 2);
   InsertHeadNode(link, 3);
   InsertHeadNode(link, 4);
   PrintList(link);  
   InsertNode(link,9);  
   PrintList(link);     
     return 0; 
      
  }

 7、链表查找（查找int类型的数据）

STU * link_search_num(STU *head,int data)
  {           
         STU * pmove = head;

        whlie(pmove != NULL)
       {

                                   //如果找到是当前结点数据，则返回当前结点的地址
           if(pmove->data==data)
 
          {
             return pmove;
          }
                                  //如果没有找到，则继续对比下一个结点的指针域
             pmove=pmove->next;
           
        }
                                   //当循环结束的时候还没有找到，返回一个NULL给主函数
            return NULL;           //没有找到
     }

 7.1链表查找（查找char类型的数据）

typedef struct Node         
{
   //数据域
     int data;         
     char name[20]; 
   //指针域
     struct Node *next;
}STU;


STU * link_search_name(STU *head,char *name)
  {           
         STU * pmove = head;

        whlie(pmove != NULL)
       {

                                           //如果找到是当前结点数据，则返回当前结点的地址
           if(strcmp(pmove->name,name)==0) //找到了
          {
             return pmove;
          }
          
                                           //如果没有找到，则继续对比下一个结点的指针域
             pmove=pmove->next;

        }
                                        //当循环结束的时候还没有找到，返回一个NULL给主函数
            return NULL;                 //没有找到
     }

7.2简单链表查找使用（完整代码）

#include<stdio.h>
#include<stdlib.h>

#define ERROR O
#define  OK  1
//初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
typedef struct Node         
{
   //数据域
     int data;         

   //指针域
     struct Node *next;
}STU;

STU * CreateLinkList()         
{
   STU * head = NULL;
 
   head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
   if(head==NULL)
  {
     exit(0);
   }
    head ->next = NULL;
    return head;
}

STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
                                   //方便使用
{
   STU * newNode = ( STU *)malloc(sizeof(STU));

   newNode->data=data;
   newNode->next=NULL;
   
   return newNode;
}

void InsertHeadNode(STU *head,int data)
{
    STU * newNode =CreateNode(data); 

    newNode->next = head->next;
    head->next=newNode;
    
}

void PrintList(STU *head)
{

   STU *pmove = head->next;       
    while(pmove)
  {
    printf("%d",pmove->data);     
    pmove=pmove->next;
  }   
   
    printf("\n");
   
}
STU * link_search_num(STU *head,int data)
  {           
         STU * pmove = head;

        while(pmove != NULL)
       {
 
                                 //如果找到是当前结点数据，则返回当前结点的地址
           if(pmove->data==data)
 
          {
             return pmove;
          }
           
                                 //如果没有找到，则继续对比下一个结点的指针域
             pmove=pmove->next;
        }
                                  //当循环结束的时候还没有找到，返回一个NULL给主函数
            return NULL;           //没有找到
    }

  int main()
  {
      
    int i;
    STU *link=NULL;
    STU *p =NULL;
    link =CreateLinkList();
      
   InsertHeadNode(link, 1);
   InsertHeadNode(link, 2);
   InsertHeadNode(link, 3);
   InsertHeadNode(link, 4);
   PrintList(link); 
   p=link_search_num(link,3);    // 查找3这个数据 
  if(p !=NULL)
  {	  
   printf("%d\n",p->data);        //打印查找的数据   
  }
  else
  {
	  printf("没有这个数据\n");
   }	
	  return 0; 
      
  }

运行结果

4321
3

 8、链表的删除某个数据

int dellte_List(STU *head,int deldata)
 { 

 //定义两个指针，一个指该删除数据前一个结点（ppre），一个指向该删除数据的结点（pp）
     STU *pp = head->next; 
      
      STU *ppre = head;          

    while(pp != NULL)
    {
  
       pp= pp->next;
       ppre=ppre->next;

      if(pp->data==deldata)
      {
         break;
        }
	 }
       if(!pp)          //如果p是有该数据，则为真。！p则为假，就不会执行
      {
        return 0;
      }
        ppre->next = pp->next;
         free(pp); 
        return 1;
     }

删除操作示意图 

 8.1简单删除操作使用

#include<stdio.h>
#include<stdlib.h>

#define ERROR O
#define  OK  1
//初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
typedef struct Node         
{
   //数据域
     int data;         

   //指针域
     struct Node *next;
}STU;

STU * CreateLinkList()         
{
   STU * head = NULL;
 
   head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
   if(head==NULL)
  {
     exit(0);
   }
    head ->next = NULL;
    return head;
}

STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
                                   //方便使用
{
   STU * newNode = ( STU *)malloc(sizeof(STU));

   newNode->data=data;
   newNode->next=NULL;
   
   return newNode;
}

void InsertHeadNode(STU *head,int data)
{
    STU * newNode =CreateNode(data); 

    newNode->next = head->next;
    head->next=newNode;
    
}

void PrintList(STU *head)
{

   STU *pmove = head->next;                          //头结点数据是0，因此，从头结点下一个数据开始打印，即head->next
    while(pmove)
  {
    printf("%d",pmove->data);     
    pmove=pmove->next;
  }   
   
    printf("\n");
   
}
STU * link_search_num(STU *head,int data)
  {           
         STU * pmove = head;

        while(pmove != NULL)
       {

          //如果找到是当前结点数据，则返回当前结点的地址
           if(pmove->data==data)
 
          {
             return pmove;
          }
           
            //如果没有找到，则继续对比下一个结点的指针域
             pmove=pmove->next;
        }
             //当循环结束的时候还没有找到，返回一个NULL给主函数
            return NULL;           //没有找到
    }
int dellte_List(STU *head,int deldata)
 { 

 //定义两个指针，一个指该删除数据前一个结点（ppre），一个指向该删除数据的结点（pp）
     STU *pp = head->next; 
      
      STU *ppre = head;          

    while(pp != NULL)
    {
  
       pp= pp->next;
       ppre=ppre->next;

      if(pp->data==deldata)
      {
         break;
        }
	 }
       if(!pp)          //如果p是有该数据，则为真。！p则为假，就不会执行
      {
        return 0;
      }
        ppre->next = pp->next;
         free(pp); 
        return 1;
     }

  int main()
  {
      
    int i;
    STU *link=NULL;
    STU *p =NULL;
    link =CreateLinkList();
      
   InsertHeadNode(link, 1);
   InsertHeadNode(link, 2);
   InsertHeadNode(link, 3);
   InsertHeadNode(link, 4);
   PrintList(link); 
   p=link_search_num(link,3);    
  if(p !=NULL)
  {	  
   printf("%d\n",p->data);//打印查找的数据   
  }
  else
  {
	  printf("没有这个数据\n");
   }
    dellte_List(link,3);
	 PrintList(link); 
	  return 0; 
      
  }

 运行结果

4321
3
421

9、链表的反转ReverseList()

int ReverseList(STU *h)
 {
    STU  *q =NULL;
    STU  *p =NULL;
    if(h==NULL)
  {
     printf("h 是创建失败\n");  //失败不是空表，是没有这个h的头指针
     return 0;
  }   

                         // h->next ==NULL：只有一个头指针，没结点，即空表，反过来还是一样的
                         // h->next->next ==NULL：只有一个结点，反过来还是一样的
  if( h->next ==NULL || h->next->next ==NULL)
 {
   return 1;

  }
   p = h->next->next;        //p指向原来链表的第二个结点
                            
   h->next->next =NULL;      //把链表一分为二，h指向的链表只有一个结点。即原来的链表的第一个结点
  
while(p!=NULL)
{ 
   q = p;
   p=p->next;
   
   q->next=h->next;
   h->next= q;
 }
    return 0;
  }

9.1简单的链表反转使用（完整代码）

#include<stdio.h>
#include<stdlib.h>

#define ERROR O
#define  OK  1
//初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
typedef struct Node         
{
   //数据域
     int data;         

   //指针域
     struct Node *next;
}STU;

STU * CreateLinkList()         
{
   STU * head = NULL;
 
   head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
   if(head==NULL)
  {
     exit(0);
   }
    head ->next = NULL;
    return head;
}

STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
                                   //方便使用
{
   STU * newNode = ( STU *)malloc(sizeof(STU));

   newNode->data=data;
   newNode->next=NULL;
   
   return newNode;
}

void InsertHeadNode(STU *head,int data)
{
    STU * newNode =CreateNode(data); 

    newNode->next = head->next;
    head->next=newNode;
    
}

void PrintList(STU *head)
{

   STU *pmove = head->next;       
    while(pmove)
  {
    printf("%d",pmove->data);     
    pmove=pmove->next;
  }   
   
    printf("\n");
   
}
int ReverseList(STU *h)
 {
    STU  *q =NULL;
    STU  *p =NULL;
    if(h==NULL)
  {
     printf("h 是创建失败\n");  //失败不是空表，是没有这个h的头指针
     return 0;
  }   

                         // h->next ==NULL：只有一个头指针，没结点，即空表，反过来还是一样的
                         // h->next->next ==NULL：只有一个结点，反过来还是一样的
  if( h->next ==NULL || h->next->next ==NULL)
 {
   return 1;

  }
   p = h->next->next;        //p指向原来链表的第二个结点
                            
   h->next->next =NULL;      //把链表一分为二，h指向的链表只有一个结点。即原来的链表的第一个结点
  
while(p!=NULL)
{ 
   q = p;
   p=p->next;
   
   q->next=h->next;
   h->next= q;
 }
    return 0;
  }
  int main()
  {
      
    int i;
    STU *link=NULL;
    link =CreateLinkList();
      
   InsertHeadNode(link, 1);
   InsertHeadNode(link, 2);
   InsertHeadNode(link, 3);
   InsertHeadNode(link, 4);
   PrintList(link);     
   ReverseList(link);
   PrintList(link);   
     return 0; 
      
  }

运行结果

4321
1234

个人总结，适合小白学习，如有错误，请留下指正，谢谢。

坏坏太兲眞
关注
  • 4
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
汽车租赁管理系统———c语言课程设计.doc
12-19
汽车租赁管理系统———c语言课程设计 本系统是一个基于C语言的汽车租赁管理系统，旨在提供一个便捷的汽车租赁服务管理平台。该系统主要实现了汽车的查询、租赁和管理功能。 结构体定义 在该系统中，使用了三个...
数据结构-单链表删除绝对值相同的元素-c语言代码
11-07
在本文中，我们将深入探讨如何使用C语言实现一个数据结构操作——删除单链表中绝对值相同的元素。首先，我们要了解单链表的基本概念。单链表是一种线性数据结构，其中每个节点包含一个数据域和一个指向下一个节点的...
数据结构入门指南：链表（新手避坑指南）
2202_75605090的博客
07-30 6082
前边我们学习了顺序表，顺序表是数据结构中最简单的一种线性数据结构，今天我们来学习链表，难度相较于顺序表会大幅增加，非常考验大家对结构体、指针的理解。但是也不要害怕，我会一一向大家解答疑惑，本期的内容先给初学者预预热，主要介绍在刚开始实现链表时注意的点以及逻辑基础，下期会将功能接口具体实现。}SLNode;定义链表这里就迎来了第一个坑，上述的这种形式很常见，对于初学者来说这里就有一个坑，这个链表定义的是否正确呢？这种方式是不正确的，为什么？
链表详解（附有C语言详细代码）
Weirdo的博客
06-06 1902
在C语言中，可以使用结构体来定义链表节点。每个节点包含一个数据域（data）和一个指针域（next），其中指针域指向下一个节点。int data;// 数据域// 指针域} Node;链表作为一种重要的数据结构，具有动态分配、插入和删除操作方便等特点。通过定义节点结构、链表初始化、插入节点、删除节点和遍历链表等基本操作，可以实现链表的基本功能。此外，链表还有查找节点、反转链表、链表排序等扩展操作。链表在实际应用中具有广泛的应用场景，如文件存储、网络路由、哈希表冲突解决和LRU缓存淘汰策略等。
单链表之基本操作代码————实现版（C语言）
A979749的博客
11-21 432
单链表操作
数据结构-单链表基本操作——C语言
weixin_50490968的博客
04-24 3066
一、按位插入（带头结点）ListInsert(&l,i,e) Tips：(此时是 i=1 的情况，插在表头，不执行while循环 ) //在第i个位置插入元素 e （带头结点） typedef struct LNode{ //单链表结构定义 ElemType data; //存放数据域 struct LNode *next; //指针域 }LNode,*LinkList; { /* data */ }; boo
C语言——单链表
qq_62755767的博客
11-23 5310
一，链表的定义 链表是一种常见的采用动态存储分配方式的数据结构。在链表中，有一个头指针变量，用这个指针保存一个地址，头指针指向一个变量，这个变量称为元素。链表中，每一个元素包括两部分：数据部分和指针部分。数据部分用来存放元素中包含的数据，指针部分用来指向下一个元素 。（最后一个元素指向NULL） 在链表中，第一个结点前虚假一个头结点，头指针指向头结点，头结点的指针域指向第一个实际有效结点，该节点可以称为首元结点。 确定一个链表需要一个参数：头指针，通过头指针可以推算出链表其他所有的参数 二，单链表
有序单链表插入——C语言
New_Teen的博客
05-07 3435
以下内容要求有一定指针和链表基础，请配合画图理解 1.首先我们定义一个头文件（slink.h），用来声明链表的结点数据类型，以及相关函数 /* ** 定义一个有序单链表的操作接口 */ #include <malloc.h> //动态分配内存声明文件 #include <assert.h> //断言函数声明文件 #include <stdio.h> //标准输入输出声明文件 #define LINK_TYPE int //链表存储数据类型 /* ** 定义结点数
数据结构——单链表详解（C语言实现）
sinzz的博客
03-08 1274
首先，我们需要知道，单链表内所需要的数据有两种，一种是数据，还有就是下一个节点的指针。所以我们需要定义一个结构体。//重命名单链表的数据 //便于不同数据类型的切换 typedef struct SLTNode {//SLTNode* next//错误 //改写法C语言是不支持的 //struct SLTNode//错误 } SLTNode;
单链表——c语言
HBINen的博客
03-10 2795
c语言实现单链表的基本操作，简单易懂，内有gif图帮助理解
单链表的基本功能实现———C语言
熙光的博客
04-13 110
本人在学C语言链表的时候总是找不到合适的基本代码， 现在整理为完整的代码供大伙参考。 以下是带头结点的情况。 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct{ char ISBN[40]; char name[40]; int price; }Book; typedef struct LNode{ //定义单链表结点类型 Book da.
单链表的创建及相关操作——入门级
qq_21493707的博客
03-14 1379
本文我们将学习单链表的创建以及相关操作。使用c语言实现，结尾有全部代码。 （仅供正在学习的朋友参考，如有错误的地方，欢迎评论指出。）
数据结构——单链表的具体操作
12-22
1. 实现单链表的定义和操作。该程序包括单链表结构类型以及对单链表 操作的具体的函数定义。 2. 程序中的单链表（带头结点）结点为结构类型，结点值为整型。 3. 本程序完成单链表的生成，任意位置的插入、删除，...
C语言——约瑟夫问题.zip
07-13
在这个问题中，我们可以利用C语言中的结构体来创建一个单链表，每个节点代表圈中的一人，节点中包含两个字段：编号（对应人的位置）和指针（指向下一个节点）。链表的头节点表示计数的起点。 以下是实现约瑟夫问题...
数据结构---线性表之单链表（C语言）
03-28
在C语言中，首先需要定义一个结构体来表示链表的节点，通常包含两部分：数据域和指针域。例如： ```c typedef struct Node { int data; // 数据域 struct Node* next; // 指针域，指向下一个节点 } ListNode; ``` ...
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1489
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1220
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 415
对于二分搜索的理论与实现的知识点学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值