C/C++之单链表（含约瑟夫问题）经典总结

在这个总结中，完成了大部分常用的单链表操作，如删除、插入结点，排序、逆序链表，约瑟夫问题等。约瑟夫问题的高效实现与分析参考其他经典算法，（从略）。

实现源代码如下：

// LinkListUD.cpp : Defines the entry point for the console application.

//

//-----header files

#include "stdafx.h"

#include <stdlib.h>

#include <stdio.h>

#include <iostream.h>

#include <windows.h>

//-----type definition

typedef int ElemType;

//-----global variables in this files

//-----Linklist NODE

typedef struct LNode

{

ElemType date;

struct LNode *next;

}linklist,*link;

//-------------------------统计链表长度：即结点个数-------------------

int Length(link pHead,BOOL bTypeofLinkList)

{

if(pHead==NULL)

exit(0);

//----

link pCurr;

pCurr=pHead->next;

//----

int n=1;

if (bTypeofLinkList) //单链表

{

while(pCurr->next!=NULL)

{

n++;

pCurr=pCurr->next;

}

//

n++;

}

else //单循环链表

{

while(pCurr!=pHead)

{

n++;

pCurr=pCurr->next;

}

}

return n;

}

//-----------------------------显示链表-------------------------//无空头结点

void DisplayList(link pHead,BOOL bTypeofLinkList)

{

link p,hs;

p=pHead;

hs=pHead;

//---链表是否存在？

if(pHead==NULL) //无空头结点

{

printf("List is empty or none\n");

exit(0);

}

//

if (bTypeofLinkList) //单链表结点数据输出方法

{

while (p->next!=NULL)

{

cout<<p->date<<"->";

p=p->next;

}

//**********单链表做收尾工作

cout<<p->date<<endl;//此时p为尾结点

}

else

{

//----------单循环链表结点数据输出方法

while(p->next!=hs) //**********循环单链表判别条件：是否返回到头结点？

{

cout<<p->date<<"->";

p=p->next;

}

//**********单循环链表做收尾工作

cout<<p->date<<endl; //p->next==hs,此时p为尾结点

}

}

//---------------------------创建默认的单链表----------------------------//无空头结点

linklist *CreateDefaultList(BOOL bTypeofLinkList,int rec_length)

{

//------------

link pHead = (linklist*)malloc(sizeof(linklist));

if (pHead==NULL)

{

cout<<"默认链表创建失败！"<<endl;

return NULL;

}

link pCurr=NULL,pPrev=NULL;

//------------

int i=1; //结点元素递增值:1,2,3,...,n。

pHead->date = i;

pPrev=pHead;

while (--rec_length>0) //

{

pCurr = (linklist*)malloc(sizeof(linklist));

i++;

pCurr->date = i;

pPrev->next=pCurr;

pPrev = pCurr;

}

//单链表/单循环链表?---单链表-------------单循环链表

(bTypeofLinkList)?(pCurr->next=NULL):(pCurr->next = pHead);

//pCurr->next = pHead; //构成环状单链表(约瑟夫环)，不带不存储数据的空头结点！

//

return pHead;

}

//---------------------------创建连续输入数据生成单链表----------------------------

linklist *CreateList(BOOL bTypeofLinkList) //创建循环单链表

{

link pHead=NULL; //header node

link pCurr=NULL; //新增分配结点地址

link pPrev=NULL; //前结点地址

int iInput;

//create header node

pHead=(linklist *)malloc(sizeof(linklist)); //返回指针型地址值

pHead->next=NULL;

//----输入连续数据直到遇到-1时退出

cout<<"Please input node infomation on and on until -1"<<endl;

scanf("%d",&iInput);

pHead->date=iInput;

//把此头结点赋给尾结点

pPrev=pHead;

//

while(1)

{

//用户输入回车后,按用户指定的格式从键盘上把有效数据输入到指定的变量之中,残留的信息存在于stdin流(键盘缓冲区)。

//对同一次输入的残余信息多次scanf，则可以将有效字符串逐次扫描变量iInput中,即可以完成用户输入的含有空格、跳格的字段。

scanf("%d",&iInput);

//

if(iInput!=-1) //将iInput值插入到新增结点上

{

//add new node

pCurr=(linklist *)malloc(sizeof(linklist));

//store ch

pCurr->date=iInput;

//==============add node's linkship

pPrev->next=pCurr;

pPrev=pCurr;

//==============

//--temp->next is set to NULL

pCurr->next=NULL;

}

else

{

if (bTypeofLinkList) //尾结点后继置空

{

pPrev->next=NULL;

}

else //元素结束时才将其首尾相接，简明清晰

{

pPrev->next=pHead; //end, tail point to header

}

break;

}

}

return pHead;

}

//-----------------------销毁链表--------------------------

char DestroyLinklist(link &L,BOOL bTypeofLinkList)

{

link p=L,judgeNode=L;

//------链表是否存在？

if (L==NULL)

{

printf("List is empty or none\n");

exit(0);

}

//--

if (bTypeofLinkList) //单链表

{

while(L->next!=NULL) //逐点销毁

{

p=L;

L=L->next;

free(p) ; //删除节点用free

}

//--释放最后一个结点

p=L;

free(p);

}

else //单循环

{

while(L->next!=judgeNode) //逐点销毁

{

p=L;

L=L->next;

free(p) ;

}

//--释放最后一个结点

p=L;

free(p);

}

//-----

L=NULL; //

//

return 'y';

}

//-----------------------打印分隔栏------------------------

void PrintPolice()

{

cout<<"---------------------------------------------------------\n";

}

//-------------------------------------插入结点-------------------------------------

linklist *InsertNodeToList(link &L,int iSite,ElemType iNodeValue,BOOL bTypeofLinkList,int iLen)

{

link pPrev,pCurr,pHead;

int iStart;

pHead=L;

pPrev=L; //某个前结点的地址

//----------插入头部

if (iSite==1) //做为第一结点插入链表头部

{

//Malloc向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。

//void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。

//pCurr= (link)malloc(sizeof(LNode)); //插入或者新增结点时才用malloc或者new

pCurr = new LNode;

pCurr->date=iNodeValue;

pCurr->next=NULL;

if (bTypeofLinkList) //单链表

{

pCurr->next=pPrev;

//----pCurr作为头结点

pPrev=pCurr;

pHead=pCurr;

cout<<"结点已经插入"<<endl;

}

else //单循环

{

while (pPrev->next!=pHead)

{

pPrev=pPrev->next;

}

//

pPrev->next = pCurr;

pCurr->next=pHead; //最后结点后继指向第一结点

//----pCurr作为头结点

pHead=pCurr;

cout<<"结点已经插入"<<endl;

}

//

return pHead;

}

//--------------插入尾部

if (iSite==(iLen+1))

{

//pCurr= (link)malloc(sizeof(LNode));

pCurr = new LNode;

pCurr->date=iNodeValue;

pCurr->next=NULL;

if (bTypeofLinkList) //单链表

{

while (pPrev->next!=NULL)

{

pPrev=pPrev->next;

}

//---

pPrev->next=pCurr;

cout<<"结点已经插入"<<endl;

}

else //单循环

{

while (pPrev->next!=pHead)

{

pPrev=pPrev->next;

}

//

pPrev->next=pCurr;

pCurr->next=pHead; //最后结点后继指向第一结点

cout<<"结点已经插入"<<endl;

}

return pHead;

}

//-------插入中间位置

iStart=1;

while(pPrev&&iStart<iSite-1) //直至链表中位置i-1处。

{

pPrev=pPrev->next; //移动临时结点pPrev的位置至计数i-1处

++iStart;

}

//pCurr= (link)malloc(sizeof(LNode));

pCurr = new LNode;

pCurr->date=iNodeValue;

pCurr->next=pPrev->next;

pPrev->next=pCurr; //此时，pCurr->next指向了pCurr；下一结点插入再循环指向。

cout<<"结点已经插入"<<endl;

//

return pHead;

}

//----------------------------------------删除结点-----------------------

linklist* DeleteListNode(link &L,int iSite,ElemType &iNodeValue,int iLen,BOOL bTypeofLinkList)

{

link pPrev,pCurr,pHead;

int iStart;

pHead=L;

pPrev=L;

pCurr=pPrev->next;

//----------删除头结点

if (iSite==1) //删除链表头部第一结点

{

if (bTypeofLinkList) //单链表

{

pPrev=pPrev->next;

iNodeValue=pHead->date;

free(pHead);

pHead=pPrev;

cout<<"结点已经删除"<<endl;

}

else //单循环

{

while (pPrev->next!=pHead)

{

pPrev=pPrev->next;

}

//

pPrev->next = pHead->next;

iNodeValue=pHead->date;

free(pHead);

pHead=pPrev;

cout<<"结点已经删除"<<endl;

}

//

return pCurr; //返回链表第二个结点地址

}

//--------------删除尾部结点-------------------

if (iSite==iLen)

{

if (bTypeofLinkList) //单链表

{

while (pCurr->next!=NULL)

{

pPrev=pCurr;

pCurr=pCurr->next;

}

//----delete the last node

pPrev->next=NULL;

iNodeValue=pCurr->date;

free(pCurr);

cout<<"结点已经删除"<<endl;

}

else //单循环

{

while (pCurr->next!=pHead)

{

pPrev=pCurr;

pCurr=pCurr->next;

}

//

pPrev->next=pHead;

iNodeValue=pCurr->date;

free(pCurr);

cout<<"结点已经删除"<<endl;

}

return pHead;

}

//-------删除中间位置结点

iStart=1;

while(pPrev&&iStart<iSite-1) //直至链表中位置i-1处。

{

pPrev=pCurr;

pCurr=pCurr->next;

++iStart;

}

//

pPrev->next=pCurr->next;

iNodeValue=pCurr->date;

free(pCurr);

cout<<"结点已经删除\n";

//

return pHead;

}

//--------------------------------查找结点------------------------------

void FindNode(link L,int iNodeValue,BOOL bTypeofLinkList)

{

if(L==NULL)

cout<<"链表未建立，请先构造链表\n" ;

else

{

link pPrev;

int iStart=1,iCount=0;

pPrev=L;

cout<<"你查找值的位置是：\n " ; //根据输入的数据值e输出查找到的响应位置值i

//---

if (bTypeofLinkList) //单链表

{

while(pPrev)
//从第1个结点开始比较

{

if(pPrev->date==iNodeValue)

{

iCount++;

cout<<iStart<<endl;

}

pPrev=pPrev->next;

iStart++;

}

cout<<"查找完毕\n";

if(iCount==0) //从另一方面讲，此时临时位置还在头结点上，即查找值不在链表中！

cout<<"你查找的值不在链表中!"<<endl;

}

else //单循环

{

while(pPrev->next!=L)//从第1个结点开始比较

{

if(pPrev->date==iNodeValue)

{

iCount++;

cout<<iStart<<endl;

}

pPrev=pPrev->next;

iStart++;

}

if(pPrev->date==iNodeValue)

{

iCount++;

cout<<iStart<<endl;

}

pPrev=pPrev->next;//pPrev返回到第一结点

//----

cout<<"查找完毕\n";

if(iCount==0) //从另一方面讲，此时临时位置还在头结点上，即查找值不在链表中！

cout<<"你查找的值不在链表中!"<<endl;

}

}

}

//---------------------------------链表排序-----------------------------------

//-------使用了最简单的比较法排序：实用，常用；时间复杂度为：T(N)=(N*N-N)/2=O(N*N),N为元素个数

void SortList(link &L,BOOL bTypeofLinkList)

{

if(L==NULL ||L->next==NULL ) //L=NULL表示未建立链表，L->next=NULL表示链表仅有头结点或者还根本未建立好！

cout<<"链表未建立或是空的，请先构造链表\n" ;

else

{

link pHead,pPrev,pCurr;

pHead=L;

pPrev=L; //begin with the first node

pCurr=pPrev->next;//the 2nd node

//--

if (bTypeofLinkList) //单链表

{

while(pPrev!=NULL)

{

pCurr=pPrev->next;

while(pCurr!=NULL) //

{

if(pPrev->date>pCurr->date) //从小到大排序

{

ElemType temp;

temp=pPrev->date;

pPrev->date=pCurr->date;

pCurr->date=temp;

}

pCurr=pCurr->next;//该点与其他所有点进行比较

}

pPrev=pPrev->next; //移动比较基点

}

}

else //单循环链表

{

while(pPrev->next!=pHead)//end with the last node

{

pCurr=pPrev->next;

while(pCurr!=pHead) //返回到第一个结点

{

if(pPrev->date>pCurr->date) //从小到大排序

{

ElemType temp;

temp=pPrev->date;

pPrev->date=pCurr->date;

pCurr->date=temp;

}

pCurr=pCurr->next;//该点与其他所有点进行比较

}

pPrev=pPrev->next; //移动比较基点

}

}

//-----

cout<<"链表已经排序 \n";

}

}

//--------------------------交换---指针或者引用方式皆可

void Myswap(link &a,link &b)

{

link temp;

temp=a;

a=b;

b=temp;

}

//---------------------------------链表逆序-------------------------------

//***********交换法

linklist* Swap_Reverse(link pHead,BOOL bTypeofLinkList)

{

//---防止传入为空链表

if ( pHead == NULL||pHead->next==NULL)

{

cout<<"链表未建立或是空的，请先构造链表\n" ;

}

//

link s_pHead=pHead,pPrev,pCurr;

pPrev = pHead->next;

pCurr = pPrev;

pHead->next = NULL;

//---

if (bTypeofLinkList) //单链表

{

while (pPrev != NULL) //尾结点后继

{

Myswap(pPrev->next, pHead);

Myswap(pHead, pPrev);

}

}

else //单循环链表

{

//----------//去掉尾首链接

while (pCurr->next!=s_pHead)//去掉尾首链接

{

pCurr=pCurr->next;

}

pCurr->next=NULL;

//---------- 单链表逆序

while (pPrev != NULL) //环表头结点

{

Myswap(pPrev->next, pHead);

Myswap(pPrev,pHead);

}

//--构成单环

pPrev=pHead->next;

while (pPrev->next!=NULL)

{

pPrev=pPrev->next;

}

pPrev->next=pHead; //尾首相连

}

//

return pHead;

}

//******直接法

linklist* Direct_Reverse(link pHead,BOOL bTypeofLinkList)

{

//---防止传入为空链表

if ( pHead == NULL||pHead->next==NULL)

{

cout<<"链表未建立或是空的，请先构造链表\n" ;

}

//

link t_pHead=pHead,pPrev(NULL),pCurr(NULL);

pPrev = t_pHead->next;

pHead->next = NULL;

//---

if (bTypeofLinkList) //单链表

{

while (pPrev != NULL) //直到尾结点后继

{

pCurr=pPrev->next;

pPrev->next=t_pHead;

t_pHead=pPrev;

pPrev=pCurr;

}

}

else //单循环链表

{

while (pPrev != pHead) //直到返回到头结点

{

pCurr=pPrev->next;

pPrev->next=t_pHead;

t_pHead=pPrev;

pPrev=pCurr;

}

//---

pPrev->next=t_pHead; //将尾首相连

}

//

return t_pHead; //返回逆序后的头结点

}

//pHead:约瑟夫环首地址,start:开始报数起点(相对空头结点的偏移位置),amount:环的大小,stop:报数任意上限设置.

//---------------------------------------------------------------------

linklist *JosephusKickout(link pHead,int start,int amount,int stop)

{

//约瑟夫环是否存在？

if(pHead==NULL||pHead->next==NULL)

{

cout<<"JosephusRing is empty or none!"<<endl;

exit(0);

}

//

link pCurr=NULL,pPrev=NULL;

pPrev=pHead;

pCurr=pHead->next;

int iStart(1); //此时n用于设置第一个开始报数时的起点位置start

//************退出循环 时pCurr,pPrev分别位于指定位置start

while(iStart++<start)

{

pCurr=pCurr->next;

pPrev=pPrev->next;

}

//***********接下去进行周期性结点删除，直到链表只余一个结点为止*****模拟了全部过程，复杂度O(amount*stop)

int iNodeNum=1; //n计算被删除的结点的数量，当n=amount-1时删除结束

while(iNodeNum++<amount) //---O(amount*stop)

{

int temp(1);//temp作为出列循环增计数至stop临时变量

//----

while(temp++<stop)

{

pCurr=pCurr->next;

pPrev=pPrev->next;

}

//temp=stop时删除当前p指向的结点

cout<<"删除结点:"<<pCurr->date<<" ";

pPrev->next=pCurr->next;

//释放被删除的结点！

free(pCurr);

pCurr=pPrev->next;

//-------

if (pPrev==pCurr)

{

cout<<endl<<"最后剩下"<<pCurr->date<<endl;

free(pCurr);

break;

}

//-------stop=1时输出删除结点顺序表

if ((stop==1)&&(iNodeNum==amount))

{

cout<<endl<<"最后剩下"<<pCurr->date<<endl;

free(pCurr);

break;

}

}

//

return NULL;

}

//***************************************测试函数************************************************//无空头结点

int main()

{

link L=NULL,ListRing(NULL); //L为一个结构体地址类型变量

int iLenofList(0);

int iInputValue(0),iNodeValue(0);

char cInput('n');

BOOL bTypeofLinkList=TRUE; //default:单链表

//---linklist operation

while (1)

{

PrintPolice();

//---task option "按2插入结点\n"<<

cout<<"1----建立链表\n"<<"2----插入结点\n"<<"3----删除结点\n"<<"4----查找结点\n"<<"5----排序结点\n"<<"6----逆序结点\n"

<<"7----Josephus\n"<<"8----清空链表\n"<<"0----退出操作 \n";

PrintPolice();

//---

cout<<"Input Option:";

cin>>iInputValue;

switch (iInputValue)

{

case 0:

if(L!=NULL)

DestroyLinklist(L,bTypeofLinkList) ;

exit(1); //exit(0):正常退出；exit(1)或者exit(-1):非正常退出；

break;

case 1:

//------

cout<<"请选择将要创建链表类型: ";

cout<<"1----单链表 2----单循环链表(Josephus Ring)"<<endl;

cout<<"Input Option:";

cin>>iInputValue;

switch (iInputValue)

{

case 1:

bTypeofLinkList=TRUE;

break;

case 2:

bTypeofLinkList=FALSE;

break;

default:break;

}

//------

cout<<"请选择链表创建方式: ";

cout<<"1----选择默认表 2----输入连续数据方式 3----连续输入单个结点数据方式(待增补)"<<endl;

cout<<"Input Option:";

cin>>iInputValue;

switch (iInputValue)

{

case 1:

cout<<"请输入默认链表长度：";

cin>>iInputValue;

while (iInputValue<=0||iInputValue>1000)

{

cout<<"输入数值超出范围，请重新输入:";

cin>>iInputValue;

}

iLenofList=iInputValue;

L=CreateDefaultList(bTypeofLinkList,iInputValue);

cout<<"选择的默认单循环链表为: \n";

DisplayList(L,bTypeofLinkList);

break;

case 2:

L=CreateList(bTypeofLinkList);

cout<<"输入连续数据生成的单循环链表为: \n";

DisplayList(L,bTypeofLinkList);

iLenofList=Length(L,bTypeofLinkList);

cout<<"该链表长度为："<<iLenofList<<endl;

break;

default:break;

}

break;

case 2:

if (L!=NULL)

{

cout<<"请输入结点插入位置:";

cin>>iInputValue;

while(iInputValue>iLenofList+1 || iInputValue<1) //1:插入链表头部；iLenofList+1：插入链表尾部

{

cout<<"位置错误，重新输入插入位置\n" ;

cin>>iInputValue;

}

//

cout<<"输入结点数据值:";

cin>>iNodeValue;

L=InsertNodeToList(L,iInputValue,iNodeValue,bTypeofLinkList,iLenofList) ;//在链表中某位置插入一个结点，单向链接插入。

iLenofList++;

cout<<"插入结点后数据生成的单链表为: \n";

DisplayList(L,bTypeofLinkList);

cout<<"现在链表长度为:"<<iLenofList<<endl;

}

else

{

cout<<"链表不存在,请先建链表\n";

}

break;

case 3:

if (L!=NULL)

{

cout<<"请输入删除结点位置:";

cin>>iInputValue;

while(iInputValue>iLenofList || iInputValue<1) //1:链表头部；iLenofList：链表尾部

{

cout<<"位置错误，重新输入删除结点位置\n" ;

cin>>iInputValue;

}

//

L=DeleteListNode(L,iInputValue,iNodeValue,iLenofList,bTypeofLinkList);

cout<<"你删除的是：";

cout<<iNodeValue<<endl ;

iLenofList--;

//

DisplayList(L,bTypeofLinkList);

cout<<"现在链表长度为:"<<iLenofList<<endl;

}

else

{

cout<<"链表不存在,请先建链表\n";

}

break;

case 4:

cout<<"输入要查找的值:";

int iInputValue;

cin>>iInputValue;

FindNode(L,iInputValue,bTypeofLinkList);

break;

case 5:

//---对链表排序

SortList(L,bTypeofLinkList);

cout<<"排序后的链表为:\n";

DisplayList(L,bTypeofLinkList);

break;

case 6:

//---交换法对链表逆序

L=Swap_Reverse(L,bTypeofLinkList);

cout<<"交换法逆序后的链表为:\n";

DisplayList(L,bTypeofLinkList);

//---直接法对链表逆序

L=Direct_Reverse(L,bTypeofLinkList); //*****此法更为简洁--复杂度也较低

cout<<"直接法逆序后的链表为:\n";

DisplayList(L,bTypeofLinkList);

break;

case 7:

if (bTypeofLinkList)

{

cout<<"Josephus Ring has not been built! Please build a ring!"<<endl;

break;

}

//新建一个带空头结点的约瑟夫环,以实现灵活设置起始点、终点的约瑟夫环踢出

ListRing=new LNode;

ListRing->next=L;

//ListRing=L; //无空头结点不灵活

//-----

cout<<"Please input JosephusRing Kickout startpoint and stoppoint!"<<endl;

cout<<"StartPoint:";

cin>>iInputValue;

cout<<"StopPoint:";

cin>>iNodeValue;

//JosephusRingKickOut(ListRing,iInputValue,iNodeValue); //无空头结点不灵活

L=JosephusKickout(ListRing,iInputValue,iLenofList,iNodeValue);

break;

case 8:

cout<<"你确实要清空链表吗？y/n:";

cin>>cInput;

cInput=(cInput=='y')?DestroyLinklist(L,bTypeofLinkList):('n');

//

if (cInput=='y')

{

cout<<"链表已被成功清除！"<<endl;

}

break;

default:break;

}

}

return 0;

}

//

内容也有很多欠缺之处，还请参阅者提出宝贵的意见和评论，方便我们共同交流学习。谢谢！