3.1 Single Linked list

1. Introduction to Single-link listarrays are useful in programming languages, but there are at least two drawbacks to an array (1) You need to know the size of the array when compiling(2) is stored continuously in computer memory, which means inserting or deleting one data in an array, and adjusting other data. There are no such problems with the use of linked list structuresrepresents the structure of a linked list and its construction process. each node in the linked list shown is An instance of the following class definition (the node value is an integer type) : This is a C + + object-oriented approach, in C, we are accustomed to define the structure of the body.

2. classIntSLLNode{
4. public:
6. IntSLLNode(){//第一个构造函数初始化next指针为NULL
8. next =0;
10. }
12. IntSLLNode(int i,IntSLLNode*in =0){//第二个构造函数设置两个成员数据的值
14. info = i; next = in;
16. }
18. int info;
20. IntSLLNode*next;//指向下一个节点，这个节点的类型与本节点相同,这里要定义成公有成员，以便实施链表的操作
22. };

The node consists of two members: info and Next, the info member is used for user-useful storage, and next is used to connect the linked list nodes to form the linked list structure. With this definition we can construct the linked list as shown:Intsllnode *p = new Intsllnode (ten);p->next = new Intsllnode (8);p->next->next = new Intsllnode (a);This only defines a head pointer p to access the data, not very convenient, in the actual operation will generally define two pointers or more pointers for easy operation.
2. Single-link list operationThe list node type has been defined by the class Intsllnode, the next is to define a class implementation of the list of various errors, single-linked list operation is nothing more than adding and deletingDefine the following class Intsllist

2. classIntSLList{
4. public:
6. IntSLList(){
8. head = tail =0;
10. }
12. ~IntSLList();
14. int isEmpty(){
16. return head ==0;
18. }
20. void addToHead(int);
22. void addToTail(int);
24. int deleteFromHead();// delete the head and return its info;
26. int deleteFromTail();// delete the tail and return its info;
28. void deleteNode(int);
30. bool isInList(int)const;
32. void printAll()const;
34. private:
36. IntSLLNode*head,*tail;//两个私有成员变量，分别是指向单链表的头和尾的指针
38. };
40. 
    

2.1 Insert (1) Add to the list at the beginning of the four steps:

• Create an empty node
• Initialize node value El
• Add a new node to the top of the list and point the new node's next to the head node, which is the current value of the head
• Update head to a pointer to a new node

1. voidIntSLList::addToHead(int el){
2. head =newIntSLLNode(el,head);//一句话就完成了四步，这就是C++的魅力了
3. if(tail ==0)
4. tail = head;
5. }

(2) Add to the end of the list four steps:

• Create an empty node
• Initialize the node value El because the node is to be added to the end of the list so that next of the new node is set to null
• Next to the tail node of the original list, point to the new tail node, so that the new node is added to the end
• Update tail to a pointer to a new node

1. voidIntSLList::addToTail(int el){
2. if(tail !=0){// 先判断链表是否为空
3. tail->next =newIntSLLNode(el);
4. tail = tail->next;
5. }
6. else head = tail =newIntSLLNode(el);
7. }

2.2 Delete (1) Delete the head node and return its value in order to be rigorous in the program, two special cases need to be considered:

• One is to attempt to remove a node from an empty list.
• The second is the case of a linked list with only one node.

2. intIntSLList::deleteFromHead(){
4. if(!isEmpty())//检查链表链表是否为空
6. {
8. int el = head->info;
10. IntSLLNode*tmp = head;
12. if(head == tail)//加入链表只有一个节点;
14. head = tail =0;
16. else head = head->next;
18. delete tmp;
20. return el;
22. }
24. else 
26. //std::cout<<"The List is Empty!"
28. return 0 ;
30. }

Note:The above program actually has a problem, the program began to use the IF statement to check whether the list is empty, if it is empty will do else operation returns 0, and for the statement that calls this method does not know whether the return 0 is the head node itself is the value of 0, or because the list is empty and return 0. The best solution is to determine whether the linked list is empty before calling this method. (2) Delete the tail node and return its value the delete operation is implemented by the member function Deletefromtail. After removing the tail node, the tail should point to the new end node of the list, that is, the tail must move a node in the opposite direction, but cannot move in the opposite direction because there is no direct link from the last node to its predecessor node. It is therefore necessary to find the precursor node from the shipowner head of the list and stop just before tail. This task is done by iterating through the list with a temp variable in the For loop.

4. intIntSLList::deleteFromTail(){
6. int el = tail->info;
8. if(head == tail){// if only one node on the list;
10. delete head;
12. head = tail =0;
14. }
16. else{// if more than one node in the list,
18. IntSLLNode*tmp;// find the predecessor of tail;
20. for(tmp = head; tmp->next != tail; tmp = tmp->next);
22. delete tail;
24. tail = tmp;// the predecessor of tail becomes tail;
26. tail->next =0;
28. }
30. return el;
32. }

(3) Delete the two deletions that are discussed earlier in the node with the value El are the deletion of a node from the beginning or the end. If you want to delete a node that contains a specific integer, and you do not care about the node's position in the linked list, you need to use a different method. This node may be at the beginning or end of the list, or anywhere in the list. Simply put, you must first locate the node and then connect its predecessor node to the successor node to remove it from the list. Because you do not know where the node is, the operation is much more complex.
This node can be removed from the linked list by connecting the precursor and the successor, but because the list is onlybackward links, so it is not possible to get their precursors from a node. One way to do this repentance is to scan the list first to findDelete the node and then scan the list again to find its precursor, and another method as shown, with the help of two pointer variables pred and TMP. The preceding figure discusses only one scenario, with the following:

• An attempt was made to delete a node from an empty list, at which point the function exits immediately.
• Remove unique nodes from a single-node list: Both head and tail are set to NULL
• Removes the first node from a list of at least two nodes, which needs to update the head
• Removes the last node from a list of at least two nodes, which needs to be updated tail
• There is no node in the list that contains a number: No action is made.

2. voidIntSLList::deleteNode(int el){
4. if(head !=0)  if Non-empty list;
6. {
8. if(head == tail && el == head->info){// if only one
10. delete head;// node on the list;
12. head = tail =0;
14. }
16. elseif(el == head->info){// if more than one node on the list
18. IntSLLNode*tmp = head;
20. head = head->next;
22. delete tmp;// and old head is deleted;
24. }
26. else{// if more than one node in the list
28. IntSLLNode*pred,*tmp;
30. for(pred = head, tmp = head->next;// and a non-head node
32. tmp !=0&&!(tmp->info == el);// is deleted;
34. pred = pred->next, tmp = tmp->next)
36. if(tmp !=0){
38. pred->next = tmp->next;
40. if(tmp == tail)
42. tail = pred;
44. delete tmp;
46. }
48. }
50. }
52. }

2.3 The Find insert and delete operations have modified the linked list. The lookup operation scans the existing list to determine if it contains a number, in this case with the Boolean member function isinlist ()implement this operation.

1. boolIntSLList::isInList(int el)const{
2. IntSLLNode*tmp;
3. for(tmp = head; tmp !=0&&!(tmp->info == el); tmp = tmp->next);
4. return tmp !=0;
5. }

Complete code: http://www.oschina.net/code/snippet_588162_48571

From for notes (Wiz)

3.1 Single-linked list