hello,大家好,我是阿旭啊。今天给大家带来数据结构第六篇:链表经典题型和双向链表的实现。希望能给大家一些小帮助~
首先进行链表判空。
if (head == null){
return null;
然后判断是否只有一个节点:
if (head.next == null){
return head;
}
由于head也进行了改变,所以没必要给head找一个替身。我们给head.next找一个替身cur。我们将cur的next设置成head,再将cur设置成head,此时前两个节点已经反转完成。
cur.next = head;
head = cur;
但是我们会发现第三个结点以及之后的节点已经找不到了。所以我们还需要给第三个结点找一个替身cur1。当前两个节点反转之后我们将cur1设置成cur,cur1设置成cur.next。此时再次进行上述操作来进行第二个和第三个结点的反转。
cur.next = head;
head = cur;
cur = cur1;
cur1 = cur.next;
然而当我们cur等于null的时候会发现cur1空指针异常。所以我们将cur1 = cur.next;放到循环的第一位。这样最后cur会和cur1相等,避免了空指针异常。
完整代码:
public ListNode reverseList(ListNode head) {
if (head == null){
return null;
}
if (head.next == null){
return head;
}
ListNode cur = head.next;
head.next = null;
while(cur != null){
ListNode cur1 = cur.next;
cur.next = head;
head = cur;
cur = cur1;
}
return head;
}
使用快慢指针来进行取中间。找head的两个替身分别为fast,slow。当fast不等于空且fast.next不等于空的时候(要注意不能写反,如果写反当fast为空的时候会发生空指针异常),fast走两步,slow走一步。最后返回slow就是中间的节点。
public ListNode middleNode(ListNode head) {
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
}
return slow;
}
依旧使用快慢指针来解题。首先判断k是否是否合法。先让快指针走k步。之后快慢指针一起走,直到快指针为空。此时的慢指针就是倒数第k个节点。
public ListNode FindKthToTail(ListNode head,int k) {
if (k <= 0){
return null;
}
ListNode fast = head;
ListNode slow = head;
for (int i = 0; i < k; i++){
if(fast == null){
return null;
}
fast = fast.next;
}
while(fast != null){
slow = slow.next;
fast = fast.next;
}
return slow;
}
首先设置一个新的头结点newHead。然后将newHead设置成head(此时newHead已经是head的替身)。同时遍历list1和list2,当list1不为空且list2也不为空时进行循环。如果list1.value
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
ListNode newHead = new ListNode(0);
ListNode head = newHead;
while(list1 != null && list2 != null){
if(list1.val < list2.val){
newHead.next = list1;
list1 = list1.next;
newHead = newHead.next;
}else{
newHead.next = list2;
list2 = list2.next;
newHead = newHead.next;
}
}
if(list1 == null){
newHead.next = list2;
}
if(list2 == null){
newHead.next = list1;
}
return head.next;
}
思路:建立两个链表,第一个是小于x的节点,第二个是大于或等于x的节点,最后将第二个链表尾插到第一个链表。 思路:先判空。回文结构的链表从中间节点分开后将后半段链表反转。此时两个链表应该是一样的。如果不一样就不回文 思路:两个链表后半段相同,前面相差的步数就是两个链表的长度之差。我们可以让长链表先走相差的步数,然后两个链表一起走,这样当两个节点相等时就是相同部分 思路:本题仍然使用快慢指针,快指针走两步,慢指针走一步,当快指针等于慢指针的时候就说明他们链表有环,如果快指针为空或者快指针的后驱为空则链表没有环。 双向链表中的节点包括:值(value), 前驱(prve),后驱(next)。 首先,双链表类中包括节点类和所有的方法。和单列表一样,先把双向链表类中的节点类写出来。节点类中包括value,next,prev以及一个构造方法: 在单链表中,我们有头结点(head),我们设置了一个成员变量为head。在双向链表中,我们可以设置头结点(head)和尾结点(last): 我们第一个写的方法是获得链表的长度size方法。顺序遍历一遍链表然后进行count计数。要注意要用cur来替代head: 我们第二个写的方法是打印链表display方法。顺序遍历链表**(只要是遍历链表且不改变链表的时候都需要进行cur替身)**,遍历的时候一个一个打印: 我们第三个写的方法是查找链表中是否含有key值的contains方法。遍历一遍链表,并且每一个进行value值与key值进行对比。若相等就true。不相等就false: 我们发现双向链表的这三个方法与单向链表的这三个方法是一样的。 我们第五个写尾插法addLast方法。双向链表中我们不仅定义了head,还定义了last。我们可以直接使用last来将新节点与原来的链表联系到一起,然后将新节点设置成last: 我们第六个写任意位置插入函数addIndex(第一个节点为0号下标)。涉及到了位置,我们第一步先判断位置是否合法。如果不合法就抛出IndextOusBoundsException异常。当位置判断为0时候,进行头插法,当位置为size()时候,进行尾插法。在中间插入时候我们需要先找到插入位置的前一个位置(使用for循环和cur替身)。然后先对节点的next和prev进行改变,再对原链表中的节点的next和prev进行改变: 我们第七个写删除第一次出现关键字为key的节点 方法remove方法。首先先判断这个链表是否为空,如果为空就直接返回。将cur设置成head的替身进行遍历。当cur.value等于key时判断是否为头结点。如果是头结点,再去判断是否这个链表只有这一个结点。如果只有这一个结点那么直接将头结点置空(也可以将尾结点置空,也因此时头结点等于尾结点。)然后返回。如果不是只有这一个节点,那么将头结点后置,然后将新的头结点的prev置空,然后返回。如果不是头结点而是尾结点,将尾结点前置,然后将新的尾结点的next置为空然后返回。如果是中间节点,那么将删除节点的前一个节点的next置成删除节点的下一个节点,删除节点的后一个节点的prev置成删除节点的掐一个节点的next然后返回。如果cur的value不等于key,那么判断下一个节点。 我们第八个写删除所有关键字为key的节点的方法removeAllKey方法。首先需要判断链表是否为空。如果为空则直接返回。设置一个cur来当做head的替身。然后遍历这个链表。当cue的value与key相等时,如果cur是head,判断是否只有一个结点,如果只有一个结点,head置空。如果不是只有一个结点。将head后置一位,并且新head的prev置空。如果cur不是head而是last,last前置一位并且last的next置空。如果也不是last,将cur的前一个节点的next设置成cur的下一个节点,将cur的下一个节点的prev设置成cur的上一个节点。(与上一个方法相比就是把每次相等的返回去掉。) 我们写最后一个清空链表的函数clean函数。我们可以直接将head和last置空(最简单的办法)。在java源码中是将每一个节点全部置空。
实践:先找一个原来头结点的替身cur。然后创建两个头结点head1,head2。然后找这两个头结点的替身cur1,cur2。遍历原来的链表,如果cur.value public ListNode partition(ListNode pHead, int x) {
ListNode cur = pHead;
ListNode head1 = new ListNode(0);
ListNode head2 = new ListNode(0);
ListNode cur1 = head1;
ListNode cur2 = head2;
while(cur != null){
if (cur.val < x){
cur1.next = cur;
cur1 = cur1.next;
}else{
cur2.next = cur;
cur2 = cur2.next;
}
cur = cur.next;
}
cur1.next = head2.next;
cur2.next = null;
return head1.next;
}
6.链表的回文结构
public boolean chkPalindrome(ListNode A) {
if (A == null){
return false;
}
ListNode fast = A;
ListNode slow = A;
//找中间位置slow
while (fast != null && fast.next != null){
slow = slow.next;
fast = fast.next.next;
}
//开始反转后半链表,翻转完毕后slow为新列表的newHead
ListNode newHead = slow.next;
slow.next = null;
while (newHead != null){
ListNode cur = newHead.next;
newHead.next = slow;
slow = newHead;
newHead = cur;
}
//开始判断是否是回文
ListNode cur1 = A;
while(slow != null){
if (cur1.val != slow .val){
return false;
}
cur1 = cur1.next;
slow = slow.next;
}
return true;
}
7.输入两个链表,找出它们的第一个公共结点
实践:先判空。先找出两个头结点的替身curA,curB。求两个链表的长度分别为countA,countB。然后将curA和curB再次改回两个头结点的替身。然后求步数之差ret。如果countApublic ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if (headA == null || headB == null){
return null;
}
int countA = 0;
int countB = 0;
ListNode curA = headA;
ListNode curB = headB;
//分别求两个链表的长度
while(curA != null){
countA++;
curA = curA.next;
}
curA = headA;
while(curB != null){
countB++;
curB = curB.next;
}
curB = headB;
//求差值步数的长度
int ret = countA - countB;
if (ret < 0){
curA = headB;
curB = headA;
ret = countB - countA;
}
for(int i = 0; i < ret; i++){
curA = curA.next;
}
while (curA != curB){
curA = curA.next;
curB = curB.next;
}
return curA;
}
8.给定一个链表,判断链表中是否有环
public boolean hasCycle(ListNode head) {
if (head == null || head.next == null){
return false;
}
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
if (fast == slow){
return true;
}
}
return false;
}
9.给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 NULL
从head到入口点长X,环长为S,从相遇点到入口为y。相遇点是由快慢指针快走两步,慢走一步找到的。所以他们的路程也是二倍的关系:
当快指针在环里走了c圈:
2 [x + (s - y)] = x + (s - y) + cs
解得:
x = (c - 1)s + y
从中可以看出来如果使用快慢指针一个指针在head开始走,一个从相遇点开始走,当他们相等的时候就是入口点。public ListNode detectCycle(ListNode head) {
if (head == null){
return null;
}
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
if (fast == slow){
break;
}
}
if (fast == null || fast.next == null){
return null;
}
fast = head;
while (fast != slow){
fast = fast.next;
slow = slow.next;
}
return fast;
}
二.双向链表的方法及实现
1.双向链表的方法
public class MyLinkedList {
//头插法
public void addFirst(int data){ }
//尾插法
public void addLast(int data){}
//任意位置插入,第一个数据节点为0号下标
public void addIndex(int index,int data){}
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key){}
//删除第一次出现关键字为key的节点
public void remove(int key){}
//删除所有值为key的节点
public void removeAllKey(int key){}
//得到单链表的长度
public int size(){} public void display(){} public void clear(){}
}
2.双向链表实现
public class MyLinkedList {
static class ListNode {
public int value;
public ListNode next;
public ListNode prev;
public ListNode(int value) {
this.value = value;
}
}
}
public ListNode head;
public ListNode last;
public int size() {
ListNode cur = head;
int count = 0;
while (cur != null) {
count++;
cur = cur.next;
}
return count;
}
public void display() {
ListNode cur = head;
while (cur != null) {
System.out.print(cur.value + " ");
cur = cur.next;
}
System.out.println();
}
public boolean contains(int key) {
if (head == null) {
return false;
}
ListNode cur = head;
while (cur != null) {
if (cur.value == key) {
return true;
}
cur = cur.next;
}
return false;
}
我们第四个写的方法是头插法addFirst方法。定义一个新的节点。先把新节点与原来的链表联系起来,再去设置头结点。要注意一开始需要判空,当链表为空时,新节点既是头结点也是尾结点:public void addFirst(int data) {
ListNode node = new ListNode(data);
if (head == null) {
last = node;
head = node;
return;
}
node.next = head;
head.prev = node;
head = node;
}
public void addLast(int data) {
ListNode node = new ListNode(data);
if (head == null) {
last = node;
head = node;
return;
}
node.prev = last;
last.next = node;
last = node;
}
public void addIndex(int index, int data) {
if (index < 0 || index > size()) {
throw new IndexOutBoundsException("获取数据时,位置不合法");
}
if (index == 0) {
addFirst(data);
return;
}
if (index == size()) {
addLast(data);
return;
}
ListNode node = new ListNode(data);
ListNode cur = head;
for (int i = 0; i < index - 1; i++) {
cur = cur.next;
}
node.next = cur.next;
node.prev = cur;
cur.next.prev = node;
cur.next = node;
}
public void remove(int key) {
if (head == null) {
return;
}
ListNode cur = head;
while (cur != null) {
if (cur.value == key) {
if (cur == head) {
if (cur.next == null) {
head = null;
} else {
head = head.next;
head.prev = null;
}
return;
} else if (cur == last) {
last = last.prev;
last.next = null;
return;
} else {
cur.prev.next = cur.next;
cur.next.prev = cur.prev;
return;
}
}
cur = cur.next;
}
}
public void removeAllKey(int key) {
if (head == null) {
return;
}
ListNode cur = head;
while (cur != null) {
if (cur.value == key) {
if (cur == head) {
if (cur.next == null) {
head = null;
} else {
head = head.next;
head.prev = null;
}
} else if (cur == last) {
last = last.prev;
last.next = null;
} else {
cur.prev.next = cur.next;
cur.next.prev = cur.prev;
}
}
cur = cur.next;
}
}
public void clear() {
//head = null;
//last= null;
ListNode cur = head.next;
while (cur != null){
head = null;
head = cur;
cur = cur.next;
}
head = null;
}
总结