求解，成员函数的实现

[leighjian]

#include <iostream>
using namespace std;
typedef struct tag_NODE
{
	int nData;
	tag_NODE *pNext;
	tag_NODE *pPre;
}NODE,*LPNODE;
class LIST
{
public:
	LIST(){m_lpHead=NULL;}
	LIST(const LIST &lst);
	~LIST();
	void FindAndDel(int nData);
private:
	LPNODE m_lpHead;
};

编码实现LIST类得三个成员函数：
1.LIST(const LIST &lst)
2.~LIST()
3.void FindAndDel(int nData)

恳求帮实现下~~！！！！

[Michael_Xie]

你这人还真懒

[seujh]

在楼主的基础上进行了修改了一下， 但是是实现了你的功能。。。。。

建议不要用struct ,都用class

是个头文件，包含这个头文件，然后 加一句：" #define MyDoubleList" ，是为了防止重复包含头文件。。。

不影响你看代码的。


//一个双向链表，基本没有什么功能，写这个没什么含量，但是要注意指针的问题。


#ifdef MyDoubleList


#include<assert.h> //调用assert函数

class Node
{
private:
int nData;
Node *pNext; //前驱
Node *pPre; //后继

public:
Node() //默认构造函数
{
nData=0;
pNext=pPre=NULL;
}

Node(int nData) //构造函数
{
this->nData=nData;
pNext=pPre=NULL;
}

~Node(){ }

void Print()
{
std::cout<<nData<<" ";
}

int GetData()
{
return nData;
}

Node* GetNext()
{
return pNext;
}

void SetNext(Node* p)
{
pNext=p;
}

Node* GetPre()
{
return pPre;
}

void SetPre(Node* p)
{
pPre=p;
}

};

class List
{

private:
Node* m_lpHead;


public:
List(); //默认构造函数，构造一个头节点,头结点是不用来干活的，链表构造成功后，最少有一个节点

~List(); //在析构函数中释放链表


//接口函数
void AddNode(int nData); //添加节点

void FindAndDel(int nData); //节点值和nData相同，那么久删除节点


void Print(); // 打印本链表



};


List::List()
{
m_lpHead=new Node();

if(m_lpHead==NULL)
{
std::cout<<"构造头节点内存分配失败"<<std::endl;

return;
}

}

//在链表基础上添加节点，头节点和第一个节点之间插入
void List::AddNode(int nData)
{
Node* temp=new Node(nData);

if(temp==NULL)
{
std::cout<<"添加节点时候，内存分配失败"<<std::endl;

return;
}

Node* p=m_lpHead->GetNext(); //获得第一个节点的指针(非头节点）

temp->SetNext(p); //temp的后继指向第一个节点

if(p!=NULL) p->SetPre(temp); //插第一个节点的时候,p为NULL;否则，则把第一个节点的前驱指针指向temp节点


temp->SetPre(m_lpHead); //前驱指针指向头节点

m_lpHead->SetNext(temp); //头节点的后继指针指向tmp节点


}


void List::Print()
{
Node* p=m_lpHead->GetNext(); //指向第一个节点，非头结点

while(p)
{
p->Print();
p=p->GetNext();
}
}


List::~List()
{
if(m_lpHead=NULL) return; //链表没有构造成功




Node* p1,*p2; //前驱，后继

p1=m_lpHead->GetNext(); //从第一个节点开始释放

while(p1)
{


p2=p1->GetNext(); //p2是p1的后继

delete p1; //释放

p1=p2;
}

//最后释放头节点

delete m_lpHead;

m_lpHead=NULL;

}




void List::FindAndDel(int nData)
{

Node*p=m_lpHead->GetNext(); //获取第一个节点的指针

Node*temp=NULL;

while(p)
{
if(nData==p->GetData()) //删除
{

temp=p;

p=p->GetNext(); //p向后移

if(p) //所删除的节点后面还有个节点，即：不是尾节点
{


( temp->GetNext() )->SetPre(temp->GetPre() ); //后节点的前驱指针指向前节点

( temp->GetPre() )->SetNext( temp->GetNext() ); //前节点的后继指针指向后节点

delete temp; //释放该节点

}
else //尾节点 ，要特别注意，上面的代码不适合
{

( temp->GetPre() )->SetNext(NULL); //把前驱节点的的后继指针设置为NULL，即可

delete temp; //释放该节点即可

}
}

else

p=p->GetNext();


}




}


#endif