链表——头插法，中间插入法，尾插法

最新推荐文章于 2023-07-25 17:08:44 发布
最新推荐文章于 2023-07-25 17:08:44 发布
阅读量919 收藏 4
点赞数 1
文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45853531/article/details/119967423
版权

 头插法：

新建一个值为inputData的结点，插入链表的头部。

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

typedef int  ElemType;

//设计一个链表结构体数据类型 ,结点
struct node {
	ElemType data;//数据域
	struct node* next;//指针域
};

/*
new_node:新建一个结点，并且初始化
参数：
	inputData 新建结点的数据
返回值：
		成功返回新建结点的地址
		失败返回NULL
*/
struct node* new_node(ElemType inputData)
{
	//1、新建一个结点
	struct node* newNode = malloc(sizeof(struct node));
	if (newNode == NULL)
	{
		printf("新结点内存申请失败\n");
		return NULL;
	}
	//2、初始化新建的结点
	newNode->data = inputData;
	newNode->next = NULL;

	return newNode;
}

/*
create_list:创建一条只有首结点的单链表
返回值：返回链表首结点的地址
*/
struct node* create_list(ElemType inputData)
{
	//1、先申请首结点的内存空间
	struct node* head = new_node(inputData);//0x1234578
	if (head == NULL)
	{
		printf("首结点申请失败\n");
		return NULL;
	}
	//2、初始化首结点
	head->data = inputData;
	head->next = NULL;

	//3、把首结点的地址返回(存储起来)
	return head;
}

/*
print_allToList：将链表中所有结点的数据打印出来
参数：
		head  链表的首结点
*/
void print_allToList(struct node* head)
{
	//遍历链表的每一个结点，每个结点的数据都打印出来
	struct node* p = head;

	while (p)
	{
		printf("%d  ", p->data);

		p = p->next;//指向下一个结点
	}

	printf("\n");
}
/*
insert_nodeToList_head:新建一个值为inputData的结点，插入链表的头部
参数：
		head  链表的首结点
		inputData 新建结点的数据
返回值：
		成功  返回  链表的首结点
		失败  返回   NULL
*/
struct node* insert_nodeToList_head(struct node* head, ElemType inputData)
{
	//1、新建一个结点并且初始化
	struct node* newNode = new_node(inputData);
	if (newNode == NULL)
	{
		printf("新结点创建失败\n");
		return NULL;
	}
	//新结点的next指向原来链表的首结点
	newNode->next = head;
	//head存储新结点的地址，也就是说，此时新结点的链表的首结点
	head = newNode;

	return head;
}


int main()
{
	struct node* head;//存储首结点的地址 链表a的首结点

	//创建一条只有首结点的单链表
	head = create_list(100);//首结点
	head = insert_nodeToList_head(head,110);//head=更新头结点
	head = insert_nodeToList_head(head,120);
    head = insert_nodeToList_head(head,130);
    head = insert_nodeToList_head(head,140);
    head = insert_nodeToList_head(head,150);


	print_allToList(head);
	return 0;
}

 运行结果：

 尾插法：

insert_nodeToList_tail:

         新建一个值为inputData的结点，插入链表的尾部
参数：
        head  链表的首结点

        inputData 新建结点的数据

 

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

typedef int  ElemType;

//设计一个链表结构体数据类型 ,结点
struct node {
	ElemType data;//数据域
	struct node* next;//指针域
};

/*
new_node:新建一个结点，并且初始化
参数：
	inputData 新建结点的数据
返回值：
		成功返回新建结点的地址
		失败返回NULL
*/
struct node* new_node(ElemType inputData)
{
	//1、新建一个结点
	struct node* newNode = malloc(sizeof(struct node));
	if (newNode == NULL)
	{
		printf("新结点内存申请失败\n");
		return NULL;
	}
	//2、初始化新建的结点
	newNode->data = inputData;
	newNode->next = NULL;

	return newNode;
}

/*
create_list:创建一条只有首结点的单链表
返回值：返回链表首结点的地址
*/
struct node* create_list(ElemType inputData)
{
	//1、先申请首结点的内存空间
	struct node* head = new_node(inputData);//0x1234578
	if (head == NULL)
	{
		printf("首结点申请失败\n");
		return NULL;
	}
	//2、初始化首结点
	head->data = inputData;
	head->next = NULL;

	//3、把首结点的地址返回(存储起来)
	return head;
}

/*
print_allToList：将链表中所有结点的数据打印出来
参数：
		head  链表的首结点
*/
void print_allToList(struct node* head)
{
	//遍历链表的每一个结点，每个结点的数据都打印出来
	struct node* p = head;

	while (p)
	{
		printf("%d  ", p->data);

		p = p->next;//指向下一个结点
	}

	printf("\n");
}
/*
insert_nodeToList_tail:新建一个值为inputData的结点，插入链表的尾部
参数：
		head  链表的首结点
		inputData 新建结点的数据
*/
void insert_nodeToList_tail(struct node* head, ElemType inputData)
{
	//1、新建一个结点
	struct node* newNode = new_node(inputData);
	if (newNode == NULL)
	{
		printf("insert_nodeToList_tail error\n");
		return;
	}
	//2、初始化新建的结点 --不需要初始化，因为在new_node函数中已经初始化了
	//newNode->data = inputData;
	//newNode->next = NULL;

	//3、遍历链表，找到链表的尾结点（尾部）
	struct node* p = head;//p指向首结点
	struct node* pre = NULL;//存储p的前一个结点
	while (p) //p == NULL 才退出
	{
		pre = p;
		p = p->next;
	}

	//此时pre就是尾结点的地址

	//4、将新建好结点插到链表的尾结点的后面
	pre->next = newNode;

}


int main()
{
	struct node* head;//存储首结点的地址 链表a的首结点

	//创建一条只有首结点的单链表
	head = create_list(100);//首结点
	insert_nodeToList_tail(head, 110);
	insert_nodeToList_tail(head, 115);
	insert_nodeToList_tail(head, 120);
	insert_nodeToList_tail(head, 125);


	print_allToList(head);
	return 0;
}

 运行结果：

 中间插入法：

insert_nodeToList:

        新建一个值为inputData的结点，插到链表中值为frontData的结点的前面
        如果值为frontData的结点不存在，则插在链表的尾部
        如果值为frontData的结点有多个，则插在第一个的前面
        如果值为frontData的结点是首结点，则使用头插

 

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

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

typedef int  ElemType;

//设计一个链表结构体数据类型 ,结点
struct node {
	ElemType data;//数据域
	struct node* next;//指针域
};

/*
new_node:新建一个结点，并且初始化
参数：
	inputData 新建结点的数据
返回值：
		成功返回新建结点的地址
		失败返回NULL
*/
struct node* new_node(ElemType inputData)
{
	//1、新建一个结点
	struct node* newNode = malloc(sizeof(struct node));
	if (newNode == NULL)
	{
		printf("新结点内存申请失败\n");
		return NULL;
	}
	//2、初始化新建的结点
	newNode->data = inputData;
	newNode->next = NULL;

	return newNode;
}

/*
create_list:创建一条只有首结点的单链表
返回值：返回链表首结点的地址
*/
struct node* create_list(ElemType inputData)
{
	//1、先申请首结点的内存空间
	struct node* head = new_node(inputData);//0x1234578
	if (head == NULL)
	{
		printf("首结点申请失败\n");
		return NULL;
	}
	//2、初始化首结点
	head->data = inputData;
	head->next = NULL;

	//3、把首结点的地址返回(存储起来)
	return head;
}

/*
print_allToList：将链表中所有结点的数据打印出来
参数：
		head  链表的首结点
*/
void print_allToList(struct node* head)
{
	//遍历链表的每一个结点，每个结点的数据都打印出来
	struct node* p = head;

	while (p)
	{
		printf("%d  ", p->data);

		p = p->next;//指向下一个结点
	}

	printf("\n");
}
/*
insert_nodeToList_head:新建一个值为inputData的结点，插入链表的头部
参数：
		head  链表的首结点
		inputData 新建结点的数据
返回值：
		成功  返回  链表的首结点
		失败  返回   NULL
*/
struct node* insert_nodeToList_head(struct node* head, ElemType inputData)
{
	//1、新建一个结点并且初始化
	struct node* newNode = new_node(inputData);
	if (newNode == NULL)
	{
		printf("头插入失败\n");
		return NULL;
	}
	//新结点的next指向原来链表的首结点
	newNode->next = head;
	//head存储新结点的地址，也就是说，此时新结点的链表的首结点
	head = newNode;

	return head; 
}

/*
insert_nodeToList:新建一个值为inputData的结点，插到链表中值为frontData的结点的前面
		如果值为frontData的结点不存在，则插在链表的尾部
		如果值为frontData的结点有多个，则插在第一个的前面
		如果值为frontData的结点是首结点，则使用头插
参数：
		head  链表的首结点
		inputData 新建结点的数据
		frontData 新结点插在该结点的前面的数据
返回值：
		成功  返回  链表的首结点
		失败  返回   NULL
*/
struct node* insert_nodeToList(struct node* head, ElemType inputData, ElemType frontData)
{
	//1、新建一个结点，并且初始化
	struct node* newNode = new_node(inputData);
	if (newNode == NULL)
	{
		printf("insert_nodeToList error\n");
		return NULL;
	}
	//遍历链表，找到值为frontData的结点frontNode和它的前面一个结点pre
	struct node* p = head;
	struct node* pre = NULL;

	while (p)
	{
		//找到了,此时 p  就是  值为frontData的结点frontNode
		if (p->data == frontData)
			break;
		else {//如果没有找到，则p往链表的下一个结点进行遍历
			pre = p;//记录p结点的上一个结点
			p = p->next;
		}
	}


	if (p != NULL)//找到的情况
	{
		if (p == head)//1、如果值为frontData的结点 是首节点 ，使用头插法，更新首结点
		{
			//新结点的next存储原链表的首结点地址,也就是新结点指向原来的首结点
			newNode->next = head;//newNode->next = p;
			head = newNode;//此时新结点就是链表的首结点
		}
		else {//2、值为frontData的结点在中间
			newNode->next = p;
			pre->next = newNode;
		}

	}
	else {//没找到的情况（如果链表遍历完之后，没找到）  p == NULL ,也就是说值为frontData的结点没有找到,新结点使用尾插
		pre->next = newNode;
	}

	return head;
}


int main()
{
	struct node* head;//存储首结点的地址 链表a的首结点

	//创建一条只有首结点的单链表
	head = create_list(100);//首结点
	head = insert_nodeToList_head(head, 110);//head=更新头结点
	head = insert_nodeToList_head(head, 120);
	head = insert_nodeToList_head(head, 130);
	head = insert_nodeToList_head(head, 140);
	head = insert_nodeToList_head(head, 150);

	head = insert_nodeToList(head,125,120);//在值为120的结点后面插入125
	

	print_allToList(head);
	return 0;
}

 运行结果：

插入之前：

 插入之后：

qq_45853531
关注
链表的中间插入
乐乐的博客
06-13 2262
#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;#include&lt;string.h&gt; //头文件struct node //设计结点的类型；{ int num;                                           //数据num struct node *pNext; ...
链表的头插法和尾插法——头插尾插交替插入
your_棒棒糖的博客
09-06 851
private static ListNode dummy = new ListNode(0); //头插法 public static void headInsert(ListNode node){ if (dummy.next == null){ dummy.next = node; return; } ListNode temp = dummy.next; dummy.nex..
10.31
wei0301的博客
10-31 192
#include struct node { int num; struct node * next; }; typedef struct node Node; typedef struct node * Link; void create_link(Link * head) { *head = NULL; } void insert_no
链表中间插入
zjy1364503349的博客
11-04 686
#include       struct node   {       int num;       struct node * next;   };      typedef struct node Node;   typedef struct node * Link;      void create_link(Link * head)   {       *hea
16.链表的插入排序(链表头插+中间插入+尾部插入)
_zhy_cq
02-08 619
对链表进行插入排序 试试这题 插入排序算法： 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。 重复直到所有输入数据插入完为止。 示例 1： 输入: 4->2->1->3 输出: 1->2->3->4 示例 2： 输入: -1->5->3->4->0 输出: -1->0->3->4->5 整体
py单链表头插法与尾插法实现(含代码测试)
执念斩长河
07-30 1811
在头插法与尾插法中，头插法讲究的是将新结点连接在头结点之后，第一个数据点之前。逆序输出。尾插法讲究的是链接到尾结点之后，所得链表称为顺序链表。因此，紧扣住定义，将代码多次演练即可掌握，实在是不可多得的好文章。
链表初始化——头插法与尾插法 超详解！！！
weixin_43570233的博客
03-20 1944
链表初始化——头插法与尾插法 超详解！！！ 看代码先 void CreatList（LinkNode *&L，int a[],int n） { LinkNode *s; L=(LinkNode *)malloc(sizeof(LNode)); L->next=NULL; for(int i=0;i<n;i++) { s=(LinkNode *)malloc(sizeo...
Java数据结构之链表——头插法逆置单链表
weixin_45700507的博客
04-25 750
单链表的就地逆置是指辅助空间O(1)的逆置方法，使用头插法。 定义单链表的基本操作 package Link; class Node{ // 定义单链表借点类 public int value; // 该结点所保存的值 public Node next; // da该结点下一个结点指针 public Node(int data){ value = data; next = null; } public Node(){.
链表的创建——尾插法、头插法总结
qq_57784588的博客
07-13 498
在运行代码时发现只有头插法打印时可以正常运行，尾插法打印完成之后报出了访问权限冲突问题发现这里是野指针的问题。 打印时L会一个个遍历直到L=NULL，由于该链表的尾节点的next指针指向不为空 ,指针自己指向了0XFFFFFFFFFFFFFFF,由于该地址不可读，导致权限冲突。解决方法就是在输入数据的while循环之......
建立 链表 “头插法”与“尾插法“ 方法详解
jing102102的博客
04-11 2522
在建立单链表的时候 头插法与尾插法时最最常见的，话不多说直接进入正题 头插法 的两种方式 顾名思义 从链表的开头开始插入结点——先进后出。 在头节点之后插入节点 新插入的结点指向上一次插入的结点 方法一 typedef struct Node { int a; struct Node* next; }Node; //int main() // //{ // Node* hand, * p; // hand = (Node*)malloc(sizeof...
链表-头插法，尾插法，中间插入.zip
08-28
链表-头插法，尾插法，中间插入.zip
单链表——增加中间插入节点的功能
小书
03-31 1100
这里暂时没有考虑pos位于尾部的情况 # 节点的定义： class Node: '''节点的定义''' def __init__(self,val): self.val = val self.next = None # 单链表的定义： class SingleLinkList: # 这里调用节点的定义，创建一个空链表,self.__head表示始终指向链表的头 def __in...
链表的插入（头插，尾插，中间插）
pencher_liu的博客
11-04 502
#include <stdio.h> #include <stdlib.h>struct node { int num; struct node * next; };typedef struct node Node; typedef struct node * Link;void create_link(Link * head) { *head = NULL; }void i
链表模板（删除模块）
xyw_1122的博客
10-10 337
#include struct node { int num; struct node *next; }; typedef struct node Node; typedef Node * Link; void init_link(Link *head) { *head = NULL; } void insert_head_node(Link newnode,Lin
单链表中间插入
weixin_43794611的博客
02-16 1907
中间往前插入  void insert_node_mid_before(Link *head,Link new_node,int loc) { Link p,q; q = p = *head; if(p == NULL) //判断是否为空链表 { printf("Link is...
c++实现链表( 链表的创建，打印，插入(头插，尾插，中插)，逆置 )
leikun153的博客
07-22 4825
在本人所写的代码：在链表创建的时候，需要自己输入一个个数来充当每个节点的数据，当输入零的时候，链表穿创建结束，但0本身并没有存储到链表里面去，当然，这里的0也可以自己改成一个字符，这样更好一点，不会让链表本身无法存储0这个数字。另外，本人创建的时候是创建了一个带头结点的链表。链表的插入本人是分成三个部分来写的，分别是头插，尾插，中插。   具体实现代码如下: #include &lt;io...
Python+图解：实现数据结构中单链表的头插法和尾插法
qq_39783265的博客
09-17 3738
用Python实现数据结构的头插法和尾插法 1.链表结构 # -*- coding:utf-8 -*- import random as rd class Node(): def __init__(self, value, next=None): self.value = value self.next = next 2.头插法 #头插法 def creatlist_head(n...
[算法通关村] 1.2 链表的插入
最新发布
[已注销]
07-25 233
今天我们来探究一下链表的插入，链表的插入共有 3 种可能性，分别是在链表的头部插入、在中间插入，和在链表的尾部插入（追加），不同的插入位置对应着不同的代码，所以需要一个一个来探究。
分别使用头插法和尾插法创建链表（python）
qq_43853684的博客
08-15 809
分别使用头插法和尾插法创建链表
链表插入操作详解：头插法与尾插法入门指导
资源摘要信息:"本文主要介绍链表的两种插入方法：尾插法和头插法，以及如何使用这两种方法来创建链表。" 1. 链表的概念： 链表是一种常见的基础数据结构，由一系列节点组成。每个节点包含两个部分：一部分存储数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值