C语言~无头链表，双向链表，双向循环链表

已于 2022-02-05 11:34:26 修改
阅读量1k 收藏 4
点赞数
分类专栏： 数据结构 文章标签： c语言 链表 数据结构
于 2022-01-26 12:08:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61327008/article/details/122692043
版权

目录

无头链表：

双向链表：

双向循环链表：

无头链表：

头插：

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

//使用二级指针方法
//无头链表：第一个节点存放数据
struct Node
{
	int data;
	struct Node* next;
};
//创建节点
struct Node* createNode(int data)
{
	struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
	if (!newNode)
	{
		return NULL;
	}
	newNode->data = data;
	newNode->next = NULL;
	return newNode;
}
//头插
void insertNodeByhead(struct Node** list,int data)
{
	struct Node* newNode = createNode(data);
	newNode->next = (*list);//新节点指向原来的表头
	(*list) = newNode;//然后现在新的节点又变成表头
}

尾插：

//尾插
void insertNodeByTail(struct Node* list,int data)
{
	struct Node* newNode = createNode(data);
	struct Node* pMove = list;
	while (pMove->next != NULL)
	{
		pMove = pMove->next;
	}
	pMove->next = newNode;
}

指定位置删除：

//指定位置删除
void delNode(struct Node** list,int num)
{
	struct Node* posNodeFront = *list;
	if (posNodeFront == NULL)
	{
		printf("链表为空");
		return;
	}
	if ((posNodeFront->next == NULL) && (posNodeFront->data != num))
	{
		printf("找不到指定位置！\n");
		return;
	}
	if (posNodeFront->data == num)
	{
		struct Node* posNode = posNodeFront->next;
		*list = posNode;
		free(posNodeFront);
		posNodeFront == NULL;
		return;
	}
	struct Node* posNode = posNodeFront;
	while (posNode->data != num)
	{
		posNodeFront = posNode;
		posNode = posNodeFront->next;
		if (posNode == NULL)
		{
			printf("找不到指定位置\n");
		}
	}
	posNodeFront->next = posNode->next;
	free(posNode);
	posNode = NULL;
}

另一种写法，在封装方式：

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

struct Node
{
	int data;
	struct Node* next;
};
struct Node* createNode(int data)
{
	struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
	newNode->data = data;
	newNode->next = NULL;
	return newNode;
}
//创建链表
struct List
{
	struct Node* frontNode;
	struct Node* tailNode;
	int size;
};
struct List* creatList()
{
	struct List* list = (struct List*)malloc(sizeof(struct List));
	list->frontNode = list->tailNode = NULL;
	list->size = 0;
	return list;
}
//头插
void insertNodeByHead2(struct List* list,int data)
{
	struct Node* newNode = createNode(data);
	if (list->size == 0)//第一个节点既是表尾元素表头节点
		list->tailNode = newNode;
	else
		newNode->next = list->frontNode;
	list->frontNode = newNode;
	list->size++;
}
//尾插
void insertNodeByTail2(struct List* list, int data)
{
	struct Node* newNode = createNode(data);
	if (list->size == 0)
		list->frontNode = newNode;
	else
		list->tailNode->next = newNode;
		list->tailNode = newNode;
	list->size++;
}
void PrintNode(struct List* list)
{
	struct Node* pMove = list->frontNode;
	while (pMove)
	{
		printf("%d\t", pMove->data);
		pMove = pMove->next;
	}
	printf("\n");
}
int main()
{
	struct List* list = creatList();
	insertNodeByHead2(list, 111);
	insertNodeByHead2(list, 424);
	insertNodeByHead2(list, 333);
	insertNodeByHead2(list, 3343);
	PrintNode(list);

    return 0;
}

双向链表：

头插：

尾插：

指定位置插入

 代码：

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

struct Node
{
	int data;
	struct Node* left;
	struct Node* right;
};

//创建节点
struct Node* createNode(int data)
{
	struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
	newNode->data = data;
	newNode->left = newNode->right = NULL;
	return newNode;
}

struct List
{
	//万金油
	int size;
	struct Node* firstNode;//第一个节点
	struct Node* lastNode;//第二个节点（尾节点）
};

//任何东西都是从无到有
struct List* createlist()
{
	//申请内存
	struct List* list = (struct List*)malloc(sizeof(struct List));

	//初始化
	list->size = 0;
	list->firstNode = list->lastNode = NULL;
	return list;
}
//头插
void insertNodeByHead(struct List* list,int data)
{
	struct Node* newNode = createNode(data);
	if (list->firstNode == NULL)
		list->lastNode = newNode;
	else
	{
		list->firstNode->left = newNode;
		newNode->right = list->firstNode;
	}
	list->firstNode = newNode;
	list->size++;
}
//尾插
void insertNodeByTail(struct List* list, int data)
{
	struct Node* newNode = createNode(data);
	if (list->lastNode == NULL)
		list->firstNode = newNode;
	else
	{
		list->lastNode->right = newNode;
		newNode->left=list->lastNode;
	}
	list->lastNode = newNode;
	list->size++;
}
//指定位置插入
void insertNodePos(struct List* list, int data, int num)
{
	if (list->size == 0)
	{
		printf("链表为空");
		return;
	}
	else if (list->firstNode->data == num)
	{
		insertNodeByHead(list, data);
	}
	else
	{
		struct Node* posNode = list->firstNode->right;
		struct Node* posNodeFront = list->firstNode;
		while ((posNode!=NULL) && (posNode->data != num))
		{
			posNodeFront = posNode;
			posNode = posNode->right;
		}
		if (posNode==NULL)
		{
			printf("找不到\n");
			return;
		}
		else
		{
			struct Node* newNode = createNode(data);
			posNodeFront->right = newNode;
			newNode->left = posNodeFront;
			newNode->right = posNode;
			posNode->left = newNode;
			list->size++;
		}
	}
}

void PrintNodeByRight(struct List* list)
{
	if (list->size == 0)
	{
		printf("链表为空无法打印");
	}
	else
	{
		//从前面开始打印
		struct Node* pMove = list->firstNode;//这里注意不要写成list->firstNode->right,不然打印第一个数据不会打印跳过list->firstNode的数据
		while (pMove)
		{
			printf("%d\t", pMove->data);
			pMove = pMove->right;
		}
		printf("\n");
	}
}

void PrintNodeByLeft(struct List* list)
{
	if (list->size == 0)
	{
		printf("链表为空无法打印");
	}
	else
	{
		//从后面开始打印
		struct Node* pMove = list->lastNode;
		while (pMove)
		{
			printf("%d\t", pMove->data);
			pMove = pMove->left;
		}
		printf("\n");
	}
}

int main()
{
	struct List* list = createlist();
	insertNodeByHead(list, 2);
	insertNodeByHead(list, 3);
	insertNodeByHead(list, 6);
	insertNodeByTail(list, 90);
	insertNodeByTail(list, 900);
	insertNodePos(list, 333,6);
	PrintNodeByRight(list);
	return 0;
}

双向循环链表：

尾插：

 指定位置插入：

代码：

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

struct Node
{
	int data;
	struct Node* left;
	struct Node* right;
};

//创建链表
struct Node* createlist()
{
	struct Node* headNode = (struct Node*)malloc(sizeof(struct Node));
	if (!headNode)
		printf("创建失败\n");
	else
		headNode->left = headNode->right = headNode;

		return headNode;
}
//创建节点
struct Node* createNode(int data)
{
	struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
	if (newNode == NULL)
		printf("创建新节点失败");
	else
	{
		newNode->left = newNode->right =NULL;
		newNode->data = data;
	}
	return newNode;
}
//尾插
void insertNodeByTail(struct Node* headNode, int data)
{
	struct Node* newNode = createNode(data);
	if (newNode == NULL)
	{
		return;
	}
	else
	{
		struct Node* TailNode = headNode->left;
		//这里顺序可以调乱
		headNode->left = newNode;
		newNode->right = headNode;
		newNode->left = TailNode;
		TailNode->right = newNode;	
	}
}
//指定位置插入
void insertNodeByPos(struct Node* headNode,int data,int num)
{
	if ((headNode->left = headNode->right) == headNode)
	{
		printf("链表为空\n");
		exit(0);
	}
	else
	{
		struct Node* newNode = createNode(data);
		struct Node* posNodeFront = headNode;
		struct Node* posNode = headNode->right;
		while (posNode != headNode && posNode->data != num)
		{
			posNodeFront = posNode;
			posNode = posNode->right;
		}
		if (posNode == headNode)
		{
			printf("找不到指定位置");
			exit(0);
		}
		
		else
		{
			//这里也是可以调乱顺序
			posNodeFront->right = newNode;
			newNode->left = posNodeFront;
			newNode->right = posNode;
			posNode->left = newNode;
		}
	}
}
//打印
void PrintNode(struct Node* headNode)
{
	if ((headNode->left = headNode->right)==headNode)
	{
		printf("链表为空，无法打印\n");
		exit(0);
	}
	struct Node* pMove = headNode->right;
	while (pMove!=headNode)
	{
		printf("%d\t", pMove->data);
		pMove = pMove->right;
	}
	printf("\n");
}


int main()
{
	struct Node* list = createlist();
	insertNodeByTail(list, 2);
	insertNodeByTail(list, 3);
	insertNodeByTail(list, 4);
	insertNodeByTail(list, 5);
	PrintNode(list);
	insertNodeByPos(list, 9,2);
	PrintNode(list);

	return 0;
}

 纯属笔记，方便日后复习！

Luckys-Yang
关注
专栏目录
数据结构-双向循环链表(无头结点)相关操作
程国华的专栏
03-22 894
实现了数据结构的双向循环链表的相关操作。
c语言之————无头循环双链表
long123bin的专栏
07-21 620
本例是用双链表实现的统计学生信息程序 dlist.h
c语言 双链表封装 （无头链表）2020-12-15
陆星材的博客
05-25 204
//头文件 //#pragma once #ifndef HH_H #define HH_H #include <stdio.h> struct node { struct node *next, *prev; }; //h 结构体类型 list #define container_of(ptr, type, member) \ (type *)((char *)ptr - ( (unsigned int)&( (type *)0 )->member ) ) //.
Java 无头双向循环链表操作方法
unstoppable_t的博客
01-09 221
class ListNode{ private int val; private ListNode next; private ListNode prev; //结点创建方法 public ListNode(int val) { this.val = val; } public int getVal() { return val; } public void setVal(int val) {
无头双向链表的实现
weixin_45662626的博客
02-24 291
上一篇：不带头节点的单链表的实现 无头双向链表的实现 无头双向链表就是没有头节点，每个节点都有next和前驱prev的链表。 如下图示意： 我们来开始写代码，无头双向链表的实现： class Node{ public int data; public Node next; public Node prev; public Node(int data) { this.data = data; } } public class MyLinkedList
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
c语言 链表 双向链表 双向循环链表
02-26
本文将深入探讨C语言实现的双向链表和双向循环链表，以及如何将这些概念应用于Linux内核。双向链表与单向链表相比，具有更灵活的操作特性，而双向循环链表则在此基础上增加了循环的特性，使得遍历和操作更加方便。 ...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
最新发布
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
【Java数据结构】无头结点双向循环链表
懂技术的猫
05-25 289
public class CircleList<E> { private class Node<T> { private T value; private Node<T> prev; private Node<T> next; public Node(T value){...
无头结点链表实现
12-01
用C++简单实现无头结点的建表，插入，删除操作
数据结构-双向循环链表（无头结点）相关算法
weixin_30570101的博客
03-15 160
#include <stdio.h>#include <stdlib.h>#define OVERFLOW -2#define OK 1#define ERROR 0//此双向循环链表无头结点typedef int ElemType;typedef struct DulNode { ElemType data; struct DulNode *prior;...
数据结构链表（无头单向非循环链表、带头双向循环链表）
han_shi_lei的博客
03-05 559
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链 接次序实现的 。 8种链表结构： 1、 单向、双向 2、带头、不带头 3、单链表、循环链表 以下是两种最常用的链表： 1、无头单向非循环链表 2、带头双向循环链表 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结 构，如哈希桶、图的邻接表等等。另外这种结...
【数据结构】链式存储：链表（无头双向链表实现）
m0_72161237的博客
01-04 814
🌈节点由val域(数据域)，prev(前驱），next(后继)，对于prev域，其是引用类型，存放上一个节点的地址；对于next域，其是引用类型，存放下一个节点的地址。
链表之无头双向非循环链表（Java语言）
qq_57563254的博客
12-06 1045
无头双向链表（Java语言）前言介绍无头双向非循环链表节点类——ListNode链表类——MyLinkedList打印链表得到链表的长度查找是否包含关键字key插入一个元素——头插法插入一个元素——尾插法插入一个元素——任意位置插入寻找index位置的节点删除第一次出现key的节点删除所有key的节点清空链表总代码 前言 经过对于顺序表和单链表的熟悉我们已经对于数据结构有了简单的认识，这次我们了解无头双向链表的相关知识。 介绍 首先我们先看一下双向链表的结构： 这就是一个非常简单的双向链表，一个节点可以找
C语言双向链表
m0_55792911的博客
01-30 875
#include<stdio.h> #include<stdlib.h> #include<assert.h> //双向链表一般也是无头式数组链表，且采用再封装 typedef struct NODE{ //创建节点的结构的模板 int data; struct NODE *front; struct NODE *tail; }NODE ,*LPNODE; LPNODE createN.
C语言创建双链表用尾插法,C实现头插法和尾插法来构建非循环双链表（不带头结点）(示例代码)...
weixin_42356349的博客
05-22 336
在实际使用中，双链表比单链表方便很多，也更为灵活。对于不带头结点的非循环双链表的基本操作，我在《C语言实现双向非循环链表(不带头结点)的基本操作》这篇文章中有详细的实现。今天我们就要用两种不同的方式头插法和尾插法来建立双链表。代码上传至 https://github.com/chenyufeng1991/HeadInsertAndTailInsertDoubleList 。核心代码如下：//尾...
单链表无头非循环与双链表无头循环Java实现
chenbaifan的博客
11-11 819
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 话不多说，直接开撕— 下面先来单链表，先放今天要实现的内容模板 // 1、无头单向非循环链表实现 public class SingleLinkedList { //头插法 public void addFirst(int data); //尾插法 public void addLast(int data); //任意位置插入,第一个数据节点为0号下标
数据结构二（顺序表 & 链表;循环及无头循环链表 & 链栈 ）
yuanchunsi的博客
07-12 657
本篇博客主要介绍顺序表，队列，链表和链栈的使用！！！(顺序表 & 链表;循环链表;无头循环链表 & 链栈 & joseph函数)
C语言实现双向循环链表插入操作
在C语言中，双向循环链表是一种数据结构，它允许节点在链表的前后两个方向上进行遍历。这种链表的每个节点包含一个指向前一个节点（prior）和一个指向后一个节点（next）的指针。本资源主要讲解如何创建、显示以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Luckys-Yang

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

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

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

打赏作者

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

抵扣说明：

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

余额充值