preface
This article is mainly about some classic related to linked lists in data structures OJ At the end of the paper, we also provide OJ The specific website of the question is for everyone to practice OJ I hope you can have a deeper understanding of the linked list. Finally, it is not easy to create. I hope you can give encouragement, praise, comment, exchange and study!
1. Delete all nodes in the linked list equal to the given value "val"
For example:
Input: head = [1,2,6,3,6], val = 6
Output: [1,2,3]
Graphic process:
After deletion
With the idea, the code is as follows:
public nodelist deletion(int val){
if (head==null)return null;
nodelist cur=head;
while (cur!=null){
while(cur.next!=null&&cur.next.val==val){
cur.next=cur.next.next;
}
cur=cur.next;
}
if(head.val==val){
head=head.next;
}
return head;
}
Second, reverse a single linked list
For example:
Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]
Code implementation
public nodelist fanzhuang(){
nodelist prve=null;
nodelist cur=head.next;
while (cur!=null){
head.next=prve;
prve=head;
head=cur;
cur=cur.next;
}
head.next=prve;
return head;
}
Three intermediate nodes
Given a non empty single linked list with head node, return the intermediate node of the linked list. If there are two intermediate nodes, the second intermediate node is returned.
For example:
head=[1,2,3,4,5] returns 3
head=[1,2,3,4] returns 3
Graphic analysis
Code implementation:
//Intermediate node problem
//Solution speed pointer
public nodelist midnode(){
nodelist fast=head;
nodelist slow=head;
while (fast!=null&&fast.next!=null){
slow=slow.next;
fast=fast.next.next;
}
return slow;
}
For the analysis method of two nodes, you can draw your own drawing experience, and you can better understand this topic. Here we propose a variant. If there are two nodes, what should we do to return the first node?
The specific code implementation is as follows:
public nodelist midnode(){
nodelist fast=head;
nodelist slow=head;
while (fast!=null&&fast.next!=null){
fast=fast.next.next;
if (fast==null){
return slow;
}
slow=slow.next;
}
return slow;
}
The penultimate node of the four linked list
Specific code implementation:
//Find the penultimate node
public nodelist node(int k){
if (k<0||head==null)return null;
nodelist slow=head;
nodelist fast=head;
while (k-1!=0){
fast=fast.next;
if (fast==null){//If it is out of range, fast should be null
return null;
}
k--;
}
while (fast.next!=null){
fast=fast.next;
slow=slow.next;
}
return slow;
}
V. merge ordered linked list
Merge the two ordered linked lists into a new ordered linked list and return. The new linked list is composed of all nodes of a given two linked lists.
For this problem, we can create a new node and string them. The specific implementation code is as follows:
//Merge ordered list
public static nodelist mergeTwoLists(nodelist head, nodelist head1) {
nodelist newhead=new nodelist(-1);//Create a new node
nodelist cur=newhead;
while(head!=null&&head1!=null){
if(head.val<head1.val){
cur.next=head;
cur=head;
head=head.next;
}else{
cur.next=head1;
cur=head1;
head1=head1.next;
}
}
if(head==null){
cur.next=head1;
}else{
cur.next=head;
}
return newhead.next;
}
Six linked list segmentation
Problem Description:
The existing head pointer ListNode head of a linked list gives a certain value of X, writes a piece of code, arranges all nodes less than x before other nodes, and cannot change the original data order, and returns the head pointer of the rearranged linked list.
Before splitting the linked list:
After split:
It should be noted here that we must first define a cur to traverse the linked list, and then use these four empty nodes to string them. It should be noted here that as, ae, bs, be, which we entered at the beginning, need to be discussed separately.
Attention to details:
1 if the value of x is appropriate, there may be no data in the first half of the split linked list, that is, as=null, then we must return bs (if the second half is also empty, it means an empty linked list)
2 after judging the previous one, we must make ae.next=bs, so as to link the split linked list
3 for the split linked list, we can't ensure that the last element must be in the second part or the first part. Then there will be a problem at this time, that is, the linked list has no tail, so we need to set be.next to null
Specific code implementation:
//Segmentation of linked list
public static nodelist spiltist(nodelist head,int x){
nodelist as=null;
nodelist ae=null;
nodelist bs=null;
nodelist be=null;
nodelist cur=head;
if (head==null)return null;
while (cur!=null){
if (cur.val<x){
//First entry
if (as==null){
as=cur;
ae=cur;
}else{//Not the first time
ae.next=cur;
ae=ae.next;
}
}else{
//First entry
if (bs==null){
bs=cur;
be=cur;
}else{//Not the first time
be.next=cur;
be=be.next;
}
}
cur=cur.next;
}
if (as==null){//Judge whether there will be data in the first half
return bs;
}
ae.next=bs;//Join the front and rear parts together
if (bs!=null&&be.next!=null){//Judge whether be.next is null or not, and set it to null manually
be.next=null;
}
return as;
}
VII. Delete duplicate nodes
Problem Description:
In a sorted linked list, there are duplicate nodes. Please delete the duplicate nodes in the linked list. The duplicate nodes are not retained and the chain header pointer is returned. For example, the linked list 1 - > 2 - > 3 - > 3 - > 4 - > 4 - > 5 is 1 - > 2 - > 5 after processing
Before deletion:
After deletion:
Through the above two pictures, we can use a puppet node to string those non repeating nodes, and then return new.next, which will be the linked list we want to get.
Attention to details:
1. It is wrong to assume that newhead.next is the head at a glance, because if a linked list is {1, 1, 2, 3}, it can explain this wrong view
2 for the direct connection between the puppet node and the linked list, we can define a temp, let temp=newhead, when cur.val= When cur.next.val, let temp.next=cur
The specific code is as follows:
//Delete duplicate nodes
public nodelist delet(){
nodelist newhead=new nodelist(1);
nodelist cur=head;
nodelist temp=newhead;
while (cur!=null){
if (cur.next!=null&&cur.val==cur.next.val){
while(cur.next!=null&&cur.val==cur.next.val){//There are multiple duplicate values
cur=cur.next;
}
cur=cur.next;
}else{
temp.next=cur;
cur=cur.next;
temp=temp.next;
}
}
if(temp.next!=null){
temp.next=null;
}
return newhead.next;
}
The last if statement should be mentioned here. In this code, if the linked list is {1, 2, 3, 3, 3}, if there is no if statement, the last repeated node cannot be deleted. According to the above code, what we want is that when cur=null, temp.next=null, so it is necessary for us to make such a judgment here.
Palindrome structure of eight linked list
For A linked list, please design an algorithm with time complexity of O(n) and additional space complexity of O(1) to judge whether it is palindrome structure. Given the header pointer A of A linked list, please return A bool value to represent whether it is A palindrome structure
For example: 1 - > 2 - > 2 - > 1
Return: true
One needs to use the fast and slow pointer to find the midpoint
Two reverse linked list
In the reverse linked list, we need to define a cur, let cur.next=slow, so as to complete the reversal of the next node where the current slow is located. We also need to go down. We need to define a curNext to record the next node of cur, but then a node cannot be found. We are moving slow=cur, so as to move slow back one bit. We are making cur=curNext, curNext=curNext.next (an if statement should be used here to determine whether curNext is null). Combined with the above, the ultimate goal is to reverse to the last node (that is, the position of slow should be on the last node). Then we must reverse more than one node, so we need a loop, Then the termination condition of this loop is cur= null
Three judge palindrome structure
From the picture after the inversion, if it is a palindrome structure, then if we walk back with slow and head at the same time, then head and slow will meet. In particular, the above situation is discussed for odd nodes. In fact, even nodes are the same, but when judging, it becomes head.next=slow. You can try to draw the specific figure yourself. In the code, I will write the total code of the two cases.
Code display
public class PalindromeList {
public boolean chkPalindrome(ListNode head) {
// write code here
if(head==null||head.next==null)return false;
//Find midpoint
ListNode fast=head;
ListNode slow=head;
while(fast!=null&&fast.next!=null){
fast=fast.next.next;
slow=slow.next;
}
//Reverse linked list
ListNode cur=slow.next;
ListNode curNext=cur.next;
while(cur!=null){
cur.next=slow;
slow=cur;
cur=curNext;
if(curNext!=null){
curNext=curNext.next;
}
}
//Judging palindrome structure
while(head!=slow){
if(head.val==slow.val){
head=head.next;
slow=slow.next;
if(head.next==slow){
return true;
}
}else{
return false;
}
}
return true;
}
}
Nine intersecting linked list
Title Description
Here are the head nodes headA and headB of the two single linked lists. Please find and return the starting node where the two single linked lists intersect. If the two linked lists do not have intersecting nodes, null is returned.
For intersecting nodes, we also adopt the method of fast and slow pointer, and set headA=slow and headB=fast. From the figure, we can see that B is longer than A, so we need to define an integer to represent the length difference between B and A, and let fast take this difference step more. Then fast and slow will go together, and then they will meet, and we will return to the meeting node
For the given linked list, it can also be this kind. It doesn't matter at this time. We can use an if to judge on the basis of the previous one. If B is longer, we can exchange the directions of fast and slow
The specific implementation code is as follows:
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode slow=headA;
ListNode fast=headB;
int lena = 0;
int lenb = 0;
while(slow!=null){
lena++;
slow=slow.next;
}
while(fast!=null){
lenb++;
fast=fast.next;
}
slow=headA;
fast=headB;
int c=lenb-lena;
if(c<0){
fast=headA;
slow=headB;
c=lena-lenb;
}
while(c!=0){
fast=fast.next;
c--;
}
while(fast!=slow){
fast=fast.next;
slow=slow.next;
}
return slow;
}
}
X. judge whether there is a ring in the table
For the problem of whether the loop is formed, we use the fast and slow pointer to solve it. We let fast take two steps at a time and slow take one step at a time. Then slow and fast will eventually meet, but we dare not let fast go three times. If there are only two nodes, they will never meet
The specific code is as follows
public class Solution {
public boolean hasCycle(ListNode head) {
if(head==null||head.next==null)return false;
ListNode fast=head.next;
ListNode slow=head;
while(fast!=null&&fast.next!=null){
if(fast==slow){
return true;
}
slow=slow.next;
fast=fast.next.next;
}
return false;
}
}
Eleven ring linked list II
Given a linked list, return the first node from the linked list into the ring. If the linked list is acyclic, null is returned.
As shown in the figure, we want to return the node 2. For this problem, we also use the fast and slow pointer to solve it
1 find the meeting point of fast and slow first
2 set one of fast and slow as the head node. If the two go together, they will go to the first node in the ring
Code implementation:
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode slow=head;
ListNode fast=head;
while(fast!=null&&fast.next!=null){
fast=fast.next.next;
slow=slow.next;
//If we meet in the ring
if(fast==slow){
break;
}
}
//No meeting
if(fast==null||fast.next==null){
return null;
}
slow=head;
while(slow!=fast){
slow=slow.next;
fast=fast.next;
}
return fast;
}
}
OJ topic website
1 delete all nodes in the linked list equal to the given value val
2 reverse a single linked list
3 given a non empty single linked list with head node, return the intermediate node of the linked list. If there are two intermediate nodes, the second intermediate node is returned.
4 input a linked list and output the penultimate node in the linked list.
5 merge the two ordered linked lists into a new ordered linked list and return. The new linked list is composed of all nodes of a given two linked lists.
6 write code to divide the linked list into two parts based on the given value x, and all nodes less than X are arranged before nodes greater than or equal to X
7 in a sorted linked list, there are duplicate nodes. Please delete the duplicate nodes in the linked list. The duplicate nodes are not retained and the chain header pointer is returned.
Palindrome structure of linked list
9 input two linked lists and find their first common node.
10 given a linked list, judge whether there are links in the linked list
11 given a linked list, return the first node from the linked list into the ring. If the linked list is acyclic, null is returned