9 seconds College C + + template class implementation single-linked list

first on the code

/******************************** definition of linear table abstract class ***************************/

Template <class datatype>

Class list{

Public

virtual void empty () = 0; Empty the linear table

virtual int getlength () = 0; to find the length of a table

virtual void Insert (int i,const datatype& x) = 0; Inserting an element with a value of x in the table I position

virtual void Remove (int i) = 0; Remove elements from the I position in a table

virtual int Search (const datatype& x) = 0; finds and returns the position of the element with the value x in the table

Virtual DataType Visit (int i) = 0; accessing The value of element I in a table

virtual void traverse () = 0; traversing a linear table

};

/******************************* definition of a single-linked list class ********************************/

Template <class datatype>

Class linklist:publiclist<datatype>{// public inherits from list class

Public

Linklist (); constructors, generating empty lists when creating objects

void empty (); Empty List

int GetLength (); to find the length of a table

void Insert (int i,const datatype& x); Inserting an element with a value of x in the table I position

void Remove (int i); Remove elements from the I position in a table

int search (const datatype& x); finds and returns the position of the element with the value x in the table

DataType visit (int i); accessing The value of element I in a table

void Traverse (); to output elements from a table individually

~linklist (); Destructors

Private

Defining Nodes

struct node{

DataType data;

Node* Next;

Node (): Next (NULL) {};

Node (dataType d):d Ata (d), next (NULL) {};

};

node* Head; Linked list Header

node* tail; Chain Footer

int currentlength; Linked list length

};

implementation of/********************************* single-link list class ******************************/

Template <class datatype>

Linklist<datatype>::linklist () {

Head=new node;

Tail=new node;

head->next=tail;

currentlength=0;

cout<< "\ncreate list success!\n";

}

Template <class datatype>

void Linklist<datatype>::empty () {

node* nowpos=head->next;

while (Nowpos!=tail) {

node* Tmp=nowpos;

nowpos=nowpos->next;

Delete tmp;

}

head->next=tail;

currentlength=0;

cout<< "\nempty list success!\n";

}

Template <class datatype>

int Linklist<datatype>::getlength () {

return currentlength;

}

Template <class datatype>

void Linklist<datatype>::insert (Inti,const datatype& x) {

if (i<0| | I>currentlength) {

cout<< "\nthe index is out of range!\n";

Return

}

node* add=new node (x);

if (i==0) {

add->next=head->next;

head->next=add;

}

else{

Find The first i-1 node

node* nowpos=head->next;

while (-i) {

nowpos=nowpos->next;

}

add->next=nowpos->next;

nowpos->next=add;

}

++currentlength;

cout<< "\ninsert data success!\n";

}

Template <class datatype>

void Linklist<datatype>::remove (Inti) {

if (i<0| | I>=currentlength) {

cout<< "\nthe index is out of range!\n";

Return

}

if (i==0) {

node* tmp=head->next->next;

Delete head->next;

head->next=tmp;

}

else{

Find The first i-1 node

node* nowpos=head->next;

while (-i) {

nowpos=nowpos->next;

}

node* tmp=nowpos->next->next;

Delete nowpos->next;

nowpos->next=tmp;

}

--currentlength;

cout<< "\ndelete data success!\n";

}

Template <class datatype>

int Linklist<datatype>::search (constdatatype& x) {

node* Nowpos=head;

int i;

for (I=0;i<currentlength;++i) {

nowpos=nowpos->next;

if (nowpos->data==x) break;

}

if (i==currentlength) return-1;

return i;

}

Template <class datatype>

datatypelinklist<datatype>::visit (int i) {

Subscript out- of-bounds throws an exception value 0

if (i<0| | I>=currentlength) {

Throw 0;

}

Find the i node

node* nowpos=head->next;

while (i--) {

nowpos=nowpos->next;

}

Return nowpos->data;

}

Template <class datatype>

void Linklist<datatype>::traverse () {

if (currentlength==0) {

cout<< "\nthe list is empty!\n";

Return

}

node* nowpos=head->next;

cout<<nowpos->data;

nowpos=nowpos->next;

while (Nowpos!=tail) {

cout<< "" <<nowPos->data;

nowpos=nowpos->next;

}

cout<<endl;

}

Template <class datatype>

Linklist<datatype>::~linklist () {

Empty ();

Delete head;

Delete tail;

}

Note

1, this code is drawn from the Linear table project package, the contents of the project package are as follows:
Definition of linear table abstract class List.h

SeqList.h , definition of sequential table class

implementation of Sequential table class SeqList.txt

LinkList.h the definition of a single linked list class

implementation of single-linked list class LinkList.txt

definition of double-linked list class dLinkList.h

implementation of double-linked list class DLinkList.txt

definition of test class Test.h

implementation of test class Test.txt

2, we can use these code as a reference, want to improve the ability or to write their own;

3, all the classes are template class, if you want to the template class definition and implementation of separation to note that the implementation of the template class can not be placed in the. cpp file, can only be placed in a . txt file;

6. The knowledge involved is divided into three major areas:

(1) The realization principle of single-linked list;

(2) design and encapsulation of class;

(3) Design abstract class list and let the single-linked list inherit from list, is for the order table, double linked list, with (pure) virtual function to achieve polymorphism. If you use only a single-linked list, you can design a class to solve it, or you can use the above code directly.

more questions can be reached in 9 seconds of college .

9 seconds College C + + template class implementation single-linked list