C++ 单链表的建立，插入数值，删除数值，排序，遍历，和分割操作

#include<iostream>
#include<stack>
#include<fstream>
#include<istream>
#include<list>

using namespace std;

typedef struct node
{
	int value;
	struct node *pNext;
} node, *pnode;

class myList
{
private:
	pnode pFirst;
	pnode pLast;
public:
	myList()
	{
		this ->pFirst = NULL;
	}

	~myList()
	{
		if ( this -> pFirst != NULL )
		{
			pnode pTemp = pFirst -> pNext;
			delete pFirst;
			pFirst = pTemp;
		}
	}
	void initialList();
	void addValue( int value );
	int deleteValue( int k );
	int insertValue( int value, int k );
	int findNumber( int value );
	void travel();
	int getNodeNumber();
	void sort();
	int split( int k );
};

void myList::initialList() //初始化单链表
{
int a;
char answer;
pnode pTail, pNew;
do
{
cout << "please input one node:";
cin >> a;
if ( pFirst == NULL )
{
pFirst = new node;
pFirst -> value = a;
pFirst -> pNext = NULL;
pTail = pFirst;
}
else
{
pTail = pFirst;
while ( pTail -> pNext != NULL )
{
pTail = pTail -> pNext;
}

pNew = new node;
pNew -> value = a;
pNew -> pNext = NULL;

pTail -> pNext = pNew;
pTail = pTail -> pNext;
}
cout << "need continue?:";
cin >> answer;
} while ( answer == 'y' || answer == 'Y' );
}

void myList::addValue( int value ) //增加数值到链表上
{
if( pFirst == NULL )
{
pFirst = new node;
pFirst -> value = value;
pFirst -> pNext = NULL;
}
else
{
pnode pTemp = pFirst;
while ( pTemp -> pNext != NULL )
{
pTemp = pTemp -> pNext;
}
pnode pNew = new node;
pNew -> value = value;
pNew -> pNext = NULL;

pTemp -> pNext = pNew;
}
}

int myList::getNodeNumber() //计算链表上有多少个数字
{
int number = 0;
pnode pTemp = pFirst;

while ( pTemp != NULL )
{
number++;
pTemp = pTemp -> pNext;
}

return number;
}
int myList::deleteValue( int k ) //删除链表上第K个数字
{
pnode p1,p2,pTemp;
if( pFirst == NULL )
return -1;
if( k < 0 || k > this->getNodeNumber() - 1 )
return -1;
if ( k == 0 )
{
pTemp = pFirst;
pFirst = pTemp -> pNext;
delete pTemp;
return 0;
}

if( k == this -> getNodeNumber() - 1 )
{
pnode p,pTemp;
p = pFirst;
while ( p->pNext->pNext != NULL )
{
p = p -> pNext;
}

pTemp = p -> pNext;
p -> pNext = NULL;
delete pTemp;
return 0;
}

p1 = pFirst;
int i = 0;
while ( i < k - 1 )
{
p1 = p1 -> pNext;
i++;
}

pTemp = p1 -> pNext;
p2 = p1->pNext->pNext;
p1 -> pNext = p2;
delete pTemp;
return 0;
}

int myList::insertValue( int value, int k ) //增加链表上第k个数字
{
pnode p1,p2,pNew,pTemp;
if( pFirst == NULL )
return -1;
if( k < 0 || k > this -> getNodeNumber() - 1 )
return -1;
if( k == 0 )
{
pTemp = pFirst;
pNew = new node;
pNew -> value = value;
pNew -> pNext = NULL;

pFirst = pNew;

pNew -> pNext = pTemp;
return 0;
}

p1 = pFirst;
int i = 0;
while ( i < k - 1 )
{
p1 = p1 -> pNext;
i++;
}

p2 = p1 -> pNext;
pNew = new node;
pNew -> value = value;
pNew -> pNext = NULL;

p1 -> pNext = pNew;
pNew -> pNext = p2;

return 0;
}

int myList::findNumber( int value ) //查找链表上是否存在想要的数字
{
int i = 0;
pnode pTemp = pFirst;
while ( pTemp != NULL )
{
if( pTemp -> value == value )
return i;
pTemp = pTemp -> pNext;
i++;
}
return -1;
}

void myList::travel() // 链表的遍历
{
pnode pTemp = this -> pFirst;
while ( pTemp != NULL )
{
cout << pTemp -> value << " ";
pTemp = pTemp -> pNext;
}
cout << endl;
}

void myList::sort()
{
int n = this -> getNodeNumber();
pnode p1,p2;

for ( int i = 0; i < n - 1; i++ )
{
p1 = pFirst;
for (int j = 0; j < n - 1; j++ )
{
p2 = p1 -> pNext;
if ( p1 -> value < p2 ->value )
{
int k = p1 -> value;
p1 -> value = p2 -> value;
p2 -> value = k;
}
p1 = p1 -> pNext;
}
}
}

int myList::split( int k ) //把一个链表分割成两个链表
{
pnode p1,p2,pSplit;
if ( k < 1 || k > this -> getNodeNumber() - 1 )
{
return -1;
}
pSplit = pFirst;
p1 = new node;
p1 -> value = NULL;
p1 -> pNext = NULL;
p2 = new node;
p2 -> value = NULL;
p2 -> pNext = NULL;
int i = 0;
for (int i = 0; i < k; i++)
{
p1 -> value = pSplit -> value;
cout << p1 -> value << " ";
pSplit = pSplit -> pNext;
p1 -> pNext = pSplit;
}
cout << endl;
for( i = k; i < getNodeNumber(); i++ )
{
p2 -> value = pSplit -> value;
cout << p2 -> value << " ";
pSplit = pSplit -> pNext;
p2 -> pNext = pSplit;
}
return 0;
}

int main()
{
myList list;
for (int i = 0; i < 20; i++)
{
list.addValue(i);
}

list.getNodeNumber();
list.insertValue( 48, 7 );
list.travel();
list.deleteValue( 5 );
list.travel();
list.sort();
list.travel();
list.split( 19 );
}