链表操作

最新推荐文章于 2019-03-29 14:36:27 发布
最新推荐文章于 2019-03-29 14:36:27 发布
阅读量811 收藏
点赞数
分类专栏： 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/attitudeisaltitude/article/details/9750291
版权
头文件：List.h 
/***********
List.h
************/

//链表节点结构
struct ListNode
{
	int m_ivalue;
	ListNode* m_pNext;
};

//节点从尾部加入链表
void AddToTail(ListNode** pHead, int value);
//节点从头部加入链表
void AddToHead(ListNode** pHead,int value);
//打印链表
void PrintList(ListNode* pHead);
//摧毁链表
void DestroyList(ListNode** pHead);
//删除值为value的节点
void RemoveNode(ListNode** pHead, int value);
//逆序打印链表，利用栈实现
void PrintReverseList(ListNode* pHead);
//删除链表中toBeDeleted指向的节点
void DeleteNode(ListNode** pHead,ListNode* toBeDeleted);
//寻找倒数第K个节点
ListNode* KthNodeFromEnd(ListNode* pHead,int k);
//返回链表中的中间节点
ListNode* MidInList(ListNode* pHead);
//逆序链表
void ReverseList(ListNode** pHead);
//将两个有序的链表合并为一个有序链表
ListNode* Merge(ListNode* pHead1,ListNode* pHead2);
//用递归的方法将两个有序的链表合并为一个有序链表
ListNode* MergeRecurse(ListNode* pHead1,ListNode* pHead2);


源文件：List.cpp

/***********
List.cpp
************/
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <stack>
#include "List.h"

using namespace std;

void AddToTail(ListNode** pHead, int value)
{
	ListNode* pNode = new ListNode();
	if(NULL == pNode)
	{
		cout<<"No more memory"<<endl;
		return;
	}
	pNode->m_ivalue = value;
	pNode->m_pNext = NULL;

	if(NULL == (*pHead))
	{
		(*pHead) = pNode;
	}
	else
	{
		ListNode* ptmp = (*pHead);
		while(ptmp->m_pNext != NULL)
			ptmp = ptmp->m_pNext;
		ptmp->m_pNext = pNode;
	}
}

void AddToHead(ListNode** pHead,int value)
{
	ListNode* pNode = new ListNode();
	if(NULL == pNode)
	{
		cout<<"No more memory"<<endl;
		return;
	}
	pNode->m_ivalue = value;
	pNode->m_pNext = NULL;

	if(NULL == (*pHead))
	{
		(*pHead) = pNode;
	}
	else
	{
		pNode->m_pNext = (*pHead);
		(*pHead) = pNode;
	}
}

void PrintList(ListNode* pHead)
{
	if(NULL == pHead)
	{
		cout<<"No Data"<<endl;
	}
	else
	{
		while(pHead != NULL)
		{
			printf("%d ",pHead->m_ivalue);
			pHead = pHead->m_pNext;
		}
		printf("\n");
	}
}

void DestroyList(ListNode** pHead)
{
	if(NULL == pHead)
		return;
	ListNode* pNode = (*pHead);
	while(pNode != NULL)
	{
		(*pHead) = (*pHead)->m_pNext;
		delete pNode;
		pNode = (*pHead);
	}

}
void RemoveNode(ListNode** pHead, int value)
{
	if(NULL == (*pHead))
		return;
	ListNode* prior,*pDelete;
	if((*pHead)->m_ivalue == value)
	{
		pDelete = (*pHead);
		(*pHead) = (*pHead)->m_pNext;
	}
	else
	{
		prior = (*pHead);
		pDelete = (*pHead)->m_pNext;
		while(pDelete!=NULL && pDelete->m_ivalue != value)
		{
			pDelete = pDelete->m_pNext;
			prior = prior->m_pNext;
		}
		if(pDelete!=NULL && pDelete->m_ivalue == value)
		{
			prior->m_pNext = pDelete->m_pNext;
		}
	}
	if(pDelete != NULL)
	{
		delete pDelete;
		pDelete = NULL;
	}
}

//利用栈实现逆序打印链表
void PrintReverseList(ListNode* pHead)
{
	if(NULL == pHead)
		return;
	stack<ListNode*> nodes;
	ListNode* pNode;
	while(pHead)
	{
		nodes.push(pHead);
		pHead = pHead->m_pNext;
	}

	while(!nodes.empty())
	{	
		pNode = nodes.top();
		printf("%d ",pNode->m_ivalue);
		nodes.pop();
	}
	printf("\n");
}

void DeleteNode(ListNode** pHead,ListNode* toBeDeleted)
{
	if(NULL == (*pHead) || NULL == pHead || NULL == toBeDeleted)
	{
		cout<<"bad paramer"<<endl;
		return;
	} 
	ListNode* pNode = NULL;
	if(NULL == toBeDeleted->m_pNext && (*pHead) == toBeDeleted)
	{
		*pHead = NULL;
		delete toBeDeleted;
		toBeDeleted = NULL;
	}
	else if(NULL == toBeDeleted->m_pNext)
	{
		pNode = *pHead;
		while(pNode->m_pNext != toBeDeleted)
		{
			pNode = pNode->m_pNext;
		}
		pNode->m_pNext = NULL;
		delete toBeDeleted;
		toBeDeleted = NULL;
	}
	else
	{
		pNode = toBeDeleted->m_pNext;
		toBeDeleted->m_ivalue = pNode->m_ivalue;
		toBeDeleted->m_pNext = pNode->m_pNext;
		delete pNode;
	}
}

ListNode* KthNodeFromEnd(ListNode* pHead,int k)
{
	if(NULL == pHead || k<=0)
	{
		printf("bad paramer!\n");
		return NULL;
	}
		
	int i=1;
	ListNode* pPrior = pHead;
	ListNode* pBehind = pHead;
	for(i; i<k; i++)
	{
		if(NULL != pPrior->m_pNext)
			pPrior = pPrior->m_pNext;
		else
		{
			printf("No Kth data\n");
			return NULL;
		}
	}
	while(NULL != pPrior->m_pNext)
	{
		pPrior = pPrior->m_pNext;
		pBehind = pBehind->m_pNext;
	}
	return pBehind;
}

//返回链表的中间节点
ListNode* MidInList(ListNode* pHead)
{
	if(NULL == pHead)
		return NULL;
	if(NULL == pHead->m_pNext || NULL == pHead->m_pNext->m_pNext)
	{
		return pHead;
	}
	else
	{
		ListNode* pNodeTwoStep = pHead;
		ListNode* pNodeOneStep = pHead;
		while(pNodeTwoStep->m_pNext != NULL)
		{
			pNodeTwoStep = pNodeTwoStep->m_pNext;
			if(NULL != pNodeTwoStep->m_pNext)
				pNodeTwoStep = pNodeTwoStep->m_pNext;
			else
				break;
			pNodeOneStep = pNodeOneStep->m_pNext;
		}
		
		return pNodeOneStep;
	}	
}

//逆序链表
void ReverseList(ListNode** pHead)
{
	if(NULL == pHead)
	{
		printf("bad paramer\n");
		return;
	}

	ListNode* pBehind;
	ListNode* pMid;
	ListNode* pPrior;

	if(NULL == (*pHead)->m_pNext)
		return;
	else if(NULL == (*pHead)->m_pNext->m_pNext)
	{
		pPrior = (*pHead)->m_pNext;
		pPrior->m_pNext = (*pHead);
		(*pHead)->m_pNext = NULL;
		(*pHead) = pPrior;
	}
	else
	{
		pBehind = (*pHead);
		pMid = pBehind->m_pNext;
		pPrior = pMid->m_pNext;

		while(pPrior != NULL)
		{
			pMid->m_pNext = pBehind;
			pBehind = pMid;
			pMid = pPrior;
			pPrior = pPrior->m_pNext;
		}

		pMid->m_pNext = pBehind;
		(*pHead)->m_pNext = NULL;
		(*pHead) = pMid;
	}
}

//将两个有序的链表合并为一个有序链表
ListNode* Merge(ListNode* pHead1,ListNode* pHead2)
{
	if(NULL == pHead1 && NULL == pHead2)
		return NULL;
	else if(NULL == pHead1)
		return pHead2;
	else if(NULL == pHead2)
		return pHead1;

	ListNode* pMergeHead;
	ListNode* pTmpNode;
	if(pHead1->m_ivalue < pHead2->m_ivalue)
	{
		pMergeHead = pHead1;
		pHead1 = pHead1->m_pNext;
	}
	else
	{
		pMergeHead = pHead2;
		pHead2 = pHead2->m_pNext;
	}
	pTmpNode = pMergeHead;
	while(pHead1!=NULL && pHead2!=NULL)
	{
		if(pHead1->m_ivalue < pHead2->m_ivalue)
		{
			pTmpNode->m_pNext = pHead1;
			pHead1 = pHead1->m_pNext;
			pTmpNode = pTmpNode->m_pNext;
		}
		else
		{
			pTmpNode->m_pNext = pHead2;
			pHead2 = pHead2->m_pNext;
			pTmpNode = pTmpNode->m_pNext;
		}
	}

	if(NULL == pHead1)
		pTmpNode->m_pNext = pHead2;
	else if(NULL == pHead2)
		pTmpNode->m_pNext = pHead1;

	return pMergeHead;
}
//用递归的方法将两个有序的链表合并为一个有序链表
ListNode* MergeRecurse(ListNode* pHead1,ListNode* pHead2)
{
	if(NULL == pHead1 && NULL == pHead2)
		return NULL;
	else if(NULL == pHead1)
		return pHead2;
	else if(NULL == pHead2)
		return pHead1;

	ListNode* pMergeHead;
	if(pHead1->m_ivalue < pHead2->m_ivalue)
	{
		pMergeHead = pHead1;
		pMergeHead->m_pNext = MergeRecurse(pHead1->m_pNext,pHead2);
	}
	else
	{
		pMergeHead = pHead2;
		pMergeHead->m_pNext = MergeRecurse(pHead1,pHead2->m_pNext);
	}

	return pMergeHead;
}

主程序文件：main.cpp 

/***********
main.cpp
************/
#include <iostream>
#include <stdio.h>
#include "List.h"
using namespace std;

ListNode* returnpNode(ListNode* pHead)
{
	ListNode* pNode = pHead;
	while(pNode->m_ivalue != 8)
		pNode = pNode->m_pNext;

	return pNode;
}

int main()
{
	ListNode* head1 = NULL;
	ListNode* head2 = NULL;
	ListNode *pNode = NULL;
	AddToTail(&head1,1);
	AddToTail(&head1,3);
	AddToTail(&head1,5);
	AddToTail(&head2,2);
	AddToTail(&head2,4);
	AddToTail(&head2,6);
	AddToTail(&head2,7);
	PrintList(head1);
	PrintList(head2);
	pNode = MergeRecurse(NULL,NULL);
	PrintList(pNode);

	return 0;
}


long504377009
关注
专栏目录
懒惰删除.cpp
04-09
已通过编译，可运行
编写实现使用懒惰删除的标准链表操作的例程
wwj_bupt
03-27 3225
数据结构与算法分析——c语言描述 练习3.17 答案 老实说我觉得懒惰删除很坑，如何坑呢？坑在代码的实现，除了删除的函数其他都要麻烦很多。首先要再定义一个listRecord来储存链表的总数据，其次同样的函数要实现2种。例如advance函数，是该返回没有删除的下一个呢还是简单粗暴的返回下一个。链表的函数实现当然是要返回后者，而用户想要的是前者。所以你得实现两遍，而且还要想函数名字。麻烦
【Weiss】【第03章】练习3.17：懒惰删除
weixin_30662109的博客
03-20 822
【练习3.17】 不同于我们已经给出的删除方法，另一种是使用懒惰删除的方法。 为了删除一个元素，我们只标记上该元素被删除的信息（使用一个附加的位域）。 表中被删除和非被删除的元素个数作为数据结构的一部分被保留。 如果被删除元素和非被删除元素一样多，我们就遍历整个表，对所有被标记的节点执行标准的删除算法。 a.列出懒惰删除的优点和缺点。 b.编写实现使用懒惰删除的标准链表操作的例程。 ...
二叉树懒惰删除相关例程
swingzhou93的博客
04-29 1742
在编写二叉树懒惰删除相关例程时，发现findMin和findMax两个方法很是复杂，于是上网百度懒惰删除相关例程的解法，却没有找到。今天硬是用比较粗糙的方法憋了出来，既然网上无法百度的到，那么我就把我的解法贴出来交流交流吧。 首先是节点类 public class TreeNode { private T value;//节点值 private TreeNode left;//左节点
PHP链表操作简单示例
01-20
本文实例讲述了PHP链表操作。分享给大家供大家参考，具体如下： 在php中运行数据结构，基本都是用数组模拟的，只是用一直思想而已。 今天遇到的这个问题是，两个链表进行合并。 链表合并效果图 问题描述：A链表是...
python如何对链表操作
12-16
3. **链表操作**： - **添加结点**：`add_node` 方法用于在链表的尾部添加新的结点。 - **查看链表**：`view` 方法遍历链表并打印所有结点的值，形成链表的表示形式。 - **计算长度**：`length` 方法通过遍历链表...
c语言链表操作示例分享
09-04
本示例介绍了一个简单的线性链表操作，包括链表的创建、插入节点和打印链表内容。下面将详细解释代码中的关键知识点。 首先，我们定义了链表节点的结构体`chaink`，它包含一个字符型数据`c`和一个指向下一个节点的...
C语言链表操作
10-10
C语言链表操作，新手强烈推荐必看内容，不看会后悔。。。
链表c的经典实现(一)
luoganttcc的博客
08-03 340
链表c的经典实现(一) //本书代码来思想自于创客诚品的<<C语言从入门到精通>> //但我对原书代码做了较大的改动; // 个人认为算法与数据结构是一个程序员的内功,欲成为第一流的高手必须苦练内功 // 欲研究数据结构,必须写C #include<stdio.h>...
Chapter 3
Howar116的专栏
04-20 4857
3.1 编写打印出一个单链表的所有元素的程序。
标题：懒惰删除
pyb的博客
08-31 4832
摘要：（1）某些情况下删除是一种昂贵的操作，这个时候我们可以采用懒惰删除的办法。 （2）简单的标记要删除的节点是为已删除。然后在查找等例程里面都人为的忽视标记过的节点. (3)如果标记删除的节点大于总数一半，就进行一次遍历，删除所有标记节点.void Lazy_Delete(List L,int X) { List temp; List
二叉树搜索树的懒惰删除及相关的其他例程
DragonBark的博客
01-18 810
对于一棵二叉树，如果删除的次数不多，通常可以使用懒惰删除策略：当一个元素要被删除时，它仍留在树中，只是做一个删除的记号。但因为这个记号的存在，所以要修改插入等其他操作。 代码的最后给出了删除叶子节点和输出指定范围内的节点的定义，仅供参考。 #includeiostream> #includecstdlib> using namespace std; templatetypename T> c
剑指offer面试题5
ahuang1900的专栏
05-22 684
面试题5： 从尾到头打印链表 题目： 输入一个链表的头结点，从尾到头fanguol
08----------懒惰删除
冷炎嗄的博客
08-30 783
一直以来我们认为 Redis 是单线程的，单线程为 Redis 带来了代码的简洁性和丰富多样的数据结构。不过Redis内部实际上并不是只有一个主线程，它还有几个异步线程专门用来处理一些耗时的操作。 Redis 为什么要懒惰删除(lazy free)？ 删除指令 del 会直接释放对象的内存，大部分情况下，这个指令非常快，没有明显延迟。不过如果删除的 key 是一个非常大的对象，比如一个包含了千...
随记--做一个“懒惰”的程序员
Java之旅
10-29 850
当时由于各种外部接口的不稳定，经常发生各种各样的网络异常，后来总结出一些统计脚本，来统计这些异常，每天都要出一个程序员，对几个机器上的日志进行统计，然后把统计结果进行汇总记录，出报表，这是发生在程序员身上的重复机械性的活，并且经历了相当长的时间。 这时，真的需要程序员懒惰一些，数据从几个机器汇集一起，进行统计，汇总，自动邮件发出，即时不会，花点时间（比如3~5个工作日），给一个有信心、愿意研究这件事的人，是可以写出来的。
【Redis】懒惰删除
Franco的博客
03-29 1932
一直以来我们认为 Redis 是单线程的，单线程为 Redis 带来了代码的简洁性和丰富多样的数据结构。不过Redis内部实际上并不是只有一个主线程，它还有几个异步线程专门用来处理一些耗时的操作。 Redis 为什么要懒惰删除(lazy free)？ 删除指令del会直接释放对象的内存，大部分情况下，这个指令非常快，没有明显延迟。不过如果删除的 key 是一个非常大的对象，比如一个包含了千...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值