C语言单链表（超级无敌详细，408考研同样适用）

已于 2023-09-09 10:56:10 修改
阅读量263 收藏 5
点赞数 3
分类专栏： 数据结构 文章标签： c语言 考研 开发语言 链表 数据结构 c++
于 2023-07-14 08:08:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74036487/article/details/131715360
版权

单链表

顺序表的存储位置可以用一个简单直观的公式表示，它可以随机存取表中任意一个元素，但插入和删除操作需要移动大量元素。链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起元素之间的逻辑关系，因此插入和删除操作不需要移动元素，而只需修改指针，但也会失去顺序表可随机存取的优点。

请添加图片描述
请添加图片描述

1 定义链表结构

线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。单链表结点结构如下代码所示，其中 data 为数据域，存放数据元素;next为指针域，存放其后继结点的地址

定义一个结构体来实现单链表
typedef 关键字的作用相当于起别名

有关结构体的定义，可以看看我的这篇博客c++结构体的定义

c语言也适用

typedef struct LNode {
	int data;               //单链表节点类型，即存放的数据类型
	struct LNode* next;     //指针指向下一个节点
}LNode,*LinkList;
//等价于
//struct LNode
//{
//	int data;
//	struct LNode* next;
//};
//typedef struct LNode LNode;    LNode是struct LNode的别名
//typedef struct LNode* LinkLIst;  LinkLIst 是struct LNode*的别名
//别名与本名功能一模一样，都可以用来定义变量，效果一样
//这里注意 Lnode* 与LinkList是等价的

别名与本名功能一模一样，都可以用来定义变量，效果一样
这里注意 Lnode* 与LinkList是等价的

2 链表的初始化

bool InitalList(LinkList& L){
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)return false;  //内存不足，申请失败

	L->next = NULL;//头结点之后还没有新的结点，所以传空
                  //会有人疑问为什么没有给头结点的data赋值
	    //因为头结点不参与保存数据，只是为了方便操作链表额外添加           的虚拟头结点

	return true;

}

3 头插法创建单链表

因为每次创建新结点的时间复杂度是O(1),所以总时间复杂度为O(n)

看图

数字代表代码运行的先后步骤
请添加图片描述

大致思路就是，每一次新创建的结点，都让他指向上一次的结点，即每次创建的结点都是最新的头指针，最终发现是一个反向的链表，先存入的数据会在末尾，最晚存储的数据是头指针

因为L->next实际指向的就是上一次的结点,所以我们让s->next指向L->next

达到了让新结点指向上一次结点的功能

然后将L->next指向s 达到刷新的效果，让L->next始终指向的是上一次的结点

到最后因为没有新结点，L->next指向的就是头指针，L自己就是头结点

整个过程中L是没有变化的，发生变化的一直是L->next；

void BuildListHead(LinkList& L) {
	LNode* s=L;  
	
	int x;   //输入的值 规定当输入-1时结束创建
	scanf_s("%d", &x);
	while (x != -1) {
		 s = (LNode*)malloc(sizeof(LNode));  //为链表申请新空间
		 s->data = x;
		 s->next = L->next;
		 L->next = s;
		 scanf_s("%d", &x);

	}
}

注意头插法是有缺陷的，它的存入顺序和链表节点是相反的，我们使用时可能会不方便，所以我们通常使用接下来介绍的尾插法

4 尾插法创建单链表

在这特意感谢王学姐对尾插法的指点

同头插法因为每次创建新结点的时间复杂度是O(1),所以总时间复杂度为O(n)

看图

请添加图片描述

思路是,我们选择s为新来的结点，让r作为链表每次的尾节点，新创建一个结点，就让 r->next=s 来指向新结点，然后让 r=s 使新节点成为尾节点

r->next=s 的功能是实现了链表在地址上的链接指向，使每次的尾节点都指向新的结点

r=s 的功能实现了，让每次的新节点都作为新的尾节点

void BuildListTail(LinkList& L) {
	LNode* s, * r = L;
	int x;
	scanf_s("%d", &x);
	while (x != -1) {
		s = (LNode*)malloc(sizeof(LNode));

		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;   //将尾节点指向空结点
}

5 链表的查找

LinkList 强调这是一个链表
LNode* 强调返回一个节点
实际上这两种方式完全等价

代码功能很简单，就是遍历输出
但是要注意边界问题以及空指针的问题，增强代码的健壮性

LNode* GetElem(LinkList L, int i) {  //i是要找的第i个节点

	int j = 1;  //从第一个节点开始遍历

	LNode* p = L->next;

	if (i == 0)  return L;
	if (i < 0) {

		printf("第%d个节点不存在\n",i);  //说明i不合法
		return NULL;
	}  
	while (p != NULL && j < i) {   //当i==j时跳出循环
		p = p->next;
		j++;
	}
	if(i==j) return p;
	else {
		printf("第%d个节点不存在\n", i);  
		return NULL;
	}
}

6 插入操作

1 按位序插入 带头结点

​ 在第i个节点插入元素e

请添加图片描述

以图示为例，在第二个结点插入e

先遍历找到第i-1个结点，也就是第一个结点，先将e->next=a2，然后将i-1处的结点a1->next=e;，实现了链表的连接插入，注意这两步是不能颠倒顺序的

bool ListInsert(LinkList& L, int i, int e) {
	 
	if (i < 1) {
		printf("插入位置不合法");  //增强代码的健壮性
		return false;
	 }
	              //指针p指向当前扫描到的节点
	LNode* p=L;  // 现在指针p指向头结点，头结点是不保存数据的，即第0个节点
	             
	int j = 0;  //j表示p指针当前指向的是第几个节点

	while (p != NULL && j < i - 1) {   //循环找到第i-1个节点
		p = p->next;
		j++;
	}

	if (p == NULL)
		return false;  //i不合法  //增强代码的健壮性

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;  //这两句不能颠倒顺序
	p->next = s;       //若是颠倒顺序，p->next还没有使用就被更新了
	return true;

}
2 不带头结点的插入方法

他与带头结点的区别在于在第一个位置插入时需要更头结点
其他功能与带头结点的相同，为了节省代码量，这里不在展出，只展示核心代码

只展示有区别的在第一个节点位置的插入

 bool ListInsert(LinkList& L, int i, int e) {
  //在第一个位置插入e
	if (i == 1) {
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;

		s->next = L;  //让s的next指向头指针
		L = s;       //然后将头指针改为s
		             //这样就实现了将s插入到第一个位置
		return true;
	}

}

7 指定结点的前插操作

你会发现，你是没办法找到给定节点的前驱节点
你可以选择从头结点挨个开始遍历，但是效率很低，而且若是不给头结点，则直接无法实现功能
所以，你可以采取下面的新方法
复制法 ----- 偷天换日大法
将给定结点的数据赋值给你新申请的节点，将要插入的节点复制给给定结点，实现数据错位的效果

即结点没有移动，但是结点内保存的数据发生了移动

bool InsertPriorNode(LNode* p, int e) {
	if (p == NULL)
		return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = p->data;
	s->next = p->next;  //将p的所有信息复制给s  

	p->data = e;
	p->next = s;   //将要插入的节点复制给p
                   //俗称偷天换日大法
	return true;
}

8 按位序删除（带头结点）

代码的逻辑与 6 插入操作很相似

bool DeleteList(LinkList& L, int i,int& e) {

	if (i < 1) {
		printf("删除的位置不合法");  //增强代码的健壮性
		return false;
	}
	//指针p指向当前扫描到的节点
	LNode* p = L;  // 现在指针p指向头结点，头结点是不保存数据的，即第0个节点

	int j = 0;  //j表示p指针当前指向的是第几个节点

	while (p != NULL && j < i - 1) {   //循环找到第i-1个节点
		p = p->next;
		j++;
	}

	if (p == NULL||p->next==NULL)
		return false;  //增强代码的健壮性

	 LNode* q = p->next; //q结点创建的作用是为了能释放掉这一段内存空间

	   e = p->next->data;  //用e可以记录下被删除的结点保存的值，不过我觉着这一步没什么用

	   p->next = p->next->next ;// 覆盖掉p->next达到实现删除的效果,虽然有点掩耳盗铃，但是效果有了

	
	
	 free(q);//释放掉没用的空间

	return true;

}

9 删除给定结点

时间复杂度O(1)

思路同偷天换日大法
但是有如果要删除最后一个结点，这个代码是实现不了的，只能从表头开 始循环遍历
我们将给定节点的后继结点的信息复制给给定结点，然后释放掉后继节点，这样就实现了给定结点的删除

实际上是保护了后继结点的数据，覆盖了当前结点的信息，来达到实现删除的效果

如果是删除给定结点的后继，传参数的时候可以传给定结点的下一个结点,即传p->next

bool DeleteNode(LNode*p){
	if (p == NULL||p->next)return false;
	//如果p是最后一个结点，那么p->next==NULL ，p->next->next是不存在的
	LNode* q = p->next;  //q结点创建的作用是为了能释放掉这一段内存空间
	 p->data = p->next->data;
	p->next = p->next->next;
	  free(q);
	return true;
 }

10 完整代码

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

// 本博客不特殊指出，默认带头结点

// 1 定义一个结构体来实现单链表
//   typedef 关键字的作用相当于起别名
typedef struct LNode {
	int data;               //单链表节点类型，即存放的数据类型
	struct LNode* next;     //指针指向下一个节点
}LNode,*LinkList;
//等价于
//struct LNode
//{
//	int data;
//	struct LNode* next;
//};
//typedef struct LNode LNode;    LNode是struct LNode的别名
//typedef struct LNode* LinkLIst;  LinkLIst 是struct LNode*的别名
//别名与本名功能一模一样，都可以用来定义变量，效果一样
//这里注意 Lnode* 与LinkList是等价的


// 2 链表的初始化
bool InitalList(LinkList& L){
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)return false;  //内存不足，申请失败

	L->next = NULL;//头结点之后还没有新的结点，所以传空
                  //会有人疑问为什么没有给头结点的data赋值
	    //因为头结点不参与保存数据，只是为了方便操作链表额外添加的虚拟头结点

	return true;

} 

// 3 头插法创建单链表
void BuildListHead(LinkList& L) {
	LNode* s=L;  
	
	int x;   //输入的值 规定当输入-1时结束创建
	scanf_s("%d", &x);
	while (x != -1) {
		 s = (LNode*)malloc(sizeof(LNode));  //为链表申请新空间
		 s->data = x;
		 s->next = L->next;
		 L->next = s;
		 scanf_s("%d", &x);

	}

}

// 4 尾插法创建单链表
void BuildListTail(LinkList& L) {
	LNode* s, * r = L;
	int x;
	scanf_s("%d", &x);
	while (x != -1) {
		s = (LNode*)malloc(sizeof(LNode));

		s->data = x;
		r->next = s;
		r = s;
		scanf_s("%d", &x);
	}
	r->next = NULL;   //将尾节点指向空结点
}


 
// 5 链表的查找
// LinkList 强调这是一个链表
// LNode* 强调返回一个节点
// 实际上这两种方式完全等价
LNode* GetElem(LinkList L, int i) {  //i是要找的第i个节点

	int j = 1;  //从第一个节点开始遍历

	LNode* p = L->next;

	if (i == 0)  return L;
	if (i < 0) {

		printf("第%d个节点不存在\n",i);  //说明i不合法
		return NULL;
	}  
	while (p != NULL && j < i) {   //当i==j时跳出循环
		p = p->next;
		j++;
	}
	if(i==j) return p;
	else {
		printf("第%d个节点不存在\n", i);  
		return NULL;
	}
}


// 6 插入操作 按位序插入  带头结点
//   在第i个节点插入元素e
bool ListInsert(LinkList& L, int i, int e) {
	 
	if (i < 1) {
		printf("插入位置不合法");  //增强代码的健壮性
		return false;
	 }
	              //指针p指向当前扫描到的节点
	LNode* p=L;  // 现在指针p指向头结点，头结点是不保存数据的，即第0个节点
	             
	int j = 0;  //j表示p指针当前指向的是第几个节点

	while (p != NULL && j < i - 1) {   //循环找到第i-1个节点
		p = p->next;
		j++;
	}

	if (p == NULL)
		return false;  //i不合法  //增强代码的健壮性

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;  //这两句不能颠倒顺序
	p->next = s;       //若是颠倒顺序，p->next还没有使用就被更新了
	return true;

}

// 这个是不带头结点的插入方法
// 他与带头结点的区别在于在第一个位置插入时需要更头结点
// 其他功能与带头结点的相同，为了节省代码量，这里不在展出，只展示核心代码 
// bool ListInsert(LinkList& L, int i, int e) {
//  //在第一个位置插入e
//	if (i == 1) {
//		LNode* s = (LNode*)malloc(sizeof(LNode));
//		s->data = e;
//
//		s->next = L;  //让s的next指向头指针
//		L = s;       //然后将头指针改为s
//		             //这样就实现了将s插入到第一个位置
//		return true;
//	}
//
//}

// 7 指定结点的前插操作
//   你会发现，你是没办法找到给定节点的前驱节点
//   你可以选择从头结点挨个开始遍历，但是效率很低，而且若是不给头结点，则无法实现
//   所以，你可以采取下面的新方法
//   复制法  -----  偷天换日大法
//   将给定结点的数据赋值给你新申请的节点，将要插入的节点复制给给定结点
bool InsertPriorNode(LNode* p, int e) {
	if (p == NULL)
		return false;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = p->data;
	s->next = p->next;  //将p的所有信息复制给s  

	p->data = e;
	p->next = s;   //将要插入的节点复制给p
                   //俗称偷天换日大法
	return true;
}

// 8 按位序删除（带头结点）
bool DeleteList(LinkList& L, int i,int& e) {

	if (i < 1) {
		printf("删除的位置不合法");  //增强代码的健壮性
		return false;
	}
	//指针p指向当前扫描到的节点
	LNode* p = L;  // 现在指针p指向头结点，头结点是不保存数据的，即第0个节点

	int j = 0;  //j表示p指针当前指向的是第几个节点

	while (p != NULL && j < i - 1) {   //循环找到第i-1个节点
		p = p->next;
		j++;
	}

	if (p == NULL||p->next==NULL)
		return false;  //增强代码的健壮性

	 LNode* q = p->next; //q结点创建的作用是为了能释放掉这一段内存空间

	   e = p->next->data;  //用e可以记录下被删除的结点保存的值，不过我觉着这一步没什么用

	   p->next = p->next->next ;// 覆盖掉p->next达到实现删除的效果,虽然有点掩耳盗铃，但是效果有了

	
	
	 free(q);//释放掉没用的空间

	return true;

}


// 9 删除给定结点
//   思路同偷天换日大法
//   但是有如果要删除最后一个结点，这个代码是实现不了的，只能从表头开始循环遍历
//   我们将给定节点的后继结点的信息复制给给定结点，然后释放掉后继节点，这样就实现了给定结点的删除
//   如果是删除给定结点的后继，传参数的时候可以传给定结点的下一个结点,即传p->next
bool DeleteNode(LNode*p){
	if (p == NULL||p->next)return false;
	//如果p是最后一个结点，那么p->next==NULL ，p->next->next是不存在的
	LNode* q = p->next;  //q结点创建的作用是为了能释放掉这一段内存空间
	 p->data = p->next->data;
	p->next = p->next->next;
	  free(q);
	return true;
 }

int main() {

	 LinkList L;        // 1 声明一个指向单链表的指针
	 InitalList(L);    // 2 初始化链表，为链表添加头结点（即第0个结点）
	// BuildListHead(L);    // 3 头插法创建单链表     本博客使用尾插法
	 
	  BuildListTail(L); // 4 尾插法创建链表
	  //   注意1和3或者1和4可以合并在一起，方便新手学习理解，本博客分开处理

       LinkList se=GetElem(L, 2);   // 5 查找单链表元素
	   printf("查找到的数据为%d\n", se->data);

	   ListInsert(L, 2, 66);                 // 6 按位插入
	   InsertPriorNode(L->next->next, 99);  // 7 指定节点的前插操作

	   int e;
	   DeleteList(L, 5, e);         // 8 按位序删除（带头结点）
	   DeleteNode(L->next->next);  // 9  删除给定结点

	 LinkList p = L->next;         // 10 打印链表 没有再单独封装函数
	  while (p) {
		 printf("%d,", p->data);
		 p = p->next;
	 }

	return 0;
}
//单链表的局限性，不能逆向检索
海风许愿
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
计算机考研数据结构--链表部分
yuanwa0969的博客
01-03 360
计算机考研数据结构–链表部分 1、顺序表中删除第i个元素； #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; typedef struct SeqList{ int *arr; int arr_length; }SeqList; int main(){ int arr[10]={1,2,3,4,5,6,7,8,9,10}; SeqList l; ...
考研复习线性表之——链表
weixin_44769592的博客
05-25 278
文章目录单链表存储结构GetElem()ListInsert()例题A，B是两个单链表，递增有序，归并A，B得到C，也是递增有序的 单链表 存储结构 typedef struct node{ int data; structnode *next;//定义指向后继节点的指针 }node,*Linklist; GetElem() void GetElem(Linklist L,int i,int &e){ int j=1; int p=L; while(p&&j<i)/
考研复试之数据结构——链表
weixin_38623697的博客
03-06 276
链表应用 虽然考试中极少会考察链表的实际应用，一般都是直接考各种链表的各种操作，不过我觉得了解链表的实际应用场景有利于建立一种直觉，加深我们对链表数据结构本身的理解。由于我本身对链表应用也不甚了解，在查阅一定资料后，我认为有一句话能比较好的总结： 链表插入删除效率极高，达到O(1)。对于不需要搜索但变动频繁且无法预知数量上限的数据，比如内存池、操作系统的进程管理、网络通信协议栈的trunk管理等等等等，缺了它是绝对玩不转的。[1]——知乎用户invalid s 链表 这一小节主要讨论链表本身：单
【考研】单链表相关算法（从基础到真题）
qq_34438969的博客
10-02 1528
本文主要为了掌握单链表基础操作所作的总结，习题部分含408真题或高校真题，以便考研复习。包括但不限于尾插法和前插法建立单链表、“就地逆置”、链式有序表的合并、注意：（1）除非特别说明，本文的单链表操作默认是带头结点的。（2）区分带头结点和不带头结点的单链表的博文，我写了一半，写完就放链接。（如果很久还没放链接，可能博主有事耽搁了，麻烦提醒一下）【考研】线性表的应用之有序表的合并_住在阳光的心里的博客-CSDN博客【考研】《数据结构》知识点总结.pdf_其它文档类资源-CSDN文库目录前言。
考研数据结构——必看链表真题(常规套路)
希可诺的博客
04-11 2253
一、考研链表操作 （1）考研数据结构——单链表操作(模板) 整体分析：这四个题可以说也是固定思想套路，都是建立一个新的链表进行辅助操作，在考研中算是比较公认的一种处理方法了。 注意：有些小伙伴可能说会说，“我还有更好的方法或者更简洁的代码”，当然肯定会出现这种情况，我也并不反对，但是你的代码是给阅卷老师看的，这种新建链表的方法往往结构会更清晰。 目录 1、倒置链表 2、合并有序链表 3、将链表中所有负数结点移动到所有整数之前 4、将最小节点移动到第一个节点的前面 1、倒...
C语言单链表实现多项式相加
08-29
本文将详细介绍如何使用C语言单链表实现多项式相加。 首先，需要定义多项式的数据结构。这里使用一个结构体`Polynode`来表示多项式的每一项，包含系数`coef`和指数`expon`。然后，使用一个指针`Polynomial`来指向...
C语言单链表实现
01-16
单链表是计算机科学中数据结构的基础之一，它在C语言中的实现对于理解和掌握数据结构的概念至关重要。在本文中，我们将深入探讨C语言如何通过结构体和指针来实现单链表。 首先，我们需要理解单链表的基本概念。...
教师管理系统（C语言）（单链表）
07-03
1、实现软件：Dev-C++ 2、详细的测试页面可见我《资源》专栏下的《C语言系统资源测试》。 3、适合新手下载学习。 4、基于C语言的单链表实现。 5、代码共461行 6、注释多，排版有序
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表
09-20
本文将详细解析如何使用C语言来实现单链表，并涵盖了19种不同的操作功能，帮助你深入理解这一核心概念。 单链表由一系列节点组成，每个节点包含两部分：数据域（用于存储数据）和指针域（指向下一个节点）。链表的...
C.rar_C语言单链表
09-23
首先，我们来详细了解单链表的基本概念。单链表中的每个节点由两部分构成：数据域（data field）存储实际的数据，以及指针域（pointer field）存储指向下一个节点的地址。由于每个节点只包含一个指向下一个节点的...
数据结构考研复习（自用非408）链表——附单链表完整代码
qq_55709496的博客
10-30 171
链表部分
结合王道考研，用链表方式，C++，实现队列
moliaochunfeng的博客
04-24 229
嘎嘎嘎，每日一更今天结合王道考研，用链表的方式实现队列，其实还挺简单的，但是我对c++实在是太不熟悉了，造成了我写的过程中遇到了很多大大小小的错误。第一个问题，在C++中，我是这么定义结构体的：Typedef struct{int data;struct LinkNode *next;}LinkNode;也不知道为什么，我这段代码就是有问题的，可能这个是可以在c语言里实现，但是C++中实现不了？然...
【考研数据结构之】——2.两种方法创建单链表
zhangchuanyang_的博客
07-22 1072
链表是由一个个节点构成的，每个节点又数据域和指针域两个部分构成。数据域存储元素内容，指针域存储下一个元素的地址。故结构体定义了data来存储元素内容，*next来存储下一个元素的地址。........................
《408篇》线性表与链表
m0_60964321的博客
04-09 555
define Maxsize 50 //定义线性表最大长度//定义元素类型typedef struct { //定义结构体//定义顺序表的元素int length;//定义线性表的长度}SqList;//定义元素类型typedef struct { //定义结构体//定义顺序表的元素int length;//定义线性表的长度//定义最大长度}SqList;//数据域//指向下一节点的指针//定义双链表的结点类型//数据域// 前驱结点的指针；后继结点的指针。
【考研数据结构预习】链表篇
hsx201612的博客
07-09 555
下学期就要大三，还真的是很快呀！准备报考深圳大学的计算机专业，本人不是科班出身的。今天开始复习数据结构吧！下面是我的一些个人复习总结，献丑了，有错的请留言指出，十分感谢赏脸了！链表的创建一些基本的操作附上个人的链表创建代码（C语言）#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; /*创建节点的数据类型*/ struct stu { int n...
数据结构考研笔记——链表常考操作
SmiledrinkCat的博客
08-02 1111
1.尾插法建立单链表 假设有n个元素已经存储在数组a中，用尾插法建立链表C： void createlistR(LNode *&amp;C, int a[], int n) { LNode *s, *r; //s用来指向新申请的结点，r始终指向C的终端结点 int i; C=(LNode *) malloc (sizeof(LNode)); //申请C的头结点...
【LinuxC语言】手撕Http之处理POST请求
m0_62599305的博客
07-07 177
在互联网的世界中，HTTP协议无疑是最重要的协议之一。它是Web的基础，支持着我们日常生活中的大部分在线活动。尽管有许多现成的库可以处理HTTP请求，但了解其底层工作原理是非常有价值的。本文将介绍如何在Linux C语言环境中处理HTTP POST请求。POST是HTTP协议中的一种请求方法，用于提交数据到服务器进行处理。与GET请求不同，POST请求将数据包含在请求体中，而不是URL中。这使得POST请求可以发送大量的数据，并且这些数据可以是任何类型，包括文本、二进制数据，甚至是文件。
【C语言】《回调函数》详细解析
EleganceJiaBao的博客
07-08 678
回调函数是指一个通过函数指针调用的函数。它允许将一个函数作为参数传递给另一个函数，并在特定事件发生时执行。这种技术使得编程更加灵活，可以动态决定在何时调用哪个函数。
2025~《数据结构》试题~考研
最新发布
专研计算机网络，数据通信，网络安全，系统集成
07-11 544
在图的遍历中，深度优先搜索（DFS）和广度优先搜索（BFS）的时间复杂度分别是（）。以下哪种排序算法的平均时间复杂度是O(n log n)（）。在二叉搜索树中，删除一个节点的最坏时间复杂度是（）。在堆排序中，构建一个最大堆的时间复杂度是（）。C. O(V + E) 和 O(V + E)D. 哈希表的查找时间复杂度一定是O(1)B. 哈希表的插入时间复杂度为O(1)A. O(V + E) 和 O(V)以下关于哈希表的说法错误的是（）。B. O(V^2) 和 O(V)D. O(V) 和 O(V^2)
C语言单链表的基本操作.pdf
04-26
本资源详细介绍了C语言中单链表的基本操作，包括创建、删除、查找、插入和输出功能。单链表是一种线性数据结构，其中每个节点包含一个数据域（`ElemType`类型）和一个指向下一个节点的指针域。以下将分别针对这些...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海风许愿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值