First, the linear structure:
array:
(1) a contiguous memory space can not be turned off
(2) as a continuous memory space can be accessed using the index
arr [i] === * (arr + i)
Access efficiency is very high
(3) in front of the insertion and deletion of data of relatively low efficiency (need to move data)
List:
(1) memory is not continuous
(2) access efficiency is relatively low because of the need to start traversing from the first element
(3) relatively high efficiency in any place insertions and deletions (just change the value of the pointer)
Second, singly linked list
Way linked list node: node element of the next node address +
. 1 typedef int T; 2 // node-way linked list . 3 typedef struct SNODE { . 4 T Data; // node element . 5 struct SNODE * Next; // address of the next node to the next node . 6 } SNODE; . 7 . 8 / / defined way linked list type slink . 9 typedef struct SNODE * slink;
1. Initialization list
Address (NULL) dynamic memory request header node of the head node does not save the data to the next node
1 void init(SLink* plink){ 2 *plink = malloc(sizeof(SNode)); 3 (*plink)->next = NULL; 4 } 5 SLink createSLink(){ 6 SNode * node = malloc(sizeof(SNode)); 7 node->next = NULL; 8 return node; 9 }
2. Determine if the list is empty
1 bool isEmpty(SLink link){ 2 return link->next == NULL; 3 }
3. Insert a node to be stored in the header data added
1 void insertFront(SLink link,T data){ 2 SNode *node = malloc(sizeof(SNode)); 3 node->data = data; 4 node->next = link->next; 5 link->next = node; 6 }
4. traverse the list
1 void travel(SLink link){ 2 if(link != NULL){ 3 SNode *node = link->next; 4 while(node != NULL){ 5 printf("%d ",node->data); 6 node = node->next; 7 } 8 printf("\n"); 9 } 10 }
The number list data
1 size_t size(SLink link){ 2 SNode *node = link->next; 3 size_t cnt = 0; 4 while(node != NULL){ 5 cnt++; 6 node = node->next; 7 } 8 return cnt; 9 }
6. The index obtained before a node position of the node index
1 static SNode *getPrevNode(SLink link,size_t index){ 2 SNode *node = link; 3 for(int i=0;i<index;i++){ 4 node = node->next; 5 } 6 return node; 7 }
7. insert an element at the specified location index
. 1 void INSERT (slink Link, size_t index, T Data) { 2 IF (index> size (Link)) { . 3 return ; . 4 } . 5 // former node finds a subscript index nodes . 6 SNODE prevNode * = getPrevNode (Link , index); . 7 SNODE * = currNode the malloc ( the sizeof (SNODE)); . 8 currNode-> Data = Data; . 9 currNode-> Next = prevNode-> Next; 10 prevNode-> Next = currNode; . 11 }
The subscript element 8. Delete
1 void deleteByIndex(SLink link,size_t index){ 2 if(index>=size(link)){ 3 return; 4 } 5 SNode *prevNode = getPrevNode(link,index); 6 SNode *currNode = prevNode->next; 7 prevNode->next = prevNode->next->next; 8 free(currNode);//释放内存 9 }
9. Empty the list, in
. 1 void Clear (slink Link) { 2 SNODE * = Link- Node> Next; . 3 the while (Node =! NULL) { . 4 SNODE Next * = node-> Next; // record the position of a node of the current node . 5 Free ( node); // release the memory of the current node . 6 node = next; // to point to the next node . 7 } . 8 Link-> next = NULL; . 9 }
10. Destruction list
1 void destroy(SLink *plink){ 2 clear(*plink); 3 free(*plink); 4 *plink = NULL; 5 }
11. Delete the first list of the node data is data
1 void deleteData(SLink link,T data){ 2 SNode *prevNode = link; 3 SNode *currNode = link->next; 4 while(currNode != NULL){ 5 if(currNode->data == data){ 6 prevNode->next = currNode->next; 7 free(currNode); 8 return; 9 } 10 prevNode = currNode; 11 currNode = currNode->next; 12 } 13 }
12. Remove all of the data is data linked list node
1 void deleteAllDatas(SLink link,T data){ 2 SNode *prevNode = link;//头节点 3 SNode *currNode = link->next; 4 while(currNode != NULL){ 5 if(currNode->data == data){ 6 prevNode->next = currNode->next; 7 free(currNode); 8 currNode = prevNode->next; 9 continue; 10 } 11 prevNode = currNode; 12 currNode = currNode->next; 13 } 14 }
13. The elements of the list modifying subscript
1 void modify(SLink link,size_t index,T data){ 2 if(index>=size(link)){ 3 return; 4 } 5 SNode *node = getPrevNode(link,index+1); 6 node->data = data; 7 }
Get element 14. The subscript
If the index> = size (link) will lead to error
1 T getDataByIndex(SLink link,size_t index){ 2 /* 3 if(index>=size(link)){ 4 return -1; 5 } 6 */ 7 SNode *node = link->next; 8 for(int i=0;i<index;i++){ 9 node = node->next; 10 } 11 return node->data; 12 }
15. The list in reverse order --- pen questions probability maximum programming problem
. 1 void Reverse (slink Link) { 2 // IF (Link == NULL) {return;} . 3 // no or only a node when the node does not need to do anything . 4 IF (Link-> Link Next == NULL || -> next-> Next == NULL) { . 5 return ; . 6 } . 7 SNODE prevNode * = Link-> Next; // first node preceding node . 8 SNODE currNode * = prevNode-> Next; // second node . 9 the while (! currNode = NULL) { 10 SNODE * = nextNode currNode-> Next; // recorded after a node of the current node . 11 currNode-> Next = prevNode; //Of former node before the next point to the current node 12 is prevNode = currNode; // front nodal point now becomes the current node 13 is currNode = nextNode; // the current node pointing to a node 14 } 15 Link-> next-> next = NULL; // make next original first node to the NULL 16 Link-> next = prevNode; // that the head node of that next the last point to the original node 17 }
Third, the doubly linked list
. 1 typedef int T; 2 . 3 typedef struct DNode { . 4 T Data; . 5 struct DNode * PREV; . 6 struct DNode * Next; . 7 } DNode; . 8 . 9 typedef struct the DLink { 10 // end to end node data is not stored . 11 DNode * head; // points to the head node 12 is DNode * tail; // point to the end node 13 is } the DLink;
1. Initialization list
Dynamic memory allocation head node and tail node
Prev doubly linked list node points to NULL head tail node point next prev tail node point next head node points to NULL
1 void init(DLink *dlink){ 2 dlink->head = malloc(sizeof(DNode)); 3 dlink->tail = malloc(sizeof(DNode)); 4 dlink->head->prev = NULL; 5 dlink->head->next = dlink->tail; 6 dlink->tail->prev = dlink->head; 7 dlink->tail->next = NULL; 8 }
2. Clear the list of all nodes
1 void clear(DLink *dlink){ 2 DNode *node = dlink->head->next; 3 while(node != dlink->tail){ 4 DNode *next = node->next; 5 free(node); 6 node = next; 7 } 8 dlink->head->next = dlink->tail; 9 dlink->tail->prev = dlink->head; 10 }
3. Destruction list
1 oid destroy(DLink *dlink){ 2 clear(dlink); 3 free(dlink->head); 4 dlink->head = NULL; 5 free(dlink->tail); 6 dlink->tail = NULL; 7 }
4. Does the list is empty
1 bool isEmpty(DLink dlink){ 2 return dlink.head->next == dlink.tail && dlink.head == dlink.tail->prev; 3 }
5. The number of list elements
1 size_t size(DLink dlink){ 2 DNode *node = dlink.head->next; 3 size_t cnt = 0; 4 while(node != dlink.tail){ 5 cnt++; 6 node = node->next; 7 } 8 return cnt; 9 }
6. Insert an element from the head
We need to create a new node, apply for a new dynamic memory
Prev head node or pointing to NULL, next point to the new node
tail node or next point NULL, prev points to the new node
of the new node point next tail node, pointing to the head node prev
1 void insertFront(DLink dlink,T data){ 2 DNode *node = malloc(sizeof(DNode)); 3 node->data = data; 4 node->next = dlink.head->next; 5 node->prev = dlink.head; 6 dlink.head->next->prev = node; 7 dlink.head->next = node; 8 }
7. Access to a node
1 static DNode * getPrevNode(DLink dlink,size_t index){ 2 DNode *node = dlink.head; 3 for(int i=0;i<index;i++){ 4 node = node->next; 5 } 6 return node; 7 }
8. The insert an element index
1 void insert(DLink dlink,size_t index,T data){ 2 if(index > size(dlink)){ 3 return; 4 } 5 DNode *prevNode = getPrevNode(dlink,index); 6 DNode *node = malloc(sizeof(DNode)); 7 node->data = data; 8 node->next = prevNode->next; 9 node->prev = prevNode; 10 prevNode->next->prev = node; 11 prevNode->next = node; 12 13 }
9. The index delete an element
1 void deleteByIndex(DLink dlink,size_t index){ 2 if(index >= size(dlink)){ 3 return; 4 } 5 DNode *currNode = getPrevNode(dlink,index+1); 6 currNode->next->prev = currNode->prev; 7 currNode->prev->next = currNode->next; 8 free(currNode); 9 }
10 starts from the head traverse the list
1 void travelFront(DLink dlink){ 2 DNode *node = dlink.head->next; 3 while(node != dlink.tail){ 4 printf("%d ",node->data); 5 node = node->next; 6 } 7 printf("\n"); 8 }
11. traverse the list from the beginning of the tail
1 void travelBack(DLink dlink){ 2 DNode *node = dlink.tail->prev; 3 while(node != dlink.head){ 4 printf("%d ",node->data); 5 node = node->prev; 6 } 7 printf("\n"); 8 }