输入一个单向链表，输出该链表中倒数第K个结点

http://blog.csdn.net/itcastcpp/article/details/39274891

//尹成 单链表操作
#include <iostream>
using namespace std;
class LinkList;

struct LinkNode
{
public:
LinkNode(int value =0):m_value(value),pNext(NULL){}
~LinkNode(){pNext = NULL;}

friend class LinkList;
int m_value;
LinkNode* pNext;
};

//带头结点的链表
class LinkList
{
public:
LinkList();
~LinkList();
void Insert(int data);
void Delete(int data);
void Sort();
bool IsEmpty();
void Reverse();
void Destroy();
int Length();
LinkNode* Find(int data);
bool IsLoop();
void Print();
LinkNode* FindIndex(int index);//使用下标
LinkNode* FindLastNum(int n);//使用两个指针
private:
LinkNode* pHead;
};

LinkList::LinkList()
{
pHead = new LinkNode();
}

LinkList::~LinkList()
{
Destroy();
}

//从大到小插入
void LinkList::Insert(int data)
{
if(NULL == pHead)
{
cout<<"料表未创建"<<endl;
return;
}
LinkNode* pCur = pHead;

//移动到待插入节点的前一个节点
while(pCur->pNext != NULL)
{
if(pCur->pNext->m_value < data)
break;
pCur = pCur->pNext;
}

LinkNode* pTmp = new LinkNode(data);
pTmp->pNext = pCur->pNext;
pCur->pNext = pTmp;
}

void LinkList::Delete(int data)
{
if(NULL == pHead)
{
cout<<"链表未创建"<<endl;
return;
}

if(NULL == pHead->pNext)
{
cout<<"链表为空"<<endl;
return;
}

LinkNode* pCur = pHead;
while(pCur->pNext)
{
//指向要删除节点的前一个节点
if(pCur->pNext->m_value == data)
{
LinkNode* pDel = pCur->pNext;
pCur->pNext = pCur->pNext->pNext;
pDel = NULL;
delete pDel;
}
else
pCur = pCur->pNext;
}
}

//从小到大排序
void LinkList::Sort()
{
if(pHead == NULL)
{
cout<<"链表未创建"<<endl;
return;
}

if(pHead->pNext == NULL)
{
cout<<"链表为空"<<endl;
return;
}

LinkNode* pCur = pHead;

LinkNode* pNewHead = new LinkNode();
while(pCur)
{
LinkNode * pTmp = pCur;
pCur = pCur->pNext;

LinkNode* p = pNewHead;
//将pTmp插入到新的链表中 插入时候按照从小到大顺序
while(p->pNext)
{
if(p->pNext->m_value > pTmp->m_value)
{
break;
}
p = p->pNext;
}

if(pTmp != pHead)
{
pTmp->pNext = p->pNext;
p->pNext = pTmp;
}
//delete pHead;//释放掉原来的内存  这里不注释掉 导致二次释放指针？
pHead = pNewHead;
}
}
bool LinkList::IsEmpty()
{
if(NULL == pHead)
{
cout<<"链表未创建"<<endl;
return false;
}

return pHead->pNext == NULL;
}

int LinkList::Length()
{
if(NULL == pHead)
{
cout<<"链表未创建"<<endl;
return 0;
}

int nLength = 0;
LinkNode* pCur = pHead->pNext;

while(pCur)
{
nLength++;
pCur=pCur->pNext;
}

return nLength;
}

void LinkList::Reverse()
{
if(NULL == pHead)
{
cout<<"链表未创建"<<endl;
return;
}

if(pHead->pNext == NULL)
{
cout<<"链表为空"<<endl;
return;
}
else
{
LinkNode* pCur = pHead->pNext->pNext;
LinkNode* pPre = pHead->pNext;
LinkNode* pnext = NULL;

while(pCur)
{
pnext = pCur->pNext;
pCur->pNext = pPre;
pPre = pCur;
pCur = pnext;
}
pHead->pNext->pNext =NULL;
pHead->pNext = pPre;

}

}

void LinkList::Destroy()
{
if(pHead == NULL)
{
cout<<"链表未创建"<<endl;
return;
}

while(pHead->pNext)
{
LinkNode* pDel = pHead->pNext;
pHead->pNext = pDel->pNext;
delete pDel;
pDel = NULL;
}

delete pHead;
pHead = NULL;
}

LinkNode* LinkList::Find(int data)
{
if(NULL == pHead)
{
cout<<"链表未创建"<<endl;
return NULL;
}

if(NULL == pHead->pNext)
{
cout<<"链表为空"<<endl;
return NULL;
}

LinkNode* pCur = pHead->pNext;
while(pCur)
{
if(pCur->m_value == data)
return pCur;
pCur= pCur->pNext;
}

return NULL;
}

void LinkList::Print()
{

if(NULL == pHead)
{
cout<<"链表未创建"<<endl;
return;
}

if(NULL == pHead->pNext)
{
cout<<"链表为空"<<endl;
return;
}
else
{
LinkNode* pCur = pHead->pNext;
while(pCur)
{
cout<<pCur->m_value<<" ";
pCur = pCur->pNext;
}
cout<<endl;
}
}

bool LinkList::IsLoop()
{

if(NULL == pHead)
{
cout<<"链表未创建"<<endl;
return false;
}

if(NULL == pHead->pNext)
{
cout<<"链表为空"<<endl;
return false;
}

LinkNode* pFast = pHead->pNext;
LinkNode* pLow = pHead->pNext;

//pFast->pNext != NULL 这个条件是很关键的
while(pFast != NULL &&
pLow != NULL && pFast->pNext !=NULL)
{
pFast = pFast->pNext->pNext;
pLow = pLow->pNext;
if(pFast == pLow)
return true;
}

return false;
}

//返回倒数第n个节点
LinkNode* LinkList::FindIndex(int n)
{
if(n <= 0 || n > Length())
return NULL;

LinkNode* pCur = pHead->pNext;

for(int i = 1;i < n;i++)
{
pCur = pCur->pNext;
}

return pCur;
}

//这一种方法利用了中间间隔
LinkNode* LinkList::FindLastNum(int n)
{
if(pHead == NULL || pHead->pNext == NULL||n < 0)
return NULL;
LinkNode* pCur = pHead->pNext;
LinkNode* pFirst = pHead->pNext;

while(n > 0)
{
pFirst = pFirst->pNext;
if(NULL == pFirst)
return NULL;

n--;
}

while(pFirst->pNext)
{
pFirst = pFirst->pNext;
pCur = pCur->pNext;
}

return pCur;
}

int main()
{
LinkList list;
list.Insert(12);
list.Insert(14);
list.Insert(2);
list.Insert(122);
list.Insert(5);
list.Insert(4);
list.Insert(7);
list.Print();
int k;
cout << "请输入要查询倒数第几个结点(计数从0开始):";
cin >> k;
LinkNode *p = list.FindIndex(list.Length() - k);
if (p)
{
cout << p->m_value << endl;
}
LinkNode *p2 = list.FindLastNum(k);
if (p2)
{
cout << p2->m_value << endl;
}

cout<<"链表进行排序之后的结果:"<<endl;
list.Sort();
list.Print();
return 0;
}