Pseudo code of linked list

1. A recursive algorithm is designed to delete all the nodes with the value of x in the single linked list L without the leading node

Writing thought;
	1)Establish recursive function and judge each round L->data Is it x，If yes, delete the node, and then L = L->next，Until the end of the linked list is traversed L->next = NULL

LNode *getElemByPos(LinkList L,int i) {
    int j = 1;
    LNode *P = L->next;
    if (i == 0) {
        return L;
    }
    if (i < 1) {
        return NULL;
    }
    while (P != NULL && j < i) {
        P = P->next;
        j++;
    }
    return P;
}

void delX(LinkList &L,ElemType x) {
    int i = 1;
    // No lead node
    if (L != NULL) {
        if (L->data == x) {
            LNode *P = getElemByPos(L,i-1);
            P->next = L->next;
        }
        i++;
        delX(L,x);
    } else {
        return ;
    }
}

Time complexity: O ( n ) O(n) O(n)
Space complexity: O ( n ) O(n) O(n)

Reference answer:

Written thought:
	1)Termination condition: table empty
	2)Divide into smaller problems: assume that the header pointer is L
	If the header element is X，Delete X，Sub table is L->next，Perform the same operation
	If the header element is not X，Sub table is L->next，Perform the same operation

void delX(LinkList &L,ElemType x) {
    // End of empty table
	if (L == NULL) {
        return ;
    }
    // Delete the node whose data field is equal to X
    if (L->data == x) {
        // Node where X is temporarily stored
        LNode *P = L;
        // L points to the next node of the node where X is located
        L = L->next;
        // Release the node where X is located
        free(P);
        // Recursive processing of sub tables
        delX(L,x);
    } else {
        // If the data field of the first node is not x, the sub table L - > next will be processed
        delX(L->next,x);
    }
}

2. In the single linked list L of the leading node, delete all nodes with the value of x and free up space. Assuming that the node with the value of x is not unique, try to write an algorithm to realize the above operation.

Written thought:
	The difference from the above question is that it has a head node and does not require recursion, so you can use a loop to replace tail recursion, and the idea remains the same

void delX(LinkList &L,ElemType x) {
    // Skip over node
    L = L->next;
    int i = 1;
    // As long as the node is not empty, the operation will continue
    while (L != NULL) {
        if (L->data == x) {
            // Store current node
            LNode *P = L;
            // Storage precursor node
            LNode *Q = getElemByPos(L,i-1);
            // Make the linked list continuous
            Q->next = P->next;
            L = L->next;
            free(P);
        }
        i++;
    }
}
LNode *getElemByPos(LinkList L,i) {
    if (i == 0) {
        return NULL;
    }
    if (i < 1) {
        return ;
    }
    int j = 1;
    while (L != NULL && j < i) {
        L = L->next;
        j++;
    }
    return L;
}

Time complexity: O ( n ) O(n) O(n)
Space complexity: O ( 1 ) O(1) O(1)

Reference answer:

Written thought:
	1)Will table L The head node of is disconnected from its subsequent part
	2)Traverse the post order part, and its value is not equal to x Execute tail insertion to the node of L After the head node of; For a value equal to x Node to perform the release operation

void delXByTailInsert(LinkList L,ElemType x) {
    LNode *subHead = L->next;			// Removed sub table header
    LNode *tailL = L;					// L indicates the footer of the table
    LNode *aux;							// Working pointer
    while (subHead != NULL) {
        // The tail is inserted into the tail of the table represented by L
        if (subHead->data != x) {
            // Insert footer and update footer pointer
            tailL->next = subHead;
            tailL = subHead;
            // Child table backward
            subHead = subHead->next;
            // Release current node of child table
        } else {
            // Temporary storage of current node
            aux = subHead;
            // Move sub table header backward
            subHead = subHead->next;
            // release
            free(aux);
        }
    }
    // The next of the tail node of the table represented by L is set to NULL
    tailL->next = NULL;
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

3. Let L be the single linked list of the leading node, and write an algorithm to output the value of each node from end to end

Written thought:
	1)To realize the reverse output from beginning to end, you can think of a single linked list"Head insertion"
	2)be careful L Is the single linked list of the leading node

bool LinkReverse(LinkList &L) {
    if (L == NULL) {
  		return false;
    }
    // Skip over node
   	LNode *subHead = L->next;
    L->next = NULL;
    while (subHead != NULL) {
        // aux stores the current node
        LNode *aux = subHead;
        // Child table node backward
        subHead = subHead->next;
        // Insert the current node into L
        aux->next = L->next;
        L->next = aux;
       	free(aux);
    }
    return true;
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

4. Write an efficient algorithm to delete a minimum node in the single linked list L of the leading node (assuming that the minimum node is unique)

Written thought:
	1)Traverse the entire single linked list, create a pointer variable, receive the current node and its predecessor nodes, and update the pointer to the current node if it is smaller than its value
	2)Throughout the loop, the pointer points to the minimum node

void delMinNode(LinkList &L) {
    // Storage header node
    LNode *subHead = L;
    L = L->next;
    ElemType min = L->data;
    // The precursor node that stores the minimum value node
    LNode *aux;
    // The loop does not exit until the table is empty
    while (subHead != NULL) {
        // If it is smaller than min, update the min value and record the precursor node
        if (min > subHead->next->data) {
            min = subHead->next->data;
            aux = subHead;
        }
        // Point to the next node
        subHead = subHead->next;
    }
    // The last aux points to the precursor node of the minimum node
    LNode *Z = aux->next;
    aux->next = Z->next;
    free(Z);
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

5. Try to write an algorithm to reverse the single linked list of the leading node in place. The so-called "in place" means that the complexity of the auxiliary space is O ( 1 ) O(1) O(1)

Written thought:
	1)It is required to store single linked list data in reverse order, and the header insertion method of single linked list can be considered

void LinkReverse(LinkList &L) {
    // Node behind storage header node
    LNode *subHead = L->next;
    // Exists as a header node
    L->next = NULL;
    LNode *aux;
    while (subHead != NULL) {
        // Store current node
        aux = subHead;
        subHead = subHead->next;
        L->next = aux;
    }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

6. There is a single linked list L with leading nodes. Design an algorithm to make its elements increase and order

Written thought:
	1)Use array storage L The values of the elements in the, and then sort them
	2)set up LNode *subHead = L,L->next = NULL，be L If the original header node is saved, the elements in the array can be inserted into the array in turn by using the header insertion method L After, insert all the ordered tables L The stored node element values are incrementally ordered

void LinkSort(LinkList L) {
    LNode *subHead = L;
    // Store the header node and insert the header of the ordered table
    L->next = NULL;
    // Calculate the number of nodes to facilitate the use of array storage
    int count = 0;
    while (subHead != NULL) {
        count += 1;
        L->next = subHead;
        subHead = subHead->next;
    }
    int *temp = (int *)malloc(sizeof(int) * count);
    memset(temp,0,sizeof(int)*count);
    subHead = L;
    L->next = NULL;
    int i;
    for (i = 0;i < count;i++) {
        temp[i] = subHead->data;
        subHead = subHead->next;
    }
    // Select and sort, and select the largest element in each round until the table is empty
    int j = 0,min;
    while (j < count) {
        min = temp[j];
        for (j = 0;j < count;j++) {
            if (min > temp[j]) {
                min = temp[j];
            }
        }
        // After inserting into L by head inserting method
        LNode *r;
        r->data = min;
        r->next = L->next;
        L->next = r;
    }
    L->next = NULL;
}

Time complexity: O ( n 2 ) O(n^2) O(n2) space complexity: O ( n ) O(n) O(n)

Reference answer:

Written thought:
	1)Waiting sequence L[1...n]At some point, the state is like this: ordered sequence L[1,...i-1],L[i]，Disordered sequence L[i+1...n]
	2)take L[i]Insert into ordered subsequence L[1...i-1]in

// Use the direct insertion sorting algorithm to sort
void insertSort(LinkList L) {
    LNode *curp = L->next,				// First element node
    	  *prep,
    	  // Used to identify the unordered part of the linked list
    	  // The first element node is considered to be ordered, and the disordered part starts from the second
    	  *subL = curp->next;			
    // At first, there is only one element in the ordered part, and the next of the last element should be NULL
    curp->next = NULL;
    // Start processing the unordered part from the second element node
    curp = subL;
    // When there are nodes in the disordered part
    while (curp != NULL) {
        // curp will be inserted into the ordered part, so save its subsequent [new unordered part] first
        subL = curp->next;
        // Prepare to find the first node larger than the curp element from front to back
        prep = L;
        while (prep->next != NULL && prep->next->data < curp->data) {
            // The last bit of the current element is still less than curp
            // Ordered partial backward
            prep = prep->next;
        }
        // When exiting, prep is followed by the insertion position of curp
        /*
        	1,curp Is the biggest
        	2,prep->next Is the first node greater than curp
        */
        // Typical insertion operation [active node to be inserted]
        curp->next = prep->next;
        prep->next = curp;
        // Handle the next node of the unordered part
        curp = subL;
    }
}

Time complexity: O ( n 2 ) O(n^2) O(n2) space complexity: O ( 1 ) O(1) O(1)

7. The data values of all element nodes in a single linked list with header nodes are out of order. Try to write a function to delete all elements (if any) between the given two values (given as function parameters) in the list

Written thought:
	1)Set the precursor node pointer and current node pointer. When traversing the appropriate node to meet the data value within the given range, delete the current node through the precursor node pointer and connect to the successor node of the current node

void delRange(LinkList L,int start,int end) {
    LNode *aux = L,*subHead = L->next;
    while (subHead != NULL) {
        if (subHead->data >= start && subHead->data <= end) {
            // Store current node
            LNode *P = subHead;
            aux->next = P->next;
            free(P);
        } else {
            // Point to the next node
        	aux = subHead;
        	subHead = subHead->next;
        }
    }
}

8. Given two linked lists, write an algorithm to find the common nodes of the two linked lists

Written thought:
	1)The public node is the address(Pointer)identical
	2)The problem is transformed into traversing the linked list A and B，Find the first node with the same address value

LNode *findFirstNode(LinkList A,LinkList B) {
    // Suppose they are linked lists of leading nodes
    LNode *subHead = A->next;
    A->next = NULL;
    // The nodes in A linked list are compared with those in B one by one
    while (subHead != NULL) {
        LNode *head = B->next;
        B->next = NULL;
        while (head != NULL) {
            // If two address values are found to be the same, exit the loop and all subsequent node address values are the same
            if (&subHead == &head) {
                return subHead;
            }
            // After the comparison is not satisfied, insert the current node into B to facilitate the cycle
            B->next = head;
        }
    }
}

Time complexity: O ( n 2 ) O(n^2) O(n2) space complexity: O ( 1 ) O(1) O(1)

9. Given a single linked list of leading nodes, set head as the head pointer, node structure as (data,next), data as the integer element and next as the pointer, and try to write the algorithm: output the data elements of each node in the single linked list in increasing order, and release the storage space occupied by the node (requirement: array is not allowed to be used as auxiliary space).

Written thought:
	Set precursor node pointer aux，Current working pointer subHead，L Storage header node, L->next = NULL，Using selection sorting, each round of traversal subHead Find the element with the smallest value and output it directly aux Delete the current node to free up space

void printSort(LinkList L) {
    while (True) {
        LNode *aux = L,
    		  *subHead = L->next;
    	L->next = NULL;
        int min = subHead->data;
        while (subHead != NULL) {
            if (min > subHead->data) {
                min = subHead->data;
            }
            aux = subHead;
            L->next = subHead;
            subHead = subHead->next;
        }
        // Find node delete
        cout << min << ", ";
        LNode *del = aux->next;
        aux->next = del->next;
        free(aux);
        // Traverse completely and exit the loop
        if (L->next == NULL) {
            break;
        }
    }
}

Time complexity: O ( n 2 ) O(n^2) O(n2) space complexity: O ( 1 ) O(1) O(1)

10. The single linked list A of A leading node is decomposed into the single linked lists A and B of two leading nodes, so that table A contains the elements with odd numbers in the original table, while table B contains the elements with even numbers in the original table, and its relative order remains unchanged.

Written thought:
	1)Set pointer variable subHead = L->next,and L->next = NULL be L As a single linked list with only head nodes A，Create a new single linked list B，order B->next = NULL
	2)from A,B Save the elements with odd and even numbers respectively, so you can set a count variable to insert the elements into the linked list respectively A and B Middle go
	3)Insert into A and B The relative order of the elements in is unchanged, so tail interpolation can be considered

void splitLink(LinkList L) {
    int count = 0;				// Count variable
    LNode *subHead = L->next;
    L->next = NULL;				// As A linked list with only head nodes, A
    LNode *B;
    B->next = NULL;				// Linked list B with only header nodes
    // Intermediate variable convenient for tail interpolation
    LNode *tail = L
          *band = B;
    while (subHead != NULL) {
        count += 1;
        // Insert tail into table A
        if (count % 2 == 1) {
            // Tail points to the subsequent node of L. after inserting the node to be inserted into r, it is tail insertion
            tail->next = subHead;
            tail = subHead;
        } else {
            band->next = subHead;
            band = subHead;
        }
        subHead = subHead->next;
    }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( n ) O(n) O(n)

11. Set C as { a 1 , b 1 , a 2 , b 2 , ... a n , b n } \{{a1,b1,a2,b2,...an,bn\}} {a1,b1,a2,b2,... an,bn} is a linear table, which is stored in the hc single linked table of the leading node. A local algorithm is designed to split it into two linear tables so that A = { a 1 , a 2 , ... a n } , B = { b n , ... b 2 , b 1 } A = \{{a1,a2,...an\}},B = \{{bn,...b2,b1\}} A={a1,a2,...an},B={bn,...b2,b1}.

Written thought:
	1)Observation linked list C knowable ai(1 ≤ i ≤ n)and bj(1 ≤ j ≤ n)Alternate, and A The sequences in the table are sorted normally, and B The sequence in the table is in reverse order
	2)So we know A The tail interpolation method is used in the table, B Header interpolation is used in the table
	3)ai stay C Is stored in odd digits, and bj stay C Is stored in even digits, so a new variable is created count To count

void splitLink(LinkList C) {
    int count = 0;
    LNode *A,*B,*subHead = C->next;
    // Create two single linked tables A and B with only head nodes
    A->next = NULL;
    B->next = NULL;
    LNode *tail = A,*head = B;
 	while (subHead != NULL) {
        count += 1;
        // Odd digit tail interpolation
        if (count % 2 == 1) {
            tail->next = subHead;
            tail = subHead;
        } else {
            // Even bit execution header interpolation
            subHead->next = head->next;
            head->next = subHead;
        }
        subHead = subHead->next;
    }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( n ) O(n) O(n)

12. In an incrementally ordered linear table, there are elements with the same value. If the storage method is a single linked list, the design algorithm removes the elements with the same value so that there are no duplicate elements in the table, such as ( 7 , 10 , 10 , 21 , 30 , 42 , 42 , 42 , 51 , 70 ) (7,10,10,21,30,42,42,42,51,70) (7,10,10,21,30,42,42,42,51,70) will become ( 7 , 10 , 21 , 30 , 42 , 51 , 70 ) (7,10,21,30,42,51,70) (7,10,21,30,42,51,70)

Written thought:
	1)Set precursor node pointer variable aux And current node pointer variables subHead，stay subHead If it is not empty, it will be traversed all the time subHead->data and aux->data Unequal rule aux=subHead,subHead = subHead->next
	2)Otherwise, delete the current node LNode *p = subHead;aux->next = subHead->next;free(p),aux and subHead unchanged

void delSameElem(LinkList L) {
    // Suppose L is a single linked list of leading nodes
    LNode *aux = L->next,
    	  *subHead = aux->next;
    while (subHead != NULL) {
        // If the value of the element behind the table is the same as that of the previous element, delete it
        if (subHead->data == aux->data) {
            LNode *P = subHead;
            aux->next = subHead->next;
            free(P);
        } else {
            aux = subHead;
            subHead = subHead->next;
        }
    }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

13. Suppose there are two linear tables arranged in the order of increasing element values, which are stored in the form of single linked list. Please write an algorithm to merge the two single linked lists into a single linked list arranged in descending order of element values, and use the nodes of the original two single linked lists to store the merged single linked list

Written thought:
	1)Create variable LNode *subHead = A->next,A->next = A
	1)Two single linked lists A and B They are stored in order by increasing the element value. The comparison starts from the first element. In case of a node with a small element value, the node will be placed in the node by header interpolation A After that, delete the original node and continue to merge and compare until a linked list is empty
	2)Insert the elements of the remaining linked list into the header in turn A After, after the whole operation is completed A It is a single linked list sorted by decreasing element values

void addReverse(LinkList A,LinkList B) {
    // Suppose that single linked lists A and B are the leading nodes
    LNode *auxA = A,
    	  *subHeadA = A->next;
    LNode *auxB = B,
    	  *subHeadB = B->next;
    // Store the tail pointers of A and B respectively
    LNode *tailA = A;
    A->next = NULL;
    // Only when the two single linked lists are not empty can it be carried out all the time
    while (subHeadA != NULL && subHeadB != NULL) {
        if (subHeadA->data < subHeadB->data) {
            LNode *P = subHeadA;
            tailA->next = subHeadA;
            auxA->next = subHeadA->next;
            free(P);
            tailA = subHeadA;
        } else {
            LNode *P = subHeadB;
            tailA->next = subHeadB;
            auxB->next = subHeadB->next;
            free(P);
            tailA = subHeadB;
        }
    }
    // Insert all the remaining single linked list elements after A
    while (subHeadA != NULL) {
        LNode *P = subHeadA;
        tailA->next = subHeadA;
        auxA->next = subHeadA->next;
        free(P);
        tailA = subHeadA;
    }
    while (subHeadB != NULL) {
        LNode *P = subHeadB;
        tailA->next = subHeadB;
        auxB->next = subHeadB->next;
        free(P);
        tailA = subHeadB;
    }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

14. Let A and B be two single linked lists (leading nodes), in which the elements are increasing in order. An algorithm is designed to generate single linked list C from the common elements of A and B, which is required not to destroy the nodes of A and B

Written thought:
	1)Set pointer subHeadA Point to single linked list A，New array temp，take A Store the element values of nodes in temp Until subHeadA End
	2)Set pointer subHeadB Point to single linked list B,stay subHeadB When it is not empty, the current is judged in each round subHeadB->data Is it temp The element already exists in. If it exists, insert the element into the single linked list by tail interpolation C In, subHeadB Point to the next node

# define SIZE 20
LinkList findSameElem(LinkList A,LinkList B) {
    // subHeadA skips the header node of A
    LNode *subHeadA = A->next;
    int *temp = (int *)malloc(sizeof(int) * SIZE);
    int i = 0;
    while (subHeadA != NULL) {
        temp[i++] = subHeadA->data;
        subHeadA = subHeadA->next;
    }
    // The value stored by i is actually the number of elements in single linked list A
    int j;
    // Traverse single linked list B
    LNode *subHeadB = B->next;
    // Create single linked list C
    LNode *C = (LNode *)malloc(sizeof(LNode));
    C->next = NULL;
    // Create tail pointer
    LNode *tail = C;
    while (subHeadB != NULL) {
        for (j = 0;j < i;j++) {
            if (subHeadB->data == temp[j]) {
                // Tail interpolation method
                tail->next = subHeadB;
                tail = subHeadB;
            }
        } 
        subHeadB = subHeadB->next;
    }
    return C;
}

Time complexity: O ( n 2 ) O(n^2) O(n2) space complexity: O ( n ) O(n) O(n)

Written thought:
	A,B Align left end of table
	1)Equal elements at the left end: apply for a node and insert the end of the element into the new table; A,B All move back one bit
	2)The elements at the left end are not equal: the elements with smaller values are moved one bit behind the linked list
	3)Repeat 1)2)，Until one of the tables is empty

// A. B linked list increment (header node)
// Form A new linked list of common elements in A and B (tail insertion method)
LinkList generateListWithSameNode(LinkList A,LinkList B) {
    LNode *subA = A->next,			// Table A sub table
    	  *subB = B->next;			// Table B sub table
    // Request header node for form C
    LinkList C = (LinkList)malloc(sizeof(LNode));
    LNode *tailC = C,				// Apply a pointer variable to the tail node for C
    	  *auxP;					// Auxiliary pointer variable
    // There are elements in both tables
    while (subA != NULL && subB != NULL) {
        // For the same element, perform tail interpolation to C
        if (subA->data == subB->data) {
            // Application node, assignment data field
            auxP = (LNode *)malloc(sizeof(LNode));
            auxP->data = subB->data;
            
            // Perform tail interpolation
            tailC->next = auxP;
            tailC = auxP;
            
            // Both tables are moved back one bit
            subB = subB->next;
            subA = subA->next;
            // The elements in table A are smaller. Because they are incremented, table A moves back one bit
        } else if (subA->data < subB->data) {
            subA = subA->next;
            // The elements in table B are smaller. Because they are incremented, table B moves back one bit
        } else {
            subB = subB->next;
        }
    }
    // Table C tail node processing
    tailC->next = NULL;
    return C;
}

Time complexity: O ( l e n 1 + l e n 2 ) O(len1 + len2) O(len1+len2) space complexity: O ( m i n ( l e n 1 , l e n 2 ) ) O(min(len1,len2)) O(min(len1,len2))

15. Two Integer Sequences A = a 1 , a 2 , ... a m , B = b 1 , b 2 ... b n A = a1,a2,...am,B = b1,b2...bn A=a1,a2,... am,B=b1,b2... bn have been stored in two single linked lists. An algorithm is designed to judge whether sequence B is a continuous subsequence of sequence a.

Written thought:
	1)Design a function to find the table length of a single linked table
	2)if A Table length lenA less than B Table length lenB，Return directly false
	3)if B yes A Continuous subsequences of, then B It must be A If a part of the list appears continuously, you can traverse the single linked list at the same time A Find the first and B When the first element is the same node, the two linked lists are compared bit by bit until B The table is empty. If there is an element with unequal values in the middle, it will be returned false，Exit the loop, otherwise the loop ends and returns true

// Calculate the table length of single linked list
int CalLength(LinkList L) {
    // Suppose there is a head node
    LNode *subHead = L->next;
    int count = 0;
    while (subHead != NULL) {
        count++;
    }
    return count;
}

bool justBisAPart(LinkList A,LinkList B) {
    // Find the table length of single linked tables A and B
    int lenA = CalLength(A),
    	lenB = CalLength(B);
    // If lenB is greater than lenA
    if (lenA < lenB) {
        return false;
    } else {
        	bool tag = false;
            // Suppose tables A and B are the leading nodes
            LNode *subHeadA = A->next;
            LNode *subHeadB = B->next;
            // Traverse table A until you find an element with the same value as the first node element in B
            int i;
        	// If B is A continuous subsequence of A, you only need to traverse lenb Lena
            for (i = 0;i < lenB - lenA;i++) {
				if (subHeadA->data == subHeadB->data) {
                    // Only when both child tables are not empty
                    while (subHeadA != NULL || subHeadB != NULL) {
                        subHeadA = subHeadA->next;
                        subHeadB = subHeadB->next;
                    }
                }
                // After the matching is successful, the continuous subsequence will be found until the table is empty
                if (subHeadA == NULL || subHeadB == NULL) {
                    tag = true;
                }
            }
        	return tag;
        }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

16. A single linked list with header node is known, and the node structure is ( d a t a , l i n k ) (data,link) (data,link), assuming that the linked list only gives the header pointer l i s t list list. Without changing the linked list, please design an algorithm as efficient as possible to find the penultimate in the linked list k k Nodes at k locations ( k by just whole number ) (k is a positive integer) (k is a positive integer). If the search is successful, the algorithm outputs the value of the node d a t a data The value of the data field and returns 1. Otherwise, only 0 is returned

Written thought:
	1)Write a function CalLength To calculate the table length of a single linked list len
	2)if len than k Small, 0 is returned
	3)set variable i Traverse from 0 to len-k，Output the of the last node data Value and returns 1

int CalLength(LinkList L) {
    int count = 0;
    LNode *subHead = L->link;
    while (subHead != NULL) {
        count++;
    }
    return count;
}

int LinkFind(LinkList L,int k) {
    int len = CalLength(L);
    if (len < k) {
        return 0;
    } else {
        int i = 0;
        LNode *subHead = L->link;
        while (i <= len - k) {
            subHead = subHead->link;
        }
        cout << subHead->data << endl;
        return 1;
    }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

17. Given a single linked list without head nodes, it is required that the space complexity is O ( 1 ) O(1) O(1). The following example is a ring with a ring: 5 − > ... 11 − > 5 5->...11->5 5−>...11−>5

Written thought:
	Traverse the nodes of the single linked list step by step, re traverse all nodes before the new node from the first node, and compare the address value of the new node with the address value before this node. If it is found to be the same, it indicates that there are links in the linked list, otherwise continue until the list is empty

void justIsCircle(LinkList L) {
    LNode *curP = L->next;
    while (curP != NULL) {
        // Each cycle starts with the first element
        LNode *head = L;
        // Separate linked list into rings
        if (&curP == &head) {
            cout << "Linked list with links" << endl;
            break;
        } else {
            while (head->next != curP) {
                if (&curP == &head) {
                    cout << "Linked list with links" << endl;
                    break;
                }
                head = head->next;
            }
            // The same ID was not found after traversal
            curP = curP->next;
        }
    }
}

Time complexity: O ( n 2 ) O(n^2) O(n2) space complexity: O ( 1 ) O(1) O(1)

18. Save with single linked list m m m integers, and the node structure is ( d a t a , n e x t ) (data,next) (data,next), and ∣ d a t a ∣ < n ( n by just whole number ) |Data | < n (n is a positive integer) ∣ data ∣ < n (n is a positive integer). Now we need to design an algorithm with time complexity as efficient as possible. For nodes with equal absolute values in the linked list, only the first node is retained and the other nodes with equal absolute values are deleted.

Written thought:
	1)You can create arrays temp，receive m Absolute value of an integer
	2)i Start from 0 to traverse the single linked list, and traverse each node temp Array, found temp The subscript of the first node in the array that is the same as the absolute value of the current node, if i And subscripts are not equal, indicating that this is a node to be deleted. The precursor node is used to delete it, and temp The corresponding element value in the array is n，Until the end of the table is traversed
	3)The remaining single linked list stores element nodes with different absolute values

void delAbValue(LinkList L,int n,int m) {
    // Create a temp array to hold the data
    int *temp = (int *)malloc(sizeof(int) * m);
    int i;
    // Skip over node
    LNode *subHead = L->next;
    for (i = 0;i < m;i++) {
        temp[i] = abs(subHead->data);
        subHead = subHead->next;
    }
    // Precursor node pointing to node
    LNode *aux = L;
    LNode *subHead = L->next;
    while (subHead != NULL) {
        // To count
    	int j = 0;
        for (i = 0;i <= j;i++) {
            // If the element values are equal
            if (abs(subHead->data) == temp[i]) {
                // If the subscripts are the same, don't worry
                if (i != j) {
                    // Delete the node and change the temp[i] value
                    LNode *P = subHead;
                    aux->next = subHead->next;
                    temp[i] = n;
                    free(P);
                } 
            }
            aux = subHead;
            subHead = subHead->next;
        }
    }
}

Time complexity: O ( n 2 ) O(n^2) O(n2) space complexity: O ( n ) O(n) O(n)

19. With a pointer L L L's acyclic two-way linked list with header nodes, except p r e d ( front drive finger needle ) PRED (precursor pointer) PRED (precursor pointer) d a t a ( number according to ) Data Data and n e x t ( after Follow finger needle ) Next (subsequent pointer) Besides the next domain, there is also an access frequency domain f r e q freq freq. Before the linked list is used, its values are initialized to zero. Once in the linked list L o c a t e ( L , x ) Locate(L,x) In the Locate(L,x) operation, the element value is x x In the node of x f r e q freq The value of the freq field is increased by 1, and the nodes in the linked list are arranged in the order of non increasing (decreasing) access frequency. At the same time, the most recently accessed nodes are ranked last among the nodes with the same frequency, so that the frequently accessed nodes are always close to the header. Try to write a document that meets the above requirements L o c a t e ( L , x ) Locate(L,x) The algorithm of Locate(L,x) operation, which is a function process and returns the address of the found node. The type is pointer type.

Written thought:
	1)Create an array temp Backup access frequency domain freq
	2)Write function Locate(L,x)To locate the lookup element x In the double linked list, make it freq Additive temp The element value in the array is also incremented by 1
	3)Traverse the double linked list from the beginning and find the first one freq The node smaller than yourself is inserted in front of it

// Returns the subscript of the matched x
LNode *Locate(LinkList L,int x) {
    LNode *subHead = L->next;
    int i;
    // Flag variable to judge whether there is element x in the double linked list
    bool tag = false;
    while (subHead != NULL) {
        if (subHead->data == x) {
            // Exit this cycle when found
            tag = true;
            break;
        } else {
            // When there is no match, the pointer moves backward and the count increases by 1
            i++;
            subHead = subHead->next;
        }
    }
    subHead = L->next;
    if (!tag) {
        // Traversing the entire double linked list did not find x, and the entire double linked list did not move
        return NULL;
    } else {
        // Traverse to node i, save the node, delete the corresponding position, and connect the front and back nodes
        int j = 0;
        while (j < i) {
            subHead = subHead->next;
        }
        // Now is the node at i
        LNode *curP = subHead;
        // Connect its predecessor and successor
        curP->next = curP->pred->next;
        curP->next->pred = curP->pred;
        // Traverse from the beginning, find the first node smaller than yourself and insert it in front of it
        subHead = L->next;
        P->freq += 1;
        while (subHead != NULL) {
            if (subHead->freq > P->freq) {
                subHead = subHead->next;
            } else {
                // Insert P before the node and keep the continuity between nodes
                subHead->pred->next = P;
                subHead->next = P->next;
            }
        }
        return P;
    }
}

Time complexity: O ( n ) O(n) O(n) space complexity: O ( 1 ) O(1) O(1)

20. Suppose that the single linked list of the leading node is used to save words. When two words have the same suffix, they can share the same suffix storage space. For example, the storage impression of "loading" and "being" is shown in the figure below.

Let str1 and str2 respectively point to the head node of the single linked list where the two words are located. The linked list structure is ∣ d a t a ∣ n e x t ∣ |data|next| ∣ data ∣ next ∣, please design an algorithm as efficient as possible in time to find out the reason s t r 1 and s t r 2 str1 and str2 The starting position of the common suffix of the two linked lists pointed to by str1 and str2 (as shown in the figure) i i Location of node i p p p). requirement:

• The basic design idea of the algorithm is given
• According to the design idea, the C or C + + or J a v a C or C + + or Java Describe the algorithm in C or C + + or Java language, and give comments on the key points
• Explain the time complexity of your algorithm

Written thought:
	1)Write a function to find the length of a single linked list CalLength，Linked lists are the leading nodes
	2)Separate use CalLength Find the linked list A and B Table length lenA and lenB
	3)For a single linked list with a long table length, you might as well set B Yes, then B The pointer moves backward lenB - lenA position
	4)Then point to A and B The pointer of the node is compared step by step. If it is not equal, it will move backward by 1 bit until it is found that the addresses of the two nodes are the same, it will return to the node and exit the loop
	5)If a table is empty and no node with the same address is found, the NULL

// Calculate single linked list length function
int CalLength(LinkList L) {
    LNode *subHead = L->next;
    int count = 0;
    while (subHead != NULL) {
        count++;
        subHead = subHead->next;
    }
    return count;
}

LNode *findFirstNode(LinkList A,LinkList B) {
    // Calculate the lengths of tables A and B respectively
    int lenA = CalLength(A);
    int lenB = CalLength(B);
    // Two pointers to A and B header nodes
    LNode *str1 = A,
          *str2 = B;
    LNode *subHeadB = B->next;
    LNode *subHeadA = A->next;
    int i = 0;
    // B move back
    if (lenA < lenB) {
        while (i < lenB - lenA) {
            subHeadB = subHeadB->next;
            i++;
        }
    } else {
        while (i < lenA - lenB) {
            subHeadA = subHeadA->next;
        }
    }
    // Both pointers move at the same time
    bool tag = false;
    while (subHeadA != NULL && subHeadB != NULL) {
        if (&subHeadA == &subHeadB) {
            LNode *curP = subHeadA;
            tag = true;
        } else {
            subHeadA = subHeadA->next;
            subHeadB = subHeadB->next;
        }
    }
    if (tag) {
        return true;
    } else {
        return NULL;
    }
}

Time complexity: O ( l e n A + l e n B ) O(lenA + lenB) O(lenA+lenB) space complexity: O ( 1 ) O(1) O(1)

21. Set linearity table L = ( a 1 , a 2 , a 3 , ... , a n − 2 , a n − 1 , a n ) L=(a1,a2,a3,...,an-2,an-1,an) L=(a1,a2,a3,..., an − 2,an − 1,an) is saved in the single linked list of the leading node. The nodes in the linked list are defined as follows:

typedef struct node {
    int data;
    struct node* next;
}NODE;

Please design a space with a complexity of O ( 1 ) O(1) O(1) and as time efficient as possible, rearrange L L L, get the linear table L = ( a 1 , a n , a 2 , a n − 1 , a 3 , a n − 2 , ... ) L=(a1,an,a2,an-1,a3,an-2,...) L=(a1,an,a2,an−1,a3,an−2,…). requirement:

• The basic design idea of the algorithm is given
• According to the design idea, the C or C + + C or C++ C or C + + language describes the algorithm, and notes are given at the key points
• Explain the time complexity of the algorithm you designed

Written thought:
	1)Write a table length function CalLength
	2)take L Divided into two sub tables A and B，If the table length is even, then A Before containing len/2 Elements, B After containing len/2 Elements, otherwise A Before containing len/2+1 Elements, B After containing len/2 Elements
	3)yes A The table will not be operated B Table reversal
	4)establish C Table, will A,B Table elements are sequentially inserted into C In the table, then C The table is the table to be found

int CalLength(LinkList L) {
    int count = 0;
    LNode *subHead = L->next;
    while (subHead != NULL) {
        // Count and move the pointer back
        count++;
        subHead = subHead->next;
    }
    return count;
}

// Arrange to generate a new table
void remakeList(LinkList L) {
	LNode *C,*A,*B;
    C->next = NULL;
    A->next = NULL;
    B->next = NULL;
    int len = CalLength(L);
    LNode *subHead = L->next;
    // Counted
    int i = 0;
    LNode *tailA = A,*tailB = B;
    while (subHead != NULL) {
        // Tail interpolation
        if (i < len/2) {
            tailA->next = subHead;
            tailA = subHead;
            subHead = subHead->next;
            i++;
        }
        // Judge whether len is odd or even
        if (len % 2 == 1) {
            tailA->next = subHead;
            tailA = subHead;
            subHead = subHead->next;
            i++;
        }
        if (i > len/2 && i < len) {
            tailB->next = subHead;
            tailB = subHead;
            subHead = subHead->next;
        }
    }
    // After dividing tables A and B, perform header interpolation on table B to realize reversal
    LNode *curP->next = B;
    while (curP != NULL) {
        curP->next = C->next;
        C->next = curP;
        curP = curP->next;
    }
    // Now C stores the reverse linked list of B
    LNode *B = C->next
    C->next = NULL;
    LNode *tail = C;
    while (B != NULL || A != NULL) {
        // Execute tail interpolation
        tail->next = A->next;
        tail = A;
        tail->next = B->next;
        tail = B;
    }
}

Time complexity: O ( n ) O(n) O(n)