# Prefix tree, linked list related topics

## trie

- Prefix tree is also named dictionary tree, word lookup tree, Trie tree, multi-channel tree structure, and hash efficiency. It is a multi-tree structure for fast retrieval. It is mostly used for word frequency search or fuzzy query.
- The query is only related to the sample length, not the sample size.
- 1) In a single string, characters from front to back are added to - Multi fork tree

2) Characters are placed on the road, and there are exclusive data items on the node (commonly pass and end values)

3) All samples are added in this way. If there is no road, create a new one, and if there is a road, reuse it

4) The pass value of the node along the way increases by 1, and the end value of the node at the end of each string increases by 1

You can complete prefix related queries

/pic:mw://20f0c6edb22084fc2a039334fc5f7972

pass is the number of passes, and end is the number of times that the current element ends

The cost of building this tree is O (N)

public class Code_01_TrieTree { public static class TrieNode { public int path; public int end; public TrieNode[] nexts; public TrieNode() { path = 0; //How many nodes have arrived end = 0; //How many strings end with this node nexts = new TrieNode[26]; //The path to the child node. If the scope given by the topic is uncertain, use map } } public static class Trie { private TrieNode root; public Trie() { //Prepare a header node root = new TrieNode(); } //Insert a word public void insert(String word) { if (word == null) { return; } char[] chs = word.toCharArray(); TrieNode node = root; int index = 0; for (int i = 0; i < chs.length; i++) { index = chs[i] - 'a'; if (node.nexts[index] == null) { node.nexts[index] = new TrieNode(); } node = node.nexts[index]; node.path++; } node.end++; } //Delete the word from the structure public void delete(String word) { if (search(word) != 0) { char[] chs = word.toCharArray(); TrieNode node = root; int index = 0; for (int i = 0; i < chs.length; i++) { index = chs[i] - 'a'; if (--node.nexts[index].path == 0) { //If a node after - 1 = = 0, it means that the node after this node is also after - 1 = = 0, so directly = null. node.nexts[index] = null; return; } node = node.nexts[index]; } node.end--; } } //Find a word and insert it several times public int search(String word) { if (word == null) { return 0; } char[] chs = word.toCharArray(); TrieNode node = root; int index = 0; for (int i = 0; i < chs.length; i++) { index = chs[i] - 'a'; if (node.nexts[index] == null) { return 0; } node = node.nexts[index]; } return node.end; } //Check the number of prefixes in a string public int prefixNumber(String pre) { if (pre == null) { return 0; } char[] chs = pre.toCharArray(); TrieNode node = root; int index = 0; for (int i = 0; i < chs.length; i++) { index = chs[i] - 'a'; if (node.nexts[index] == null) { return 0; } node = node.nexts[index]; } return node.path; } } public static void main(String[] args) { Trie trie = new Trie(); System.out.println(trie.search("zuo")); trie.insert("zuo"); System.out.println(trie.search("zuo")); trie.delete("zuo"); System.out.println(trie.search("zuo")); trie.insert("zuo"); trie.insert("zuo"); trie.delete("zuo"); System.out.println(trie.search("zuo")); trie.delete("zuo"); System.out.println(trie.search("zuo")); trie.insert("zuoa"); trie.insert("zuoac"); trie.insert("zuoab"); trie.insert("zuoad"); trie.delete("zuoa"); System.out.println(trie.search("zuoa")); System.out.println(trie.prefixNumber("zuo")); } }

## Linked list

Written examination can not care about space complexity, all for time complexity

In the interview, time complexity is the most important, but save space

:: speed pointer:

1) Enter the chain header node. The odd length returns the midpoint, and the even length returns the upper midpoint

2) Enter the chain header node. The odd length returns the midpoint, and the even length returns the lower midpoint

3) Enter the chain header node. The odd length returns the previous midpoint, and the even length returns the previous midpoint

4) Enter the chain header node. The odd length returns the one before the midpoint, and the even length returns the one before the next midpoint

#### 1) Enter the chain header node. The odd length returns the midpoint, and the even length returns the upper midpoint

public static Node mid0rUpMidNode(Node head) { if (head = nu11|| head.next == nu11|| head.next.next = nu1l) { return head; } // Node slow = head. next; Node fast = head. next. next; while (fast.next != nu1l && fast.next.next != nu1l) { slow = slow. next; fast = fast .next .next; } return slow; } if (head == null|| head.next == nu1l) { return true; } Node n1 =lhead; Node n2 = head; while (n2.next != nu1l && n2.next.next != nu1l) { // find mid node n1 = n1.next; // n1 ->mid n2 = n2. next.next; 1/ n2 -> end } return n1

#### 2) Enter the chain header node. The odd length returns the midpoint, and the even length returns the lower midpoint

public static Node mid0rDownMidNode (Node head) { if (head == nul1|| head.next = nu1l) { return head; } Node slow = head . next; Node fast = head . next; while (fast.next != nu1l && fast.next.next != nu1l) { slow = slow.next; fast = fast.next .next; } return slow; }

#### 3) Enter the chain header node. The odd length returns the previous midpoint, and the even length returns the previous midpoint

public static Node mid0rUpMidPreNode(Node head) { if (head = nu11|| head.next == nu11|| head.next.next == nu1l) { return nu1l; } Node slow = head; Node fast = head. next. next; while (fast.next != nu1l && fast.next.next != nu11) { slow = slow.next; fast = fast .next .next; } return slow; }

#### 4) Enter the chain header node. The odd length returns the one before the midpoint, and the even length returns the one before the next midpoint

public static Node mi d0rUpMidPreNode(Node head) { if (head = nu11|| head.next == nu11|| head.next.next == nu1l) { return nu1l; } Node slow = head; Node fast = head . next. next; while (fast.next != nu1l && fast.next.next != nu1l) { slow = slow.next; fast = fast .next .next; } return slow; }

### :: given the head node of a single linked list, please judge whether the linked list is palindrome structure.::

1) The hash table method is particularly simple (pen trial)

2) The method of changing the original linked list needs to pay attention to the boundary (for interview)

Using the stack, first traverse the stack, then traverse it, and compare it with the elements at the top of the stack

Use less space?

The speed pointer finds the midpoint and the upper midpoint

Press the second half of the stack and compare it with the first half again

Constant space?

First, the speed pointer locates the midpoint and the end, and the next pointer of the midpoint points to null

Reverse the pointers in the second half, and then compare the beginning and end in turn. When one pointer points to null, it is a palindrome structure

If one of them is different, it is a non palindrome

Note that before returning the result, you need to return the second half in reverse order

### :: divide the unidirectional linked list into the form of small on the left, equal in the middle and large on the right according to a certain value:

1) Put the linked list into the array and do partition on the array

2) Divided into small, medium and large parts, and then string them together (for interview)

public static Node listPartition2(Node head, int pivot) { Node sH = nu1l; // small head Node sT = nu1l; // small tail Node eH = nu1l; // equal head Node eT = nu1l; // equal tail Node mH = nu11; // big head ! Node mT = nu1l; // big tail Node next = nu1l; // save next node // every node distributed to three lists while (head != nu1l) { next = head.next; head.next = nu1l; if (head.value < pivot) { if (sH == null) { sH = head; sT = head; } else{ sT .next = head; sT = head; }else if (head.value == pivot) { if (eH == nu11) { eH = head; eT = head; } else { eT.next = head; eT = head; } } head= next; } /Xinba in xiaori area, even equal to<The head of the domain, wait for the regional huabalian people to open<Header of domain if (sT != null) { //If there is a small field sT .next = eH; eT= eT==null?sT:eT;//Whoever connects the head larger than the area becomes eT } // The if above, whether it's gone or not, et // all reconnect if (eT != null) { //If it is less than the domain and equal gate < gauge, there is not none eT .next = mH; } returnsH!=null?sH:(eH!=nu1l?eH:mH); }

#### Copy linked list with special pointer

-A special single linked list node class is described below

class Node {

Int value.

Node next:

Node rand;

Node(int val){ value= val }

}

rand pointer is a new pointer in the node structure of the single linked list. rand may point to any node in the linked list or mull

Given the head node of an acyclic single linked list composed of ndoe node types, please implement a function to copy the linked list and return the head node of the copied new linked list.

[required]

Time complexity ON). Additional space complexity O(1)

/pic:mw://03ccf88fcbe09ad4d166dd62401cea8e

Create map

In the first traversal, key is the old node and value is the new node

Traverse the linked list for the second time, find the new node from the old node, and assign the rand pointer to the new node

Finally, return to the new node

public static Node copyListWi thRand1(Node head) { HashMap<Node, Node> map = new HashMap<Node, Node>(); Node cur = head; while (cur != nu1l) { map.put(cur, new Node(cur .value)); cur = cur .next ; } cur = head; while (cur != nu1l) { .//cur seven // map.get(cur) map.get(cur).next = map. get(cur . next); map. get(cur).rand = map.get(cur.rand); cur = cur .next; } return map. get(head); }

#### :: copy without hash table:

For the first traversal, create a new node and insert it behind the old node

Set the rand pointer for the second traversal,

If the rand of 1 points to - > 3

Then the copy node of 3 is behind 3

Point the rand pointer of the copy node of 1 to the next node of 3

Finally, the copied nodes are concatenated to return to their head nodes

/pic:mw://ffca72bcc8cf741c73cc9a71ba8edd2b

public static Node copyListWithRand2(Node head) { if (head == nu1l) { return null; } Node cur = head; Node next = null; // copy node and link to every node //1->2 //1-> 1'->2 while (cur != nu11) { //cur old| next = cur .next; cur .next = new Node(cur .value); cur .next.next = next; cur = next; cur = head; } Node curCopy = nu1l; // set copy node rand //1->1'->2->2' while (cur != nu1l) { // cur 2 // cur.next new copy next = cur .next .next; curCopy = cur . next; curCopy.rand = cur .rand != null ? cur.rand.next : null; cur = next; } // head head.next Node res = head.next; . cur = head; // split while (cur != nu1l) { next = cur .next. next; curCopy = cur .next; cur .next = next; curCopy.next = next != nu1l ? next.next : nu11; cur = next; } return res; }

### :: return the first node of intersection:

Given two single linked lists that may or may not have rings, the head nodes head1 and head2. Please implement a function. If two linked lists intersect, please return the first node of the intersection. If it does not intersect, null is returned.

[required]

If the sum of the lengths of the two linked lists is N, the time complexity should reach O(N), and the additional space should be complex

The impurity should reach 0 (1).

#### :: give a linked list with a ring and find out the node into the ring:

//Find the first entry point of the chain leader. If not bad. This is null public static Node getLoopNode(Node head) { if (head == nu11 | head.next == nu11|| head.next.next == nu11) { return nu11; } //n1 fast n2 Node n1 = head.next; // n1 -> slow Node n2 = head.next.next; // n2 -> fast while (n1 != n2) { if (n2.next == null|| n2.next.next == nu1l) { return nu11; } n2 = n2.next .next; n1 = n1.next; } n2 = head; // n2 -> walk again from head while (n1 != n2) { n1 = n1.next; n2 = n2.next; . } return n1; }

#### Both linked lists are acyclic

All the nodes in the first linked list are entered into the set, and the nodes in the second linked list are found to be overlapping

No set

Traverse the first linked list, record the last node, and record the length of the linked list (the length is recorded as x)

Traverse the second linked list, record the last node, and record the length of the linked list (the length is recorded as y)

If the two last nodes are different, they do not intersect

x and y

Big ones go first, take x-y steps

Then the two linked lists go together and will meet at the intersecting node

//If the two chain lengths are not bad, drive back the parent node of phase: if you don't want disaster. Drive null public static Node noLoop(Node head1, Node head2) { if (head1 == null |I head2 == null) { return nu11; } Node cur1 = head1; Node cur2 = head2; intn=0; while (cur1.next != nu1l) { n++; cur1 = cur1.next; } while (cur2.next != nu1l) { n--; cur2 = cur2.next; } if (cur1 != cur2) { return nu1l; } // n: the value of chain length 1 minus chain length 2 cur1=n>0?headl:head2;//Who grows, whose head becomes cur1 cur2 = cur1 == head1 ? head2 : head1; //Who knows, whose head becomes cur2 while(n1=){ n--; cur1 = cur1.next; while (cur1 != cur2) { cur1 = cur1.next; cur2 = cur2.next; } return cur1; }

One has a ring and the other has no ring. In this case, the two linked lists do not intersect

#### Both have rings

If two linked lists intersect, they must share this ring

There are three situations

If the memory address of loop1 is equal to the memory address of loop2

Is the second case

If loop 1 is not equal to loop 2

Let loop1 go along the loop. If loop2 is not encountered, it is the first case

That is, there is no intersection

If loop2 is encountered, it is the third case

/pic:mw://6cb42ffbc1d73bb795ceb75c932bc96f

1/Two are linked. Return to network No.Two intersecting nodes. If you don't want to hand in the questions null public static Node bothLoop(Node head1, Node 1oop1, Node head2, Node 1oop2) { Node curl = nu1l; Node cur2 = null; if (loop1 == 1oop2) { cur1 = head1 ; cur2 = head2; intn=0; while (cur1 != 1oop1) { n++; cur1 = cur1.next; } while (cur2 != 1oop2) { n--; cur2 = cur2.next; } cur1=n>0?head1:head2; cur2 = cur1 == head1 ? head2 : head1; n = Math.abs(n); while (n != 0) { n--; cur1 = cur1.next ; } while (cur1 != cur2) { cur1 = cur1.next; cur2 = cur2.next; } }else { cur1 = 1oop1.next; while (cur1 != 1oop1) { if (cur1 == 1oop2) { return loop1; } cur1 = cur1.next; } return nu11; }

#### Main method

public static Node getIntersectNode (Node head1, Node head2) { if (head1 = null|| head2 = null) { return nu11; Node 1oop1 = getLoopNode(head1); Node_ 1oop2 = getL oopNode (head2) ; if (loop1 == nu11 && loop2 == nu11) { return noloop(head1, head2); } if (loop1 != nu1l && loop2 != nu11) { return bothLoop(head1, loop1, head2, 1oop2); } return null; }

### Can you delete this point on the linked list without giving the head node of the single linked list and only the node you want to delete?

Shake smart

Assign the value of the next node of the deleted node to the deleted node, and then point to the next node of the next node

However, the last node cannot be deleted