链表创建按位置和元素增删改查及逆置

最新推荐文章于 2024-09-29 22:26:41 发布
最新推荐文章于 2024-09-29 22:26:41 发布
阅读量43 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huncho/article/details/131194615
版权

head.h

#ifndef __HEAD_H__
#define __HEAD_H__
	
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define LINKLIST_HEAD 1
#define LINKLIST_NODE 0

typedef int datatype;
typedef struct Node
{
	union
	{
		int len;
		datatype data;
	};
	struct Node *next;
}*Linklist;

Linklist create_node(int flag);
int insert_head(Linklist L, datatype e);
void output(Linklist L);
Linklist insert_rear(Linklist L, datatype e, Linklist rear);
int delete_head(Linklist L);
int delete_rear(Linklist L);
int insert_pos(Linklist L, int pos, datatype e);
int delete_pos(Linklist L, int pos);
int update_pos(Linklist L, int pos, datatype e);
int search_pos(Linklist L, int pos);
int search_data(Linklist L, datatype key);
int insert_data(Linklist L, datatype key, datatype e);
int update_data(Linklist L, datatype key, datatype e);
int delete_data(Linklist L, datatype key);
void rev_linklist(Linklist L);
#endif

main.c

#include "head.h"

int main(int argc, char *argv[])
{
	//1表示头结点 0表示普通结点
	Linklist L = create_node(LINKLIST_HEAD);
	
	Linklist rear = L;
	
	int n;
	printf("请输入要插入的个数：");
	scanf("%d",&n);
	datatype e;

	for (int i = 0; i < n; i++)
	{
		//printf("请输入插入的值:");
		//scanf("%d", &e);
		//insert_head(L, e);

		//头插
		//insert_head(L, i + 1);
		
		//空链表尾插
		rear = insert_rear(L, i + 1, rear);


	}
	
	output(L);

	/*
	//头删
	delete_head(L);
	delete_head(L);
	output(L);
	*/

	/*
	//尾删
	delete_rear(L);
	delete_rear(L);
	output(L);
	*/

	/*
	//按位置插入
	int pos;
	printf("请输入插入的位置：");
	scanf("%d",&pos);
	printf("请输入要插入的值：");
	scanf("%d",&e);
	insert_pos(L, pos, e);
	output(L);
	*/

	/*
	//按位置删除
	int pos;
	printf("请输入要删除的位置：");
	scanf("%d",&pos);
	delete_pos(L, pos);
	output(L);
	*/

	/*
	//按位置修改
	int pos;
	printf("请输入要修改的位置：");
	scanf("%d",&pos);
	printf("请输入要修改的值：");
	scanf("%d",&e);
	update_pos(L, pos, e);
	output(L);
	*/

	/*
	//按位置查询
	int pos;
	printf("请输入要查询的位置：");
	scanf("%d",&pos);
	printf("查询位置的值为%d\n", search_pos(L, pos));
	*/

	/*
	//按元素查询
	datatype key;
	printf("请输入要查询的值");
	scanf("%d", &key);
	int pos = search_data(L, key);
	printf("查询的元素的位置在%d\n", pos);
	*/

	/*
	//按元素插入
	datatype key;
	printf("请输入要插入位置的值：");
	scanf("%d",&key);
	printf("请输入要插入的值：");
	scanf("%d",&e);
	insert_data(L, key, e);
	output(L);
	*/

	/*
	//按元素修改
	int key;
	printf("请输入要修改的元素值：");
	scanf("%d",&key);
	printf("请输入要修改的值：");
	scanf("%d",&e);
	update_data(L, key, e);
	output(L);
	*/

	/*
	//按元素删除
	int key;
	printf("请输入要删除的元素的值：");
	scanf("%d",&key);
	delete_data(L, key);
	output(L);
	*/

	//单链表逆置
	rev_linklist(L);
	output(L);
	



	return 0;
}

test.c

#include "head.h"

/*
 * function:    创建头结点
 * @param [ in] flag 
 * @param [out] 
 * @return     成功返回首地址 失败返回NULL 
 */
Linklist create_node(int flag)
{
	Linklist L = (Linklist)malloc(sizeof(struct Node));
	if (L == NULL)
	{
		return NULL;
	}

	//0表示普通结点 1是头结点 
	if (flag == LINKLIST_HEAD)
	{
		L->len = 0;
	}
	else if (flag == LINKLIST_NODE)
	{
		L->data = 0;
	}

	L->next = NULL;
	return L;
}

/*
 * function:    头插
 * @param [ in] 链表 插入的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int insert_head(Linklist L, datatype e)
{
	if (L == NULL)
	{
		printf("插入失败\n");
		return -1;
	}

	Linklist s = create_node(LINKLIST_NODE);
	if (s == NULL)
	{
		printf("插入失败\n");
		return -1;
	}

	s->data = e;
	s->next = L->next;
	L->next = s;
	L->len++;
	
	return 0;
}

/*
 * function:    遍历打印
 * @param [ in] 链表
 * @param [out] 
 * @return      无
 */

void output(Linklist L)
{
	if (L == NULL || L->next == NULL)
	{
		printf("打印失败\n");
		return;
	}

	Linklist p = L;
	while (p->next != NULL)
	{
		p = p->next;
		printf("%d ", p->data);
	}
	puts("");
}

/*
 * function:   	空链表尾插
 * @param [ in] 链表 插入的值 尾结点
 * @param [out] 
 * @return      尾结点
 */

Linklist insert_rear(Linklist L, datatype e, Linklist rear)
{
	if (L == NULL)
	{
		printf("插入失败\n");
		return NULL;
	}

	Linklist s = create_node(LINKLIST_NODE);
	if (s == NULL)
	{
		printf("插入失败\n");
		return NULL;
	}
	s->data = e;
	rear->next = s;
	rear = s;
	L->len++;

	return rear;

}


/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */

int delete_head(Linklist L)
{
	if (L == NULL || L->next == NULL)
	{
		printf("删除失败\n");
		return -1;
	}

	Linklist q = L->next;
	L->next = q->next;
	free(q);
	L->len--;
	return 0;
}


/*
 * function:    尾删
 * @param [ in] 链表
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int delete_rear(Linklist L)
{
	if (L == NULL || L->next == NULL)
	{
		printf("删除失败\n");
		return -1;
	}

	Linklist p = L;
	while (p->next->next != NULL)
	{
		p = p->next;
	}
	free(p->next);
	p->next = NULL;
	L->len--;
	return 0;
	
}

/*
 * function:    按位置插入
 * @param [ in] 链表 位置 值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int insert_pos(Linklist L, int pos, datatype e)
{
	if (L == NULL || pos < 1 || pos > L->len + 1)
	{
		printf("插入失败\n");
		return -1;
	}

	Linklist p = L;
	for (int i = 0; i < pos - 1; i++)
	{
		p = p->next;
	}

	Linklist s = create_node(LINKLIST_NODE);
	if (s == NULL)
	{
		printf("插入失败");
		return -1;
	}

	s->data = e;
	s->next = p->next;
	p->next = s;
	L->len++;
	return 0;

}

/*
 * function:    按位置删除
 * @param [ in] 链表 位置
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delete_pos(Linklist L, int pos)
{
	if (L == NULL || L->next == NULL || pos < 1 || pos > L->len)
	{
		printf("删除失败\n");
		return -1;
	}

	Linklist p = L;
	for (int i = 0; i < pos - 1; i++)
	{
		p = p->next;
	}

	Linklist q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;
	L->len--;
	return 0;
}

/*
 * function:    按位置修改
 * @param [ in] 链表 位置 值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int update_pos(Linklist L, int pos, datatype e)
{
	if (L == NULL || L->next == NULL || pos < 1 || pos > L->len)
	{
		printf("修改失败\n");
		return -1;
	}

	Linklist p = L;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	p->data = e;

	return 0;

}

/*
 * function:    按位置查询
 * @param [ in] 链表 位置 
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int search_pos(Linklist L, int pos)
{
	if (L == NULL || L->next == NULL || pos < 1 || pos > L->len)
	{
		printf("查询失败\n");
		return -1;
	}

	Linklist p = L;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	return p->data;

}

/*
 * function:    按元素查询
 * @param [ in] 链表 元素值
 * @param [out] 
 * @return      元素的位置
 */
int search_data(Linklist L, datatype key)
{
	if (L == NULL || L->next == NULL)
	{
		printf("查询失败\n");
		return -1;
	}

	Linklist p = L;
	int pos = 0;
	while (p->next != NULL)
	{
		p = p->next;
		pos++;
		if (p->data == key)
		{
			return pos;
		}
	}
	printf("未找到\n");
	return -1;
}

/*
 * function:    按元素插入
 * @param [ in] 链表 元素值 增加的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int insert_data(Linklist L, datatype key, datatype e)
{
	if (L == NULL || L->next == NULL)
	{
		printf("插入失败\n");
		return -1;
	}

	int pos = search_data(L, key);
	if (pos == -1)
	{
		printf("插入失败\n");
	}
	insert_pos(L, pos, e);
	
	return 0;
}

/*
 * function:    按元素修改
 * @param [ in] 链表 元素 修改值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int update_data(Linklist L, datatype key, datatype e)
{
	if (L == NULL || L->next == NULL)
	{
		printf("修改失败\n");
		return -1;
	}

	int pos = search_data(L, key);
	if (pos == -1)
	{
		printf("修改失败\n");
	}
	update_pos(L, pos, e);
	return 0;

}

/*
 * function:    按元素删除
 * @param [ in] 链表 元素值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int delete_data(Linklist L, datatype key)
{
	if (L == NULL || L->next == NULL)
	{
		printf("修改失败\n");
		return -1;
	}

	int pos = search_data(L, key);
	if (pos == -1)
	{
		printf("删除失败\n");
		return -1;
	}

	delete_pos(L, pos);

	return 0;
}

/*
 * function:    单链表逆置
 * @param [ in] 单链表
 * @param [out] 
 * @return      无
 */

void rev_linklist(Linklist L)
{
	if (L == NULL || L->next == NULL)
	{
		printf("修改失败\n");
		return;
	}

	Linklist p = L->next;
	L->next = NULL;
	while (p != NULL)
	{
		Linklist s = p;
		p = p->next;
		s->next = L->next;
		L->next = s;
	}
}

huncho
关注
数据结构DAY4 链表按元素增删改查 单链表逆置
YNing111851的博客
06-13 57
/利用search_data函数找到下标。//利用search_data函数找到下标。else if(m==0) //m==0 创建普通节点的空间。//参数:元素值key 链表-即头结点 一个指向头结点的指针rear。if(m==1) //m==1 创建头结点的空间。//search_data函数返回一个下标 定义int接返回值。
链表的创建逆置及增删改查
qq_45949060的博客
12-22 120
链表是一种常见的数据结构。它是一种动态的进行存储分配的一种结构。链表各元素在内存中的地址可以是不连续的。链表中的每一个结点中应包括一个指针变量，用它存放下一个结点的地址。 链表的创建： 建立链表是指在程序执行过程中从无到有的建立起一个链表，即一个一个的开辟结点和输入各结点数据，并建立起前后相链的关系。 链表的逆置： 链表的增加： 链表的删除： 链表的更改： 链表的查找： ...
单链表的增删改查，就地逆置、倒数第k个节点算法实现
YangLong的博客
07-19 320
前言唠叨一下 最近有点时间，总结了一下单链表的各种操作，包括增删改查，就地逆置、求倒数第k个节点等。工作之余重新回顾一下，虽然工作中很少用到，Java也封装了比较完善的链表实现，但对于自己的算法理解多多少少也有所帮助。 效果图 链表类实现逻辑 package com.list; /** * 单链表-带头结点 */ public class SingleLinkedList<T> { private int size; private Node head; /** * 构
数据结构双向链表，实现增删改查
小钱努力学C的博客
07-19 1230
双向链表的描述以及存储结构定义，头插、尾插、头删、尾删以及双向链表逆置等基本操作的实现
单向链表，链表的定义以及增删改查的实现
小钱努力学C的博客
07-18 232
LinkList Request_space() //在堆区申请一个结点空间int Output(LinkList L_list) //实现输出return -1;return 0;LinkList insert_head(LinkList L_list,ElemType value) //实现头插LinkList insert_rear(LinkList L_list,ElemType value) //实现尾插else。
c语言 双向链表增删修查,手写双链表，并实现增删改查
weixin_34443284的博客
05-21 136
手写双链表，并实现增删改查public class DoublyLinkedListT {// 一个空的头节点private final Node head = new Node(null);@Getterprivate int size = 0;public DoublyLinkedList() {head.pre = head;head.next = head;}@SafeVarargspub...
Python数据结构-----链表1.0（单链表的增删改查以及反转）
m0_73633088的博客
03-12 1761
详细讲解Python中链表的操作，增删改查以及实现链表的转置输出，快来看快来看快来看快来快来看！！！！！
数据结构单链表所有操作，创建，初始，增删改查逆置
weixin_42761614的博客
06-05 174
#include<stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; bool InitList(LinkList &L){ //带头节点（没有值的节点，只有next指针的结构体初始化，且头节点值本就为空 L = (LNode *)mallo.
【算法】Java实现链表的基本操作（链表增删查、链表逆置、链表局部逆置、查找有环链表入口）
TiramisuDP的博客
06-28 204
链表1、理论1.1、数据结构1.2、优缺点1.3、比较2、基本操作2.1、新建链表与增删改查2.2、链表逆置2.3、判断有环链表与查找环的入口 1、理论 1.1、数据结构 链表种类还是比较繁多的，根据指针域可以分为单链表与双向链表，根据头尾是否连接可以分为循环链表与不循环链表，根据是否有头指针可以分为有头链表与无头链表。 大致排列组合就可以得到8种链表结构。 1.2、优缺点 1.3、比较 2、基本操作 2.1、新建链表与增删改查 2.2、链表逆置 2.3、判断有环链表与查找环的入口 ...
顺序表 链表 双链表的增删查改操作及链表逆置等常用线性表算法.zip
08-16
在本压缩包中，我们重点关注了三种类型的线性表：顺序表、链表和双链表，以及它们的增删查改操作和链表逆置等常见算法。 顺序表是一种最简单的线性表实现，它在内存中是连续存储的，可以通过数组来表示。对于顺序表...
单链表的建立、增删改查
qq_41244719的博客
11-09 827
单链表的定义、增删改查单链表的定义不带头结点的单链表带头结点的单链表单链表的插入删除按位序插入（带头结点）按位序插入（不带头结点） 单链表的定义 单链表分为不带头结点的单链表和带头结点的单链表 不带头结点的单链表 声明一个不带头结点的单链表，&符号表示引用，InitList函数中将L赋值为NULL，防止脏数据，表示空表。 #include <stdlib.h> #include <stdio.h> typedef struct LNode{ int data;
单链表算法(增删改查、头插法、尾插法、单链表逆置、求倒数第k个节点值、找中间节点、删除单链表中最大值节点、分割单链表）、)
06-25 907
单链表简介： 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 代码： #include <stdio.h> #include "stdlib.h" typedef int ElemType; typedef struct Node { ElemType data; stru
C语言版数据结构 链表：链表的建立、链表的增加删除查找修改。链表的改造：循环链表、双向链表。
qq_57702110的博客
08-05 922
首先我们要知道链表有哪些建立方式： 假设我们有一个整型数组，怎么建立一个由数组的每个元素组成的链表呢？ struct node{ int a; struct node* next; }; typedef struct node Node; int main(){ int arr[] = { 1,2,3,4,5}; Node* ps = new_list1(arr, sizeof(arr)/sizeof(arr[0])); return 0; } 1、头插入建立法 先...
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 155
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
【笔记】数据结构12
最新发布
m0_52024881的博客
09-29 301
看到的社区的一个知识总结，这里记录一下。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 860
本文介绍了数据结构中的AVL树，给出了C++的代码实现
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 671
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
第五周做题总结_数据结构_队列与应用
2301_79837864的博客
09-29 490
银行营业大厅共服务3种客户，类型为A\B\C，大厅分别设置了3个窗口分别服务三种客户，即每个窗口只服务一种客户。现有一批客户来银行办理业务，每个客户都有类型和办理业务时间。每个窗口按照客户到来的顺序进行服务。编程实现它们的办理流程，请使用C++自带的queue必须使用队列实现，其他方法0分！队列queue的用法如下：包含头文件：#include定义一个整数队列对象：queue myQe;定义一个整数队列对象数组：queue myQA[10];入队操作：myQe.push(itemp);
Java链表数据结构详解：增删改查与实现
本文主要探讨了Java中如何理解和实现链表数据结构，并详细讲解了链表的增删改查操作。链表作为一种基础数据结构，虽然不像数组那样在内存中顺序存储，但它的特点是通过节点之间的引用关系连接，这使得在插入和删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值