C语言实现单链表-面试题(基础篇)

单链表的实现(点击打开链接

单链表简易实现后有如下面试题

1.比较顺序表和链表的优缺点,说说它们分别在什么场景下使用?
2.从尾到头打印单链表
3.删除一个无头单链表的非尾节点
4.在无头单链表的一个节点前插入一个节点
5.单链表实现约瑟夫环
6.逆置/反转单链表
7.单链表排序(冒泡排序&快速排序)
8.合并两个有序链表,合并后依然有序
9.查找单链表的中间节点,要求只能遍历一次链表
10.查找单链表的倒数第k个节点,要求只能遍历一次链表

1.比较顺序表和链表的优缺点,说说它们分别在什么场景下使用? 

顺序表:内存中地址连续
长度不可变更
支持随机查找 可以在O(1)内查找元素
适用于需要大量访问元素的 而少量增添/删除元素的程序
链表 :内存中地址非连续
长度可以实时变化
不支持随机查找 查找元素时间复杂度O(n)
适用于需要进行大量增添/删除元素操作 而对访问元素无要求的程序


结构体的定义

typedef int DataType;

typedef struct ListNode
{
	DataType data;
	struct ListNode *next;
}ListNode;


2.从尾到头打印单链表 

函数实现

void TaliToHead(ListNode *plist)	//从尾到头打印单链表
{
	if(plist == NULL)
		return;
	TaliToHead(plist->next);
	printf("%d->",plist->data);
}
3.删除一个无头单链表的非尾节点 

void DeleteNoHead(ListNode **pos)	//删除一个无头单链表的非尾节点
{
	ListNode * cur = *pos;
	ListNode *prel = cur;
	while(cur->next)	//从该节点从前往后覆盖,并删除最后一个节点
		{
			prel = cur;
			cur->data = (cur->next)->data;
			cur = cur->next;
		}
	free(prel->next);
	prel->next = NULL;


}
4.在无头单链表的一个节点前插入一个节点 

void InsertNoHead(ListNode **pos, DataType x)	//无头单链表的一个节点前插入一个节点
{
	ListNode *cur = *pos;
	ListNode *ptemp = BuyNode(x);
	assert(*pos);
	ptemp->next = cur->next;
	cur->next = ptemp;
	ptemp->data = cur->data;
	cur->data = x;
}
5.单链表实现约瑟夫环

void JosephRing(ListNode **pplist,DataType x)	//约瑟夫环,x为间隔
{
	ListNode *cur = *pplist;
	ListNode *prel = *pplist;
	ListNode *ptem = NULL;
	if(NULL == *pplist || NULL == (*pplist)->next)
		return;
	while(cur->next)
	{
		cur = cur->next;
	}
	cur->next = prel;	//将单链表的首尾节点连起来成环。
	cur = *pplist;
	while(cur->next!=cur)
	{
		DataType n = x;
		while(n--)
		{
			prel = cur;
			cur = cur->next;
		}
		prel->next = cur->next;
		free(cur);
		cur = prel->next;
	}
	printf("%d\n",cur->data);	//最后剩下的节点

}

6.逆置/反转单链表 

void ReverseList(ListNode **pplist)	//逆序单链表
{
	ListNode *cur = *pplist;
	ListNode *ptemp = NULL;
	ListNode *ret = NULL;
	if(NULL == *pplist || NULL == (*pplist)->next)
		return;
	while(cur)
	{
		ptemp = cur;
		cur = cur->next;
		ptemp->next = ret;
		ret = ptemp;
		
	}
	*pplist = ret;
}
7.单链表排序(冒泡排序&快速排序)

 

void SortList(ListNode *plist)	//冒泡排序单链表
{
	ListNode *tail = NULL;
	if(NULL == plist || NULL == (plist)->next)
		return;
	while(plist->next != tail)	
	{
		ListNode *cur = plist;
		ListNode *next = cur->next;
		while(next != tail)
		{
			if(cur->data < next->data)
			{
				DataType temp = cur->data;
				cur->data = next->data;
				next->data = temp;
			}
			cur = next;
			next = next->next;

		}
		tail = cur;
	}
}


8.合并两个有序链表,合并后依然有序

void ListToList(ListNode **pplist,ListNode **pplist1)	//合并两个单链表
{
	ListNode *cur = *pplist;
	if(NULL == cur)
	{
		cur = *pplist1;
	}
	else
	{
		while(cur->next)
			cur = cur->next;
		cur->next = *pplist1;
	}
}
合并后再用一个上面的排序函数即可
 
9.查找单链表的中间节点,要求只能遍历一次链表 

ListNode *MidOfList(ListNode *plist)	//查找中间节点
{
	ListNode *fast = plist;	//快指针一次过两个节点
	ListNode *slow = plist;	//慢指针一次过一个,快指针到尾节点,慢指针就到中间节点
	if(NULL == plist || NULL == plist->next)
		return plist;
	else
	{
		while(fast && fast->next)
		{
			slow = slow->next;
			fast = fast->next->next;
		}
	}
	return slow;
	
}



10.查找单链表的倒数第k个节点,要求只能遍历一次链表

和上面找中间相似

ListNode *FindNum(ListNode *plist,DataType x)	//查找单链表中倒数第x个节点
{
	ListNode *fast = plist;
	ListNode *slow = plist;
	if(NULL == plist || NULL == plist->next)
		return plist;
	while(x--)	//快指针先跑x个节点
	{
		fast = fast->next;
	}
	while(fast && fast->next)	//快指针到尾节点是,慢指针刚好到倒数第X个节点
	{
		slow = slow->next;
		fast = fast->next;
	}
	return slow;
}

以上函数为简单思路,有待优化和提升,测试过没什么大问题,有大问题联系我。。 尴尬




  • 1
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值