数据结构------链表面试题总

数据结构------链表面试题总

以下代码是在vs2013下编写的：

我们先来看一下测试结果：

 

#pragma once
#include<stdio.h>
#include<windows.h>
#include<stdlib.h>
#include<assert.h>

//链表的定义
typedef int DataType;
typedef struct SListNode
{
	struct SListNode *pNext;//指向链表中下一个结点
	DataType data;//当前结点中保存的元素
}SListNode;

//初始化
void SListInit(SListNode **pFirst)
{
	assert(pFirst!=NULL);
	*pFirst = NULL;
}
//销毁
void SListDestroy(SListNode **pFirst)
{
	assert(pFirst != NULL);
	SListNode *pNode, *pNext;
	pNode = *pFirst;
	while (pNode != NULL)
	{
		pNext = pNode->pNext;
		free(pNode);
		pNode = pNext;
	}
	*pFirst = NULL;
}
SListNode * CreateNewNode(int data)
{
	SListNode *pNewNode = (SListNode *)malloc(sizeof(SListNode));
	assert(pNewNode);

	pNewNode->data = data;
	pNewNode->pNext = NULL;

	return pNewNode;
}
// 尾插
void PushBack(SListNode **ppFirst, DataType data)
{
	assert(ppFirst != NULL);

	SListNode *pNewNode = CreateNewNode(data);

	if (*ppFirst == NULL) {
		*ppFirst = pNewNode;
		return;
	}

	SListNode *pNode;
	pNode = *ppFirst;
	while (pNode->pNext != NULL) {
		pNode = pNode->pNext;
	}

	// pNode 就是倒数第一个
	pNode->pNext = pNewNode;
}



// 倒叙打印链表 
#if 1
void ReversePrint(SListNode *pFirst)
{
	SListNode *pNode, *end;//定义两个指针，分别指向头结点和尾结点，空间浪费小，时间大
	pNode = pFirst;
	end = NULL;
	while (end != pFirst)
	{
		while (pNode->pNext!=end)
		{
			pNode = pNode->pNext;
		}
		end = pNode;//依次找到最后一个，倒数第二个·······第一个
		printf(" <- %d ", pNode->data);
		pNode = pFirst;//让pnode为第一个结点，继续找
	}
	printf("\n");
 }
#endif 
#if 0
void show(SListNode*p){//用递归依次得到链表倒序，时间少，空间大
	if (p->pNext){
		show(p->pNext);
	}
	printf("<- %d", p->data);
}

void TestPrintR()
{
	SListNode *pFirst = NULL;

	PushBack(&pFirst, 1);
	PushBack(&pFirst, 2);
	PushBack(&pFirst, 3);
	PushBack(&pFirst, 4);
	PushBack(&pFirst, 5);
	show(pFirst);
}
#endif

// 头删
void PopFront(SListNode **ppFirst)
{
	assert(ppFirst != NULL);
	assert(*ppFirst != NULL);

	SListNode *pOldFirst = *ppFirst;
	*ppFirst = (*ppFirst)->pNext;
	free(pOldFirst);
}


//头插
void PushFront(SListNode **ppFirst, DataType data)
{
	assert(ppFirst != NULL);
	SListNode *pNewNode = CreateNewNode(data);
	pNewNode->pNext = *ppFirst;
	*ppFirst = pNewNode;
}

// 逆置链表 
#if 1
SListNode * ReverseList(SListNode *pFirst)
{
	//assert(pFirst!= NULL);
	SListNode *pNewFirst=NULL;//创建新结点
	DataType data;
	while (pFirst != NULL)
	{
		data = pFirst->data;
		PopFront(&pFirst);//头删
		PushFront(&pNewFirst, data);//头插
	}
	return pNewFirst;
}
#endif
SListNode * ReverseList2(SListNode *pFirst)
{
	if (pFirst == NULL) {
		return NULL;
	}
	SListNode *p1 = NULL;
	SListNode *p2 = pFirst;//1的地址
	SListNode *p3 = pFirst->pNext;//2的地址
	while (p2)
	{
		p2->pNext = p1;
		p1 = p2;//1->null
		p2 = p3;//2->1->null
		if (p3 != NULL)
		{
			p3 = p3->pNext;//获得3的地址
		}
	}
	return p1;
}
//查找
SListNode *Find(SListNode *pFirst,DataType data)
{
	SListNode *pNode;
	for (pNode = pFirst; pNode; pNode = pNode->pNext)
	{
		if (pNode->data == data)
		{
			return  pNode;
		}
	}
	return NULL;
	
}

// 删除非尾无头链表 
//首先，我们先建立一个节点pCur，令节点pCur指向要删除的节点pos的下一个节点，然后，我们先把pCur的值赋给pos, 然后再删除掉pCur这个节点，
void RemoveNodeNotTail(SListNode *pos)
{
	assert(pos != NULL);

	SListNode *pCur = pos->pNext;

	// 让 pos 的下一个指向 原来下一个的下一个
	pos->pNext = pCur->pNext;
	pos->data = pCur->data;

	free(pCur);
}

// 无头链表前插入 
void InsertNoHead(SListNode *pPos, int data)
{
	SListNode *pNewNode = (SListNode *)malloc(sizeof(SListNode));
	assert(pNewNode != NULL);

	pNewNode->data = pPos->data;
	pNewNode->pNext = pPos->pNext;
	pPos->data = data;
	pPos->pNext = pNewNode;
}

/*
约瑟夫环
*/
SListNode * JocephCircle(SListNode *pFirst, int k)
{
	//先将链表构成一个循环链表
	SListNode *pNode = pFirst;
	SListNode *pPrev = NULL;
	int i = 0;
	while (pNode->pNext)
	{
		pNode = pNode->pNext;
	}
	pNode->pNext = pFirst;
	//开始执行
	pNode = pFirst;
	while (pNode->pNext != pNode)
	{
		for (i = 0; i < k - 1; i++)//找到第k个结点
		{
			pPrev = pNode;
			pNode = pNode->pNext;
		}

		//删除第k个结点
		pPrev->pNext = pNode->pNext;
		free(pNode);

		//记住让pNode指向下一个
		pNode = pPrev->pNext;
	}

	return pNode;
}


// 合并两个有序链表 
SListNode * MergeOrderedList(SListNode *p1First, SListNode *p2First)
{
	SListNode *p1 = p1First;
	SListNode *p2 = p2First;
	SListNode *pNewFirst = NULL;
	while (p1 != NULL&&p2 != NULL)
	{
		if (p1->data < p2->data)
		{
			PushBack(&pNewFirst, p1->data);
			p1 = p1->pNext;
		}
		else
		{
			PushBack(&pNewFirst, p2->data);
			p2 = p2->pNext;
		}
	}

		//判空
		SListNode *NotEmpty = p1;
		if (p1 == NULL)
		{
			NotEmpty = p2;
		}
		while (NotEmpty != NULL)
		{
			PushBack(&pNewFirst, NotEmpty->data);
			NotEmpty = NotEmpty->pNext;
		}
	
		return pNewFirst;
}



// 遍历一次，找到中间结点 
SListNode * FindMid(SListNode *pFirst)
{
	//定义一个快慢指针，两个先一起到第一个结点，然后让快的先走一步，也就是快的走两步，慢的走一步。
	SListNode *pSlow=pFirst;
	SListNode *pFast=pFirst;
	while (1)
	{
		pSlow = pSlow->pNext;
		pFast = pFast->pNext;
		if (pFast == NULL)
		{
			break;
		}
		pFast = pFast->pNext;
		if (pFast == NULL)
		{
			break;
		}
	}
	return pSlow;
}


// 遍历一次，找到倒数第 k 个结点（k从1开始） 
SListNode * FindK(SListNode *pFirst, int k)
{
	if (pFirst == NULL || k == 0)
	{
		return NULL;
	}
	//定义两个指针
	SListNode *p1=pFirst;//先走k-1步
	SListNode *p2=pFirst;//然后两个同时走
	int i = 0;
	for (i = 0; i <= k - 1; i++)
	{
		p1 = p1->pNext;
	}
	while (p1)
	{
		p1 = p1->pNext;
		p2 = p2->pNext;
	}
	return p2;

}


// 遍历一次，删除倒数第 k 个结点（k从1开始），不能用替换删除法 ,有问题
void RemoveK(SListNode *pFirst, int k)
{
	assert(pFirst);
	assert(k);
	SListNode *Find = FindK(pFirst, k);
	if (Find == pFirst)
	{
		PopFront(&pFirst);
		return ;
	}
	SListNode *pCur=pFirst;
	for (pCur = pFirst; pCur != Find; pCur = pCur->pNext)
	{
		;
	}
		//找到Find的前一个节点地址
		pCur->pNext = Find->pNext;
		free(Find);
}

// 判断两个链表是否相交，求交集
void UnionSet(SListNode *pFirst1, SListNode *pFirst2)
{//定义两个指针，小的往后走，依次判断
	SListNode *p1 = pFirst1;
	SListNode *p2 = pFirst2;
	while (p1 != NULL&&p2 != NULL)
	{
		if (p1->data < p2->data)
		{
			p1 = p1->pNext;
		}
		else if (p1->data>p2->data)
		{
			p2 = p2->pNext;
		}
		else{
			printf("%d  ", p1->data);
			p1 = p1->pNext;
			p2 = p2->pNext;
		}
	}

	printf("\n");
}



void Print(SListNode *pFirst)
{
	SListNode *pNode;
	for (pNode = pFirst; pNode; pNode = pNode->pNext)
	{
		printf("%d ->", pNode->data);
	}
	printf("NULL\n");
}
void TestSList()
{
	SListNode *pFirst;

	SListInit(&pFirst);
	assert(pFirst == NULL);

	//尾插
	printf("尾插：");
	PushBack(&pFirst, 1);
	PushBack(&pFirst, 2);
	PushBack(&pFirst, 3);
	PushBack(&pFirst, 4);
	PushBack(&pFirst, 5);
	Print(pFirst);


	printf("逆序打印链表：");
	ReversePrint(pFirst);


	printf("头删：");
	PopFront(&pFirst);//头删
	Print(pFirst);


	printf("头插：");
	PushFront(&pFirst, 1);//头插
	Print(pFirst);


	/*printf("逆置单链表：");
	SListNode *pNewFirst = ReverseList(pFirst);
	Print(pNewFirst);*/


	printf("逆置单链表：");
	SListNode *pNewFirst2 = ReverseList2(pFirst);
	Print(pNewFirst2);


	printf("无头链表前插入,找到了插入，没找到不插入");
	SListNode *pFound = Find(pFirst, 5);
	if (pFound == NULL) {
		printf("没有找到\n");
	}
	else {
		printf("找到了 ：%d\n", pFound->data);
	printf("无头链表前插入 :");
		InsertNoHead(pFound, 9);
		Print(pFirst);
	}

	/*printf("删除非尾无头链表：");
	SListNode *pFound2 = Find(pFirst, 2);
	RemoveNodeNotTail(pFound2);
	Print(pFirst);
*/

	printf("约瑟夫环 :");
	SListNode *pSuv = JocephCircle(pFirst, 3);
	printf("%d\n",pSuv->data);



	//合并两个有序链表并且输出有序
	//SListNode *pFirst2;
	//SListInit(&pFirst2);
	//assert(pFirst2 == NULL);
	尾插
	//printf("尾插二：");
	//PushBack(&pFirst2, 4);
	//PushBack(&pFirst2, 5);
	//PushBack(&pFirst2, 6);
	//PushBack(&pFirst2, 7);
	//PushBack(&pFirst2, 8);
	//Print(pFirst2);
	//printf("合并两个有序链表并且输出有序 :");
	//SListNode *pNewFirst3=MergeOrderedList(pFirst, pFirst2);
	//Print(pNewFirst3);


	//printf("遍历一次，找到中间结点 :");
	//SListNode *pFound3 = FindMid(pFirst);
	//printf("%d\n", pFound3->data);


	//printf("遍历一次，找到倒数第 k 个结点（k从1开始） :");
	//SListNode *pFound4 = FindK(pFirst, 2);
	// printf("%d\n", pFound4->data);


	// //printf("遍历一次，删除倒数第 k 个结点（k从1开始），不能用替换删除法 :");
	// //RemoveK(pFirst, 2);
	// //Print(pFirst);

	//printf("求交集 ：");
	//UnionSet(pFirst, pFirst2);


	//SListDestroy(&pFirst);
}