Auxiliary tutorial on data structure of piglet--2.2 single-linked list in linear table
tags (space delimited): Data structure
Learning Roadmap and Learning Essentials in this section
Learning Essentials :
- 1. Understand the order table and the single-linked list of their own little and shortcomings!
- 2. Familiar with the form of single-linked lists, for head pointers, head nodes, tail nodes, data fields and pointer fields these nouns need to know what is!
- 3. Familiar with single-linked list node structure
- 4. Distinguish the head pointer from the head node !
- 5. Familiar with the two ways to create a single-linked list: head-interpolation and tail-insertion method
- 6. Understanding the logic of the 12 basic operations of a single-link list
- 7. Interesting algorithmic questions: Find the middle node of a single linked list ~
1. Introduction of single-link list (sequential table and single-linked list PK)
2. A single-linked list of structural drawings and some nouns
3. Storage structure of single-linked table nodes
From the above structure we know that the node structure of the single-linked list is divided into data fields and pointer fields, the corresponding storage structure code is as follows:
typedefstruct LNode{ ElemType data; //数据域 struct LNode *next; //指针域 }LNode,*LinkList; //定义两个只是方便使用而已,Linklist是一个结点指针哦~
4. Comparison of head pointer and head node
2 We see the head pointer and head node, you may be a little puzzled about these two nouns, let us explain below ~
5. The comparison between the head interpolation method and the tail interpolation method to create the table
The difference between the two methods is simply the location of the insertion:
Head interpolation: The new insertion node is never the first node at the current point
Tail Interpolation: The new insertion node is always the last node at the current point
1) Head interpolation method to build a table
Implementation code:
//Head-insert method to build a linked listvoidHeadcreatelist (linklist l,int N) {linklist p; int i; Srand (Time (0));//Initialize random number seedL=(linklist) malloc (sizeof (Lnode)); L -Next= NULL;//Use loops to generate nodes and add them to a single linked list.for (i= 0; I<N;i++) {P=(linklist) malloc (sizeof (Lnode));//production of new nodesP -Data =RAND ()% - + 1;//Production two random number 100, three bits isP -Next=L -Next L -Next=P//Insert to table header} }
2) tail interpolation method to build a table
Implementation code:
voidTailcraetelist (linklist L,intN) {linklist p,r;intI Srand (Time (0));//Initialize random number seedL = (linklist)malloc(sizeof(Lnode)); R = L; for(i =0; i < n;i++) {p = (linklist)malloc(sizeof(Lnode));//production of new nodesP->data = rand ()% -+1;//Production two random number 100, three bits isR->next = p;//The pointer to the end of the footer node points to the new noder = P;//define the current new node as the tail node at the end of the table} r->next = NULL;//Current linked list ends}
6. Interesting algorithm: Find the middle node of a single linked list
is to give you a single-linked list, to get you a single-linked table in the middle of the node? What would you do?
In general, we may use a pointer to the beginning and end of the record, while recording the length of the single-linked list, and then divided by 2 to get the first few
The key is the middle node, then the LENGTH/2 to get the intermediate nodes, repeated traversal is cumbersome, there is no other way?
Yes, sure there is, here's an easy way to do it:
With two different pointers, move in different moving order, here we take them as a fast and slow pointer !
Each cycle,
* * The quick pointer moves backwards by two nodes: P = P-Next next;
The slow pointer moves backwards one node: q = q-next;**
When the quick pointer reaches the tail, the slow pointer does not point to the middle node, you say yes ~
The principle is very simple, below we write the code implementation:
Status Getmidlnode (linklist*L,elemtype*e) {linklist p,q; P=Q= *L while(p -Next -Next!= NULL) {if(p -Next -Next!= NULL) {P=P -Next -Next Q=Q -Next }Else{p=P -Next }} E=Q -Data;returnOK;}
7.12 Basic Operating code implementations
From the beginning of this section is not as a step by step to explain, directly on the code, the difficult part will write down comments!
1) Construct empty table
void InitList(LinkList L){ L = (LinkList)malloc(sizeof(LNode)); if(!L)exit(ERROR); L ->nextNULL;}
2) Set the linked list to an empty table
void ClearList(LinkList L){ =->next; ->=NULL; //接着就是释放头结点以外的结点了 while(p) { = L->next; free(L); //释放首元结点 = p; //移动到当前的首元结点
3) Determine if the table is empty
Here are two things to differentiate:
* * with head node: L--next = null; This table is empty table!
Headless node: L = null, empty table at this time! **
Status ListEmpty(LinkList L){ //有头节点的情况,只需判断头结点的指针域是否为空即可 if->next)returnFALSE; elsereturnTRUE; }
4) Destroy single linked list
void DestoryList(LinkList L){ LinkList q; //删除头结点外的结点 while(L) { //指向首元结点,而不是头结点 =->next; free(L); = q; //删除后指向首元
5) Get the table length
int ListLength(LinkList L){ int0; LinkList p = L ->next; while(p) { i++; p = p ->next; } return
6) Get the value of element I in the table
Status Getelem (linklist l,int I,elemtype*e) {int J= 1;//point to the first element, then move back, if the end or the value of J is greater than I //I haven't found a change element. I'm not legal .Linklist p=L -Next while(p&&J<i) {j++; P=P -Next }if(!P||J>IreturnERROR; E=P -Data;returnOK;}
7) Find the element that satisfies the criteria in the lookup table
int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType)){ int0; next; while(p) { i++; if(compare(p->data,e))return i; next; } return0;
8) obtain a direct precursor to a node.
Status BeforeElem(LinkList L,ElemType choose,ElemType *before){ LinkList q,p = L ->next; while(p ->next) { q = p ->next; //判断p的后继是否为choose,是的话返回OK,否则继续后移 if(q ->data == choose) { before = p ->data; return OK; } p = q; } return ERROR; }
9. Obtaining a direct successor to a node
*behind){ =->next; while->next) { if->data== choose) { =->->data; return OK; } =->next; } return ERROR; }
10. Insert an element into the table I position
Status Listinsert (linklist l,int i,elemtype e) {int J= 0; Linklist p,q=L//Ask Q to point to the head node while(p&&J<I- 1) {J++; P=P -Next//p refers to a node down}if(!P||J>I- 1)returnERROR; P=(linklist) malloc (sizeof (Lnode));//To have the pointer field of the inserted node point to the subsequent node of the insertion position first //Let the pointer field of the precursor of the insertion node point to the insertion junction //!!! The order can not be messy oh 1P -Data =E P -Next=Q -Next Q -Next=PreturnOK;}
11. Delete the first element of the table
Status Listdelete (linklist L,intI,elemtype*e){intj =0; Linklist p,Q= L; while(Q-Next&& J < i-1) {j + +;Q=Q-Next; }if(!Q | |J >i-1)returnERROR; p =Q-Next;//Point to the node you want to deleteQ-Next= P-Next;//The pointer field of the precursor that deletes the node points to the subsequent E = P->data; of the Delete node Free (p);//Release the node you want to deletereturnOK;}
12. Traverse all elements in a single linked list
void ListTraverser(LinkList L,void(*visit)(ElemType)){ =->next; while(p) { ->data); =->next; } printf("\n");}
8. This section of the code download:
Https://github.com/coder-pig/Data-structure-auxiliary-tutorial/blob/master/List/list2.c
Auxiliary tutorial on data structure of piglet--2.2 single-linked list in linear table