关于C单链表的面试题（基础篇）

question:

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

answer:

first of all  定义结构体

typedef int DataType;

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

1.比较顺序表和链表的优缺点

  
  

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

   
   

  
  
  
  

   
   2.从尾到头打印单链表
  
  
void printTaliToHead(ListNode* plist)//从尾到头打印单链表
{
	if(plist == NULL)
		return;
	printTaliToHead(plist->next);
	printf("%d->",plist->data);
}
  
  

   
   

  
  
  
  

   
   3.删除一个无头单链表的非尾节点 
   
   

  
  
  
  

   
   
void DelNoHeadNoTail(ListNode* pos)//删除一个无头单链表的非尾节点 
{
 assert(pos);
 assert(pos->next);
 ListNode* next = pos->next;
 pos->data = next->data;
 pos->next = next->next;
 free(next);
}
   
   

  
  
  
  

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

   
   
void AddNoHead(ListNode* pos, DataType x)//在无头单链表的一个节点前插入一个节点 
{
 assert(pos);
 ListNode* tmp = BuyNode(x);
 ListNode* next = pos->next;
 pos->next = tmp;
 tmp->next = next;
 DataType tmpData = pos->data;
 pos->data = tmp->data;
 tmp->data = tmpData;
}
   
   

  
  
  
  

   
   5.单链表实现约瑟夫环 
  
  
  
  

   
   问题描述：约瑟夫问题的一种描述是：编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。
  
  
ListNode* JosephRing(ListNode* list, int k)//约瑟夫环 
{
 ListNode* cur = list;
 ListNode* next = NULL;
 ListNode *pos = list;
 while(pos->next)
 {
  pos = pos->next;
 }
 pos->next = cur; //将单链表的首尾节点连起来成环
 if (list == NULL)
 {
  return NULL;
 }
 while (cur->next != cur)
 {
  int count = k;
  while (--count)
  {
   cur = cur->next;
  }
  next = cur->next;
  cur->data = next->data;
  cur->next = next->next;
  free(next);
 }
 return cur;
}
  
  

   
   

  
  
  
  

   
   6.逆置/反转单链表 
  
  
  
  

   
   
ListNode* Reverse(ListNode* list)//逆置/反转单链表 
{
	ListNode* newlist = NULL;
	ListNode* cur = list;
	ListNode* tmp = NULL;
	while (cur)
	{
		tmp = cur;
		cur = cur->next;
		tmp->next = newlist;
		newlist = tmp;
	}
	return newlist;
}
   
   

  
  
  
  

   
   7.单链表排序（冒泡排序&快速排序） 
  
  
  
  

   
   
void Bubblesort(ListNode* list)//单链表排序（冒泡排序&快速排序）
{
	ListNode* tail = NULL;
	ListNode* cur = NULL;
	ListNode* next = NULL;
	if ((list == NULL)||(list->next == NULL))
	{
		return;
	}
	while (tail != list->next)
	{
		cur = list;
		next = cur->next;
		while (next != tail)
		{
			if (cur->data > next->data)
			{
				DataType tmp = cur->data;
				cur->data = next->data;
				next->data = tmp;
			}
			cur = cur->next;
			next = next->next;
		}
		tail = cur;
	}
}
   
   

  
  
  
  

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

   
   
void Conbine(ListNode* list1,ListNode* list2)//合并两个有序链表,合并后依然有序
{
	ListNode* tmp = NULL;
	tmp = list1;
	if ((list1 != NULL)&&(list2 == NULL))
	{
		Bubblesort(list1);
	}
	else if ((list1 == NULL)&&(list2 != NULL))
	{
		Bubblesort(list2);
	}
	else
	{
		while (tmp->next)
		{
			tmp = tmp->next;
		}
		tmp->next = list2;
		Bubblesort(list1);
	}
}

  
  
  
  

   
   

  
  
  
  

   
   9.查找单链表的中间节点，要求只能遍历一次链表 
  
  
  
  

   
   
ListNode* SearchMid(ListNode* list)//查找单链表的中间节点，要求只能遍历一次链表 
{
	ListNode* fast = list;  
	ListNode* slow = list;
	while (fast && fast->next)
	{
		fast = fast->next->next;
		slow = slow->next;
	}
	return slow;
}
   
   

  
  
  
  

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

   
   
ListNode* SearchBKNode(ListNode* list, int k)//查找单链表的倒数第k个节点，要求只能遍历一次链表 
{
	ListNode* fast = list;  
	ListNode* slow = list; 
	int i = k;  
	for(i=0; i<k-1; i++)  
	{  
		fast = fast->next;
		if(fast == NULL)  
		{  
			return NULL;
		}  
	}
	while(fast->next)  
	{  
		fast = fast->next;  
		slow = slow->next;  
	}  
	return slow;  
}