数据结构——链表面试题

#pragma once

#include"slist.h"
//从头到尾打印单链表
void  print_single(SListNode *pFirst)
{
	assert(pFirst);
	SListNode *pNode = pFirst;
	SListNode *end = NULL;
	while (end != pFirst)
	{
		while (pNode->pNext != end)
		{
			pNode = pNode->pNext;
		}
		end = pNode;
		printf("%d ", pNode->data);
		pNode = pFirst;
	}
}
void show(SListNode *p)
{
	if (p->pNext)
	{
		show(p->pNext);
	}
	printf("%d ", p->data);
}
void  test1()
{
	SListNode *pFirst = NULL;
	SListPushFront(&pFirst, 1);
	SListPushFront(&pFirst, 2);
	SListPushFront(&pFirst, 3);
	SListPushFront(&pFirst, 4);
	SListPushFront(&pFirst, 5);
	print(pFirst);
	//print_single(pFirst);
	show(pFirst);
}

//逆置
SListNode * reverse_slist(SListNode *pFirst)
{
	SListNode *pNewNode = NULL;
	DataType data;
	while (pFirst)
	{
		data = pFirst->data;
		SListPopFront(&pFirst);
		SListPushFront(&pNewNode, data);
	}
	return pNewNode;
}
void test2()
{
	SListNode *pFirst = NULL;

	SListPushBack(&pFirst, 1);
	SListPushBack(&pFirst, 2);
	SListPushBack(&pFirst, 3);
	SListPushBack(&pFirst, 4);
	SListPushBack(&pFirst, 5);
	print(pFirst);
	SListNode *pNewNode = reverse_slist(pFirst);
	print(pNewNode);
}

//删除一个无头链表的非尾节点
void EraseNoFirstNotTail(SListNode *pPos)
{
	SListNode *pNode;
	pNode = pPos->pNext;

	pPos->pNext = pNode->pNext;
	pPos->data = pNode->data;
	free(pNode);
}
//在无头单链表前插一个节点
void InsertNoFirst(SListNode *pPos, DataType data)
{
	SListNode *pNewNode=(SListNode*)malloc(sizeof(SListNode));
	assert(pNewNode);
	pNewNode->pNext = pPos->pNext;
	pNewNode->data = pPos->data;
	pPos->data = data;
	pPos->pNext = pNewNode;
}
//约瑟夫环
SListNode * JocephCircle(SListNode *pFirst, int k)
{
	//将链表构造成一个环
	SListNode *pNode = pFirst;
	while (pNode->pNext != NULL)
	{
		pNode = pNode->pNext;
	}
	pNode->pNext = pFirst;
	//删除第k个结点
	SListNode *pCur = NULL;
	int i;
	pNode = pFirst;
	while (pNode->pNext != pNode)
	{
		/*while (k-1){
			pCur = pNode;
			pNode = pNode->pNext;
			k--;
		}*/	
		
		for (i = 0; i < k - 1; i++) {
			pCur = pNode;
			pNode = pNode->pNext;
		}
		pCur->pNext = pNode->pNext;
		free(pNode);
		pNode = pCur->pNext;

	}
	return pNode;
}
void BubbleSort(SListNode *pFirst)
{
	SListNode *pNode = pFirst;
	SListNode *pNode2 = NULL;
	while (pNode!= pNode2)
	{
		while (pNode->pNext != pNode2)
		{
			if (pNode->pNext->data < pNode->data)
			{
				DataType tmp = pNode->data;
				pNode->data = pNode->pNext->data;
				pNode->pNext->data = tmp;
			}
			pNode = pNode->pNext;
		}
		pNode2 = pNode;
		pNode = pFirst;
	}
}
// 合并两个有序链表 
SListNode * MergeOrderedList(SListNode *pFirst1, SListNode *pFirst2)
{
	SListNode *p1 = pFirst1;
	SListNode *p2 = pFirst2;
	SListNode *pNewFirst = NULL;
	while (p1!=NULL&&p2!=NULL)
	{
		if (p1->data < p2->data)
		{
			SListPushBack(&pNewFirst, p1->data);
			p1 = p1->pNext;
		}
		else if (p1->data > p2->data)
		{
			SListPushBack(&pNewFirst, p2->data);
			p2 = p2->pNext;
		}
		else
		{
			SListPushBack(&pNewFirst, p1->data);
			SListPushBack(&pNewFirst, p2->data);
			p1 = p1->pNext;
			p2 = p2->pNext;
		}
	}
	SListNode *pNotempty = p1;
	if (p1 == NULL)
	{
		pNotempty = p2;
	}
	while (pNotempty)
	{
		SListPushBack(&pNewFirst, pNotempty->data);
		pNotempty = pNotempty->pNext;
	}
	return pNewFirst;
}
// 遍历一次，找到中间结点 
SListNode * FindMid(SListNode *pFirst)
{
	SListNode *pFast = pFirst;
	SListNode *pSlow = pFirst;
	while (1)
	{
		pFast = pFast->pNext;
		if (pFast == NULL)
		{
			break;
		}
		pFast = pFast->pNext;
		if (pFast == NULL) {
			break;
		}
		pSlow = pSlow->pNext;
	}
	return pSlow;
}
// 遍历一次，找到倒数第 k 个结点（k从1开始） 
SListNode * FindK(SListNode *pFirst, int k)
{
	assert(pFirst);
	SListNode *pFast = pFirst;
	SListNode *pSlow = pFirst;
	while (k&&pFast)
	{
		pFast = pFast->pNext;
		k--;
	}
	if (k > 0)
	{
		return NULL;
	}
	while (pFast)
	{
		pFast = pFast->pNext;
		pSlow = pSlow->pNext;
	}
	return pSlow;
}
// 遍历一次，删除倒数第 k 个结点（k从1开始），不能用替换删除法 
void RemoveK(SListNode *pFirst, int k)
{
	assert(pFirst);
	SListNode *pNewNode = FindK(pFirst, k);
	SListErase(&pFirst,pNewNode);
}
void TestMergeOrderedList()
{
	SListNode *pFirst1 = NULL;

	SListNode *pFirst2 = NULL;
	SListPushBack(&pFirst1, 1);
	SListPushBack(&pFirst1, 2);
	SListPushBack(&pFirst2, 3);
	SListPushBack(&pFirst1, 4);
	SListPushBack(&pFirst2, 3);
	SListPushBack(&pFirst1, 4);
	SListPushBack(&pFirst1, 4);
	SListPushBack(&pFirst1, 4);
	SListPushBack(&pFirst2, 3);
	SListPushBack(&pFirst2, 5);
	SListPushBack(&pFirst2, 8);
	SListNode *pMerged = MergeOrderedList(pFirst1, pFirst2);//合并链表
	print(pMerged);
	SListNode *pMid = FindMid(pMerged);//找出中间结点
	printf("%d\n", pMid->data);
	SListNode *pMidk = FindK(pMerged,2);//找出倒数第k个结点
	printf("%d\n", pMidk->data);
	RemoveK(pMerged,2);
	print(pMerged);
}
void test3()
{
	SListNode *pFirst = NULL;

	SListPushBack(&pFirst, 1);
	SListPushBack(&pFirst, 2);
	SListPushBack(&pFirst, 3);
	SListPushBack(&pFirst, 4);
	SListPushBack(&pFirst, 5);
	print(pFirst);
	EraseNoFirstNotTail(pFirst->pNext);
    print(pFirst);
	InsertNoFirst(pFirst->pNext,100);
	print(pFirst);
	//SListNode *pSuv = JocephCircle(pFirst, 2);
	//printf("%d\n", pSuv->data);
	BubbleSort(pFirst);
	print(pFirst);
}