链表的操作

</pre><pre name="code" class="cpp">
#include <iostream>
using namespace std;


typedef int T;
class List
{
struct Node
{
T data;
Node* next;
Node(const T& n, Node* next=NULL): data(n),next(next){}
};
Node* head;//头指针，不是节点，但指向第一个节点
int len;//数据个数
public:
List():head(),len(){}


~List()
{
clear();
}


int size() const
{
return len;
}


void travel() const
{
Node* p = head;
while(p)
{
cout << p->data << ' ';
p = p->next;
}
cout << endl;
}


void clear()
{
Node* p = head;
Node* q;
while(p)
{
q = p->next;//记录下一个节点的地址
delete p;//释放当前这个节点
p = q;//p指向下一个节点
}
head = NULL;
len = 0;
}


/*
插入一个节点:在n号节点前插入一个节点的步骤
1)找到链表中指向n号节点的指针本身(head 或成员next)
如果n是0，就用head
否则就p=head之后循环n-1次p=p->next返回p->next，
2)让新节点的next成员指向n号节点
3)让找到那个指针指向新节点
*/


Node*& get_ptr(int n)//找到指向n号节点本身
{
if(n<0 || n>len)
n = len;//无效位置当成最后位置
if(n==0)//0号是由head指向的
return head;
Node* p = head;
for(int i=1; i<n; ++i)//其他的是由前一个节点的next指向的
p = p->next;
return p->next;//返回节点中的next成员
}


void insert(const T& d, int n)//在n号节点前插入
{
Node*& p = get_ptr(n);//取得n号节点的指针本身
Node* q = new Node(d, p);//新节点的next指向n号节点
p = q;
++len;
}
/*删除n号节点
1）找到链表中指向n号节点的指针本身
2）把指针保存一份
3）让找到的指针指向下一个节点
4）用保存的指针释放n号节点
*/
/*
删除等于指定值得节点
1）查找等于指定值的节点，取得指向它的指针本身
2）把指针保存一份
3）让找到的指针指向下一个节点
4）用保存的指针释放要删除的节点空间
*/
void erase(int n)//删除节点
{
Node*& p = get_ptr(n);
if(p)
{
Node* q = p;
p = p->next;
delete q;
--len;
}
}


void remove(const T& d)
{
Node*& p = find(d);
if(p)
{
Node* q = p;
p = p->next;
delete q;
--len;
}
}


Node*& find(const T& d)
{
if(len==0 || head->data==d)
return head;
Node* p = head;
while(p->next && p->next->data!=d)
p = p->next;
return p->next;
}


void update(const T& oldv, const T& newv)
{
Node* p = find(oldv);
if(p)
{
p->data = newv;
}
}


T& front()
{
return head->data;
}


T& back()
{
return get_ptr(n-1)->data;
}
};


void main()
{
List l;
l.insert(1,0);
l.insert(2,0);
l.insert(3,0);
l.insert(100,4);
l.insert(101,4);
l.insert(102,6);
l.travel();
l.erase(2);
l.travel();
l.remove(2);
l.travel();
l.update(100, 1024);
l.travel();
}