单链表中一些经典的问题-->约瑟夫环,链表逆序,查找链表结点...(上)

上篇博客中写了关于单链表的一些基本操作,接下来是对单链表的一些扩展问题,接下来实现如下问题:

     ---->从尾到头打印单链表--->删除链表的非尾结点，不遍历链表--->约瑟夫环--->使用冒泡方式对单链表进行排序--->单链表的逆序---(三个指针)---->单链表的逆序---(使用头插法)--->合并两个有序链表，合并起来依然要有序--->查找链表的中间结点，只遍历一次链表--->查找链表的倒数第K个结点等等。

下面用C语言代码实现：

    slist.c

//从尾到头打印单链表
void PrintSlistTail(pNode pHead)  //递归方式
{
	if (pHead)
	{
		PrintSlistTail(pHead->_pNext);
		printf("%d-->", pHead->_data);
	}
}


// 删除链表的非尾结点，要求不能遍历链表 
void DeleteNotTailNode( pNode pos) //替换法
{
	pNode pCur = NULL;
	if (NULL == pos || NULL == pos->_pNext)
	{
		return;
	}
	pCur=pos->_pNext;
	pos->_data=pos->_pNext->_data;
	pos->_pNext = pos->_pNext->_pNext;  
	free(pCur);                //释放结点
}




// 约瑟夫环 
void JosephCirclePre(pNode *pHead)  //构成环
{
	assert(pHead);
	pNode pCur = NULL;
	if (*pHead == NULL)
	{
		return;
	}
    pCur = *pHead;
	while (pCur->_pNext)
	{
		pCur = pCur->_pNext;
	}
	pCur->_pNext = *pHead;
}
void JosephCircle(pNode* pHead, const int M)  //删除结点
{
	assert(pHead);
	pNode pCur = NULL;
	int count = 0;
	if (*pHead == NULL)
	{
		return;
	}
	pCur = *pHead;
	while (pCur!=pCur->_pNext)
	{
		count = M;
		while (--count)
		{
			pCur = pCur->_pNext;
		}
		pCur->_data = pCur->_pNext->_data;
		pCur->_pNext = pCur->_pNext->_pNext;
	}
	pCur->_pNext = NULL;
	*pHead = pCur;
}
// 使用冒泡方式对单链表进行排序 
void BubbleSort(pNode pHead)
{
	assert(pHead);
	int i = 0;
	int j = 0;
	pNode pCur =NULL;
	int size = SListSize(pHead);
	for (i = 0; i < size-1; i++)
	{
		 pCur = pHead;
		for (j = 0; j < size - 1 - i; j++)
		{
			if ((pCur->_data)>(pCur->_pNext->_data))
			{
				int tmp = pCur->_data;
				pCur->_data = pCur->_pNext->_data;
				pCur->_pNext->_data = tmp;
			}
			pCur = pCur->_pNext;
		}
	}
}

// 单链表的逆序---三个指针 
void ReverseSList(pNode* pHead)
{
	assert(pHead);
	pNode pPre = NULL;
	pNode pCur = NULL;
	pNode pNext = NULL;
	if (*pHead == NULL)
	{
		return;
	}
	pCur = *pHead;
	while (pCur)
	{
		pNext=pCur->_pNext;
		pCur->_pNext = pPre;
		pPre = pCur;
		pCur = pNext;
	}
	*pHead = pPre;
}

// 单链表的逆序---使用头插法 
pNode ReverseSListOP(pNode pHead)
{
	pNode pNewNode=NULL;
	pNode pCur = pHead;
	while (pCur)
	{
		SListPushFront(&pNewNode, pCur->_data);
		pCur = pCur->_pNext;
	}
	return pNewNode;
}

// 合并两个有序链表，合并起来依然要有序 
pNode MergeSList(pNode pHead1, pNode pHead2)
{
	pNode pNewNode = NULL;
	pNode pCur1 =NULL;
	pNode pCur2 = NULL;
	if (pHead1 == NULL)  //判空
	{
		return pHead2;
	}
	else if (pHead2 == NULL)
	{
		return pHead1;
	}
	pCur1 = pHead1;
	pCur2 = pHead2;
	while (pCur1!=NULL && pCur2!=NULL)
	{
		if ((pCur1->_data) < (pCur2->_data))
		{
			sListPushBack(&pNewNode, pCur1->_data);
			pCur1 = pCur1->_pNext;
		}
		else 
		{
			sListPushBack(&pNewNode, pCur2->_data);
			pCur2 = pCur2->_pNext;
		}
}
	if (pCur1==NULL &&pCur2!=NULL)
	{
		while (pCur2)
		{
			sListPushBack(&pNewNode, pCur2->_data);
			pCur2 = pCur2->_pNext;
		}
	}
	if (pCur2==NULL && pCur1!=NULL)
	{
		while (pCur1)
		{
			sListPushBack(&pNewNode, pCur1->_data);
			pCur1 = pCur1->_pNext;
		}
	}
	return pNewNode;
}

// 查找链表的中间结点，要求只能遍历一次链表 
pNode FindMiddleNode(pNode pHead)
{
	assert(pHead);
	pNode pCur = pHead;
	pNode pSlow = pCur;
	pNode pFast = pCur;
	
	while (pFast!=NULL && pFast->_pNext!=NULL)
	{
		pFast = pFast->_pNext->_pNext;
		pSlow = pSlow->_pNext;
	}
	return pSlow;
}

// 查找链表的倒数第K个结点(遍历一次链表) 
pNode FindLastKNode(pNode pHead, int K)
{
	assert(pHead);
	pNode pCur = pHead;
	pNode pFast = pHead;
	pNode pSlow = pHead;
	if (K < 0 || K>SListSize(pCur))
	{
		return NULL;
	}
	while (K--)
	{
		pFast = pFast->_pNext;
	}
	while (pFast!=NULL)
	{
		pFast = pFast->_pNext;
		pSlow = pSlow->_pNext;
	}
	return pSlow;
}

test.c

#include "slist.h"
//测试尾插
void testsListPushBack(pNode *pHead)
{
	sListPushBack(pHead, 1);
	sListPushBack(pHead, 2);
	sListPushBack(pHead, 3);
	sListPushBack(pHead, 4);
	printSList(*pHead);
	printNodeNum(*pHead);
}
//测试从尾到头打印单链表
void testPrintSlistTail(pNode pHead)
{
	PrintSlistTail(pHead); 
}
//测试 删除链表的非尾结点，要求不能遍历链表
void testDeleteNotTailNode(pNode pHead)
{
	DeleteNotTailNode(pHead->_pNext);
	printSList(pHead);
}
// 测试约瑟夫环 
void testJosephCircle(pNode *pHead)     
{
	JosephCircle(pHead, 3);
}

void testJosephCirclePre(pNode *pHead)   //测试是否成环
{
	JosephCirclePre(pHead);
	testJosephCircle(pHead);    //测试删除结点是否成功,解环
	printSList(*pHead);
}

//测试单链表的逆序---三个指针
void testReverseSList(pNode *pHead)
{
	ReverseSList(pHead);
	printSList(*pHead);
}

// 测试单链表的逆序---使用头插法
void testReverseSListOP(pNode pHead)
{
	pNode pCur=ReverseSListOP(pHead);
	printSList(pCur);
}
// 测试合并两个有序链表，合并起来依然要有序 
void testMergeSList(pNode pHead1,pNode pHead2)
{
	pNode pCur=MergeSList(pHead1, pHead2);
	printSList(pCur);
}
// 查找链表的中间结点，要求只能遍历一次链表 
void testFindMiddleNode(pNode pHead)
{
	pNode pCur=FindMiddleNode(pHead);
}

void testFindLastKNode(pNode pHead)
{
	pNode pCur = FindLastKNode(pHead, 1);
}
int main()
{
	pNode pHead;
	pNode pHead2;
	sListInit(&pHead);
	sListInit(&pHead2); 
	testsListPushBack(&pHead);
	testsListPushBack(&pHead2);
	testPrintSlistTail(pHead);
	testDeleteNotTailNode(pHead);
	testJosephCirclePre(&pHead);
	testReverseSList(&pHead);
	testReverseSListOP(pHead);
	testMergeSList(pHead, pHead2);
	testFindMiddleNode(pHead);
	testFindLastKNode(pHead);
	system("pause");
	return 0;
}

slist.h

#define _CRT_SECURE_NO_WARNINGS 0;
#pragma once
typedef int DataType; 
#include <stdio.h>

#include <assert.h>
#include <stdlib.h>
typedef struct SListNode
{
	struct SListNode* _pNext; //指向链表的的下一个结点
	DataType _data; //当前结点中所保存的元素
}Node,*pNode;


void PrintSlistTail(pNode pHead);
void DeleteNotTailNode(pNode pos);

void JosephCirclePre(pNode *pHead);
void JosephCircle(pNode* pHead, const int M);
void BubbleSort(pNode pHead);
void ReverseSList(pNode* pHead);
pNode ReverseSListOP(pNode pHead);
pNode MergeSList(pNode pHead1, pNode pHead2);
pNode FindMiddleNode(pNode pHead);
pNode FindLastKNode(pNode pHead, int K);

在上面可能会涉及到一些对单链表删除，插入的基本操作，已发在上篇博客（单链表的一些基本操作），在这里就不详述。