单链表（增、删、查找）

最新推荐文章于 2023-11-03 11:28:07 发布
最新推荐文章于 2023-11-03 11:28:07 发布
阅读量285 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/marilynmanson1/article/details/51557751
版权 
     用结构体构建单链表，实现单链表的基本功能。



//头文件
#pragma once
#include<stdio.h>
#include<assert.h>
#include<malloc.h>


typedef int DataType;
typedef struct ListNode
{
	DataType _data;
	struct ListNode *_next;
}ListNode;


//初始化
void InitList(ListNode **ppHead)
{
	*ppHead = NULL;
}

//销毁节点
void DestoryList(ListNode*& pHead)
{
	ListNode* cur = pHead;
	while (cur)
	{
		ListNode* tmp = cur;
		cur = cur->_next;
		free(tmp);
	}
	pHead = NULL;
}

ListNode* BuyNode(DataType x)
{
	ListNode* tmp = (ListNode*)malloc(sizeof(ListNode));
	assert(tmp);

	tmp->_data = x;
	tmp->_next = NULL;
	return tmp;
}

//尾插  
void PushBack(ListNode** ppHead, DataType x)   
{
	assert(ppHead);

	if (*ppHead = NULL)
	{
		*ppHead = BuyNode(x);
	}
	else
	{
		ListNode *tail = *ppHead;
		while (tail->_next != NULL)
		{
			tail = tail->_next;
		}
		tail->_next = BuyNode(x);
	}
}

//头插
void PushFront(ListNode* &pHead, DataType x)
{
	if (pHead == NULL)
	{
		pHead = BuyNode(x);
	}
	else
	{
		ListNode * tmp = BuyNode(x);
		tmp->_next = pHead;
		pHead = tmp;
	}
}

void PrintList(ListNode *pHead)
{
	ListNode *cur = pHead;
	while (cur != NULL)
	{
		printf("%d->", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}

//尾删
void PopBack(ListNode* &pHead)
{
	if (pHead == NULL)
	{
		printf("List is empty\n");
		return;
	}
	else if (pHead->_next == NULL)
	{
		free(pHead);
		pHead = NULL;
	}
	else
	{
		ListNode* prevTail = NULL, *tail = pHead;
		while (tail->_next != NULL)
		{
			prevTail = tail;
			tail = tail->_next;
		}
		prevTail->_next = NULL;
		free(tail);
	}
}

//头删
void PopFront(ListNode*& pHead)
{
	if (pHead == NULL)
	{
		printf("List is empty.\n");
		return;
	}
	else
	{
		ListNode* tmp = pHead;
		pHead = tmp->_next;
		free(tmp);	
	}
}

ListNode *Find(ListNode *pHead, DataType x)
{
	ListNode *cur = pHead;
	while (cur)
	{
		if (cur->_data == x)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

void Insert(ListNode* pos, DataType x)
{
	assert(pos);

	ListNode *tmp = BuyNode(x);
	tmp->_next = pos->_next;
	pos->_next = tmp;

	/*ListNode *next = pos->_next;
	ListNode *tmp = BuyNode(x);  //插入的节点
	pos->_next = tmp;
	tmp->_next = next;
	*/
}

void Erase(ListNode* &pHead, ListNode *pos)
{
	assert(pos);

	
	if (pos == pHead)
	{
		pHead = pHead->_next;
		free(pHead);
	}
	else
	{
		ListNode* cur = pHead;
		while (cur)
		{
			if (cur->_next != pos)
			{
				cur->_next = pos->_next;
				free(pos);
				break;
			}
			cur = cur->_next;
		}
	}
}

void DelNonTailNode(ListNode* pos)//删除不知头和不是尾部的节点
{
	assert(pos&&pos->_next);

	pos->_data = pos->_next->_data;
	ListNode *next = pos->_next->_next;
	free(pos);
	pos->_next = next;
}

void Remove(ListNode* &pHead, DataType x)
{
	ListNode* ret = Find(pHead, x);
	if (ret)
	{
		Erase(pHead, ret);
	}
/*
	ListNode *node1 = pHead;
	ListNode *node2 = NULL;
	if (pHead == NULL)
	{
		return ;
	}
	else
	{
		if (node1->_data == x)
		{
			pHead = pHead->_next;
			free(node1);
			return ;
		}
		else
		{
			while (node1 != NULL)
			{
				node2 = node1;
				node2 = node2->_next;
				if (node2->_data== x)
				{
					node1->_next = node2->_next;
					free(node2);
					break;
				}
				node1 = node1->_next;
			}
		}
	}*/
}

void Reverse(ListNode* &pHead)      //逆置
{
	if (pHead == NULL || pHead->_next == NULL)
	{
		return;
	}
	ListNode* cur = pHead;
	ListNode* newHead = NULL;
	while (cur)
	{
		ListNode* tmp = cur;
		cur = cur->_next;
		tmp->_next = newHead;
		newHead = tmp;
	}
	pHead = newHead;
}

void PrintTailToHead(ListNode *pHead)
{
	if (pHead)
	{
		PrintTailToHead(pHead->_next);

		printf("%d\n",pHead->_data);
	}
}

ListNode* FindMid(ListNode* pHead)//查找单链表的中间节点，要求只能遍历一次链表（快慢指针，一个走一步，另一个走两步）
{
	if (pHead == NULL || pHead->_next == NULL)
	{
		return pHead;
	}

	ListNode* fast = pHead;
	ListNode* slow = pHead;
	while (fast)
	{
		fast = fast->_next->_next;
		slow = slow->_next;
	}
	return slow;
}

void InsertFrontNode(ListNode* pos,DataType x)
{
	assert(pos);

	ListNode* tmp = BuyNode(x);
	tmp->_next = pos->_next;
	pos->_next = tmp;

	DataType tmpData = tmp->_data;
	tmp->_data = pos->_data;
	pos->_data = tmpData;

}

ListNode* JosephCycle(ListNode* pHead, int m)//删除节点
{
	ListNode* cur = pHead;
	if (cur == NULL)
		return NULL;

	while (1)
	{
		//只剩一个节点
		if (cur = cur->_next)
		{
			return cur;
		}

		int x = m;
		while (--x)//走m-1步
		{
			cur = cur->_next;
		}
		//替换法进行删除
		cur->_data = cur->_next->_data;
		ListNode* del = cur->_next;
		cur->_next = del->_next;

		free(del);
	}
}


//快速排序
//冒泡排序
void SortList(ListNode* pHead)
{

	if (pHead == NULL || pHead->_next == NULL)
		return;
	ListNode *tail = NULL;
	ListNode*cur = pHead->_next;
	ListNode*prev = pHead;

	while (tail != pHead)
	{
		int exchange = 0;//优化不交换情况
		while (cur != tail)
		{

			if (cur->_data <prev->_data)
			{
				DataType temp = cur->_data;
				cur->_data = prev->_data;
				prev->_data = temp;
				exchange = 1;
			}
			prev = cur;
			cur = cur->_next;
		}
		if (exchange == 0)
			return;
		tail = prev;

		prev = pHead;
		cur = pHead->_next;
	}
}


//合并两个有序链表，合并后仍有序   先摘  后尾插
ListNode* MergeList(ListNode *pHead1, ListNode* pHead2)
{
	if (pHead1 == NULL)
	{
		return pHead2;
	}
	if (pHead2 == NULL)
	{
		return pHead1;
	}

	ListNode*cur1 = pHead1;
}

ListNode* FindKTailNode(ListNode* pHead, int k)
{
	ListNode *fast = pHead, *slow = pHead;
	while (--k)
	{
		if (fast == NULL)
		{
			return NULL;
		}
		fast = fast->_next;

		if (fast == NULL)
		{
			return NULL;
		}
	}

	while (fast->_next)
	{
		slow = slow->_next;
		fast = fast->_next;
	}
	return slow;
}

//合并两个有序链表
ListNode* MergeList(ListNode*pHead1, ListNode*pHead2)
{
	if (pHead1 == NULL)
		return pHead2;
	if (pHead2 == NULL)
		return pHead1;
	ListNode*newHead;
	ListNode*cur1 = pHead1;
	ListNode*cur2 = pHead2;
	ListNode*tail = NULL;
	if (cur1->_data < cur2->_data)
	{
		newHead = cur1;
		cur1 = cur1->_next;
	}
	else
	{
		newHead = cur2;
		cur2 = cur2->_next;
	}
	tail = newHead;//
	while (cur1&&cur2)
	{
		if (cur1->_data< cur2->_data)
		{
			tail->_next = cur1;
			cur1 = cur1->_next;
		}
		else
		{
			tail->_next = cur2;
			cur2 = cur2->_next;
		}
		tail = tail->_next;

		if (cur1 == NULL)
			tail->_next = cur2;
		if (cur2 == NULL)
			tail->_next = cur1;
	}
	return newHead;
}


//判断链表是否带环,环长度，环入口点
void RingList(ListNode* pHead)
{

	ListNode*slow = pHead;
	ListNode*fast = pHead;


	while (fast->_next)
	{

		slow = slow->_next;
		fast = fast->_next;
		if (fast->_next)
			fast = fast->_next;
		if (slow == fast)
		{
			printf( "链表中存在环\n" );
			//ListNode *tmp = slow;
			slow = slow->_next;
			int k = 1;
			while (slow != fast)
			{
				slow = slow->_next;
				k++;
			}
			printf("链表环长度为 %d\n", k );
			//一步走必然会在环上次相遇的地方再次相遇
			//当slow进入环时，必然会与fast相遇，最初想遇的就是环入口点
			slow = pHead;
			while (slow != fast)
			{
				slow = slow->_next;
				fast = fast->_next;
			}

			printf( "环入口值为：%d\n" , slow->_data );
			return;
		}

	}
	printf("链表中不带环\n");
}

//链表相交
void Intersect(ListNode*pHead1, ListNode * pHead2)
{
	if (pHead1 == NULL || pHead2 == NULL)
	{
		printf( "List is not insersect\n" );
		return;
	}

	ListNode *cur1 = pHead1;
	ListNode *cur2;
	while (cur1)
	{
		cur2 = pHead2;
		cur1 = cur1->_next;
		while (cur2)
		{
			if (cur1 == cur2)
			{
				printf( "链表相交，交点值为：%d\n", cur1->_data );
				return;
			}
			cur2 = cur2->_next;
		}

	}
	printf( "链表不相交\n");
	return;
}


int Size(ListNode*pHead)
{
	assert(pHead);

	int size = 0;
	ListNode*cur = pHead->_next;

	while (cur)
	{
		++size;
		cur = cur->_next;
	}
	return size;
}



//测试



#include<stdio.h>

#include"ListNode.h"


void test1()

{

ListNode * list = NULL;

PushBack(&list, 1);

PushBack(&list, 2);

PrintList(list);


PopFront(list);

PopFront(list);

PopFront(list);

PrintList(list);



ListNode* ret = Find(list, 3);

Erase(list, ret);

PrintList(list);


ListNode *ret1 = Find(list, 3);

InsertFrontNode(list, ret1->_data);

}


int main()

{

test1();

return 0;

}


本文出自 “二负” 博客，请务必保留此出处http://10324470.blog.51cto.com/10314470/1770126

MarilynManson1
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构单链表实验-增删查
10-20
3）能够实现词典的装载、添加、删除、按英文单词精确查找、按中文模糊查找，模糊查找时可能有多个匹配项，要求全部输出。 4）为实现上述功能，自行设计相应的结构体、类 5）考虑如何更快的完成操作 6）如何存储变化...
单链表的查找
jdhsgwhd的博客
10-04 4448
LocateElem(L,e): 按值查找操作，在表L中查找具有给定关键字的元素。GetElem(L,i) :按位查找操作，获取L中第i个位置的元素的值。头结点可看做是第0个结点。单链表的查找分为两种。
单链表的查找(按值查找、按位查找)(数据结构与算法)
最新发布
AII_IIA的博客
11-03 3053
什么是单链表？单链表是一种常见的链式数据结构，用于存储和操作数据元素的集合。它由一系列的节点组成，每个节点包含两个部分：数据域和指针域。单链表的每个节点包含了存储数据的数据域，以及指向下一个节点的指针域。通过这些指针域，节点之间可以按顺序连接起来，形成一个链式结构。链表的最后一个节点通常指向一个特殊的空节点（NULL或nullptr），表示链表的结束。相比于数组，链表的一大优势是它的动态性。在链表中，节点的添加、删除可以通过修改指针的指向来完成，不需要像数组那样进行元素的移动。
数据结构--单链表的查找
m0_60593173的博客
06-27 1586
均以带头结点链表为例:按位查找操作。获取表L中第i个位置的元素的值。:按值查找操作。在表L中查找具有给定关键字值的元素。
c#实现单链表_查找插入的操作
04-30
本程序由C#实现，如何定义单链表以及查找、插入、求长度基本操作。
单链表的操作
03-07
1）编程实现单链表的以下基本操作：建立单链表，查找单链表，插入单链表，删除单链表。 2）采用单链表结构编程实现：两个有序单链表的归并运算。
手写简单单链表实现功能
03-31
手动实现简单单链表实现，有助于学习数据结构之单链表。其中实现的功能有增删改查功能。单链表的优点是插入删除效率高。但不支持随机查找，查找效率低。
c 语言写的一个单链表 支持增、删、改、查、保存... 单链表的神器啊
08-06
c 语言写的一个单链表 支持增、删、改、查、保存本地 等多种操作，是一个比较全的写单链表的东西了，大家速度收藏... 单链表的神器啊 下面为具体支持的操作： printf("1: 创建链表\n"); printf("2: 显示链表\n");...
单向链表的类模板实现增加、删除、查找和打印
06-18
编写一个单向链表的类模板，分别实现增加、删除、查找和打印操作。目前来说这个方法非常好，很经典。希望对你有所帮助。
单链表的查找、插入、删除和打印（展示）
b312738566的博客
11-21 3583
单链表的查找、插入、删除和打印
单链表的查找（按序号，按值查找）
热门推荐
apple_2021的博客
07-31 1万+
单链表的查找操作 一. 按序号查找 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; } *LinkList,LNode; // 尾插建立单链表 LinkList List_ToolInsert (LinkList &L){ int x; L = (LinkList)malloc (sizeof(LNode)); LNode *s,*r =
【数据结构与算法】单链表的查找和建立
一以贯之的努力 不得懈怠的人生
09-22 818
单链表的按位查找、按值查找、尾插法和头插法
单链表的按序号查找结点和按位查找结点
m0_51769031的博客
05-20 3491
1、按序号查找结点，从单链表的第一个结点出发，直到找到第i个结点，否则返回最后一个结点指针域NULL； LinkList GetElem(LinkList L,int i) { int j=1; if(i==0) //如果i==0，则返回头结点 return L; if(i<1) //i给的值无效 { return NULL; } LinkList p=L->next; //第一个结点指针赋给p while(p&&j<i) {
单链表的基本操作-查找
w_nxsxs的博客
11-03 3442
【问题描述】 实现有头结点单链表查找算法：根据关键字值查找其在单链表中的位置(第一次出现的位置)。 【输入形式】 第一行输入整数n（n不大于1000），表示单链表长度； 第二行输入若干个整数（以非法整数或文件末尾作为结束），表示欲查找的关键字值； 【输出形式】 输出每个关键字值在单链表中的位置。若未找到，输出“no”。 【样例输入】 5 10 56 -34 -2 90 90 -100 34 56 e 【样例输出】 5 no no 2 单链表的查找算法 链表的访问均从
C++实现单链表增删改查
03-28
单链表是一种常用的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。单链表的操作包括增加节点、删除节点、修改节点和查找节点。下面是C语言实现单链表的增删改查示例代码： ```c #include <stdio.h> #include <stdlib.h> // 节点结构体 typedef struct node { int data; // 数据元素 struct node* next; // 指向下一个节点的指针 } Node; // 在单链表末尾增加节点 void addNode(Node** head, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (*head == NULL) { *head = newNode; } else { Node* current = *head; while (current->next != NULL) { current = current->next; } current->next = newNode; } } // 在单链表指定位置插入节点 void insertNode(Node** head, int index, int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; if (index == 0) { newNode->next = *head; *head = newNode; } else { Node* current = *head; for (int i = 0; i < index - 1 && current != NULL; i++) { current = current->next; } if (current != NULL) { newNode->next = current->next; current->next = newNode; } else { printf("Index out of range\n"); } } } // 在单链表指定位置删除节点 void deleteNode(Node** head, int index) { if (*head == NULL) { printf("List is empty\n"); return; } Node* current = *head; Node* previous = NULL; if (index == 0) { *head = current->next; free(current); } else { for (int i = 0; i < index && current != NULL; i++) { previous = current; current = current->next; } if (current != NULL) { previous->next = current->next; free(current); } else { printf("Index out of range\n"); } } } // 修改单链表指定位置节点的值 void modifyNode(Node* head, int index, int data) { if (head == NULL) { printf("List is empty\n"); return; } Node* current = head; for (int i = 0; i < index && current != NULL; i++) { current = current->next; } if (current != NULL) { current->data = data; } else { printf("Index out of range\n"); } } // 查找单链表指定位置节点的值 int searchNode(Node* head, int index) { if (head == NULL) { printf("List is empty\n"); return -1; } Node* current = head; for (int i = 0; i < index && current != NULL; i++) { current = current->next; } if (current != NULL) { return current->data; } else { printf("Index out of range\n"); return -1; } } // 打印单链表 void printList(Node* head) { if (head == NULL) { printf("List is empty\n"); return; } Node* current = head; printf("List: "); while (current != NULL) { printf("%d ", current->data); current = current->next; } printf("\n"); } int main() { Node* head = NULL; // 在单链表末尾增加节点 addNode(&head, 1); addNode(&head, 2); addNode(&head, 3); printList(head); // 在单链表指定位置插入节点 insertNode(&head, 1, 4); insertNode(&head, 0, 5); insertNode(&head, 6, 6); printList(head); // 在单链表指定位置删除节点 deleteNode(&head, 2); deleteNode(&head, 0); deleteNode(&head, 4); printList(head); // 修改单链表指定位置节点的值 modifyNode(head, 1, 7); modifyNode(head, 3, 8); modifyNode(head, 5, 9); printList(head); // 查找单链表指定位置节点的值 printf("Value at index 2: %d\n", searchNode(head, 2)); printf("Value at index 5: %d\n", searchNode(head, 5)); printf("Value at index 7: %d\n", searchNode(head, 7)); return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值