1.输出单链表中倒数第k个节点
第一种解法:定义两个变量p、q指向头结点,q先向前走k-1步,之后p、q同时向后走,直到q.next=null,此时p指向的就是倒数第k个节点。(或者p先向前走k步,之后p、q同时向后走,直到q=null)
代码如下(用的是描述里括号中的方法即q先向前走k步)
private int getLength() {//求此链表长度
int length = 0;
for (Entry<T> p = headEntry; p != null; p = p.getNext()) {
length++;
}
return length;
}
public Entry<T> kCountDownEntry01(int k) {
int length = getLength();//这里求长度只是为了防止k无效
if (k <= 0 || k > length) {
return null;
}
Entry<T> p = headEntry, q = headEntry;
for (int i = 0; i < k; i++) {
q = q.getNext();
}
while (q!= null) {
p = p.getNext();
q = q.getNext();
}
return p;
第二种解法:也是比较容易想到的解法,直接遍历求出链表长度length,引用变量从头向后走length-k步即可。
代码如下
public Entry<T> kCountDownEntry02(int k) {
int length = getLength();
if (k <= 0 || k > length) {
return null;
}
int flag = length - k;
Entry p = headEntry;
for (int i = 0; i < flag; i++) {
p = p.getNext();
}
return p;
}
2.单链表的逆置
此问题需要三个引用变量p、q、s(如果只有前后两个变量的话,后者next域改为前者之后,其余结点的地址将找不到),详细操作请看下方动图。
代码如下
public void inversion() {
if (getLength() == 1) {
return;
}
Entry<T> p = headEntry;
Entry<T> q = p.getNext();
Entry<T> s = q.getNext();
while (q != null) {
q.setNext(p);
p = q;
q = s;
if (s != null) {//防止移动到链表末尾时出现空指针异常
s = s.getNext();
}
}
headEntry.setNext(null);
headEntry = p;//更新头节点
}
3.假设两个单链表相交,输出相交节点value
定义两个变量p、q分别指向两个链表的头结点,计算出两个链表的长度,假如p指向长链表的头结点,先让p走长链表与短链表的差值步,之后p、q一起向后移动,直到p=q,此时p(或q)指向相交节点。
代码如下
public static <E extends Comparable<E>> void TwoLinkIntersectEntry(Link<E> link1, Link<E> link2) {
int len1 = link1.getLength();
int len2 = link2.getLength();
int diff = Math.abs(len1 - len2);
Entry<E> p = link1.headEntry;
Entry<E> q = link2.headEntry;
if (len1 > len2) {
for (int i = 0; i < diff; i++) {
p = p.getNext();
}
} else if (len1 < len2) {
for (int i = 0; i < diff; i++) {
q = q.getNext();
}
}
while (p != q) {
p = p.getNext();
q = q.getNext();
}
System.out.println(p.getValue());
}
此算法验证较复杂,附测试代码
public static void main(String[] args) {
Link<Integer> link1 = new Link<>();
Link<Integer> link2 = new Link<>();
link1.addTail(8);
link1.addTail(4);
link1.addTail(6);
link1.addTail(5);
link1.addTail(19);
link1.addTail(13);
link1.addTail(2);
link1.addTail(0);
Entry<Integer> meetEntry = link1.getEntry(13);//获取准备作为相交节点的节点
link2.addHead(6);
link2.addHead(2);
link2.addHead(9);
link2.addHead(0);
Entry<Integer> preMeetEntry = link2.getEntry(6);//获取第二条链表中相交节点前一个节点
preMeetEntry.setNext(meetEntry);//将两个节点链接起来
System.out.print("链表1:");
link1.show();
System.out.print("链表2:");
link2.show();
System.out.print("相交节点:");
Link.TwoLinkIntersectEntry(link1,link2);
}
测试结果
4.判断一个单链表是否有环
此算法用到快慢引用,即一个快引用(每次走两步)和一个慢引用(每次走一步),如果快引用和慢引用能够相遇,则说明链表有环。
代码如下
public Entry<T> haveCircle() {//返回相遇结点,为下一道题铺垫
if (headEntry == null || headEntry.getNext() == null) {
return null;
}
Entry<T> fast = headEntry;
Entry<T> slow = headEntry;
while (true) {
fast = fast.getNext().getNext();
slow = slow.getNext();
if (fast == slow) {
return fast;
} else if (fast == null || fast.getNext() == null) {//没有环
return null;
}
}
}
5.如果链表有环,输出环的入口结点(续4)
设起始点到相遇点距离为L,环的长度为R,入口点到相遇点为x。如果快慢引用相遇,那么快引用一定比慢引用多走了nR,此时快引用所走的路程是慢引用所走路程的2倍,即L+nR+x=2(L+x),解得L=nR-x=R-x+(n-1)R。
当n=1时,起始点到入口点的距离等于相遇点到入口点的距离,此时在起始点定义p,在相遇点定义q,同时向后移动,当p=q时,p(或q)指向入口结点。(若n不为1,则是由于L过长,q会走(n-1)圈+相遇点到入口点距离之后与p在入口结点相遇)
代码如下
public Entry<T> enterPoint() {
Entry<T> meetPoint = haveCircle();//相遇点
if (meetPoint == null) {
return null;
}
Entry<T> p = meetPoint;
Entry<T> q = headEntry;
while (p != q) {
p = p.getNext();
q = q.getNext();
}
return p;
}
6.两个有序单链表合并成一个有序单链表
首先两个链表的头进行比较,小的作为新链表的头,之后再往后进行比较,小的就链在新链表头的后面,依次进行。
代码如下
public static <E extends Comparable<E>> void mergeOrder(LinkWithTail<E> link1, LinkWithTail<E> link2) {
if (link1.headEntry == null && link2.headEntry == null) {
return;
} else if (link1.headEntry == null && link2.headEntry != null) {
link2.show();//若链表1为空,直接打印链表2
return;
}else if(link1.headEntry!=null&&link2.headEntry==null){
link1.show();//若链表2为空,直接打印链表1
return;
}
Entry<E> p = link1.headEntry;
Entry<E> q = link2.headEntry;
Entry<E> newHeadEntry = p.getValue().compareTo(q.getValue()) > 0 ? q : p;//小的作为新链表的头
Entry<E> newTailEntry = newHeadEntry;//标记新链表的尾节点
if (newHeadEntry == p) {
p = p.getNext();
} else {
q = q.getNext();
}
while (p != null && q != null) {
if (p.getValue().compareTo(q.getValue()) < 0) {
newTailEntry.setNext(p);
newTailEntry = newTailEntry.getNext();
p = p.getNext();
} else if (p.getValue().compareTo(q.getValue()) > 0) {
newTailEntry.setNext(q);
newTailEntry = newTailEntry.getNext();
q = q.getNext();
} else {
newTailEntry.setNext(p);
newTailEntry.setNext(q);
newTailEntry = newTailEntry.getNext().getNext();
}
}
if (p == null) {//p(或q)为空时,直接将q(或p)链接到新链表的尾节点之后
newTailEntry.setNext(q);
} else {
newTailEntry.setNext(p);
}
for (Entry<E> i = newHeadEntry; i != null; i = i.getNext()) {//打印
System.out.print(i.getValue() + " ");
}
}
7.复杂链表的拷贝
代码如下(附测试代码)
public class ComplexLink<T> {
static class Node<E> {//复杂链表的节点
private E value;
private Node<E> next;
private Node<E> random;
public Node() {//head
}
public Node(E value) {
this.value = value;
}
}
private Node<T> head = null;
public ComplexLink() {
head = new Node<T>();
}
public void insert(T value, Node<T> random) {//头插法
Node<T> node = new Node<>(value);
node.random = random;
node.next = head.next;
head.next = node;
}
public void createList(T[] arr) {//创建一个复杂链表
if (arr.length > 3) {
Object[] node = new Object[arr.length];
int i = 0;
for (i = 0; i < arr.length; i++) {
node[i] = new Node<T>(arr[i]);
}
insert(arr[0], (Node<T>) node[arr.length - 1]);
insert(arr[1], (Node<T>) node[arr.length - 2]);
insert(arr[2], (Node<T>) node[arr.length - 3]);
for (i = 3; i < arr.length; i++) {
insert(arr[i], null);
}
}
}
public void cloneNodes() {//把复制的节点链接在原始链表的每一对应节点后面
Node<T> node = head;
while (node != null) {
Node<T> clone = new Node<>(node.value);
clone.random = null;
clone.next = node.next;
node.next = clone;
node = node.next.next;
}
}
public void connectRandom() {//复制的节点的random指针指向被复制节点的random指针的下一个节点
Node<T> node = head;
while (node != null) {
Node<T> clone = node.next;
if (node.random != null) {
clone.random = node.random.next;
}
node = node.next.next;
}
}
public Node<T> separateLists() {//拆分为两个链表,此代码中奇数位置为复制链表
Node<T> node = head;
Node<T> cloneHead = node;
Node<T> cloneNode = node.next;
node.next = cloneNode.next;
node = node.next;
while (node != null) {
cloneNode.next = node.next;
cloneNode = cloneNode.next;
node.next = cloneNode.next;
node = node.next;
}
return cloneHead;
}
public Node<T> clone() {//三个步骤代码合并
cloneNodes();
connectRandom();
return separateLists();
}
public void show() {//打印
Node<T> p = head.next;
while (p != null) {
if (p.random != null) {
System.out.println("value: " + p.value + " random: " + p.random.value);
} else {
System.out.println("value: " + p.value + " random: " + p.random);
}
p = p.next;
}
System.out.println();
}
public static void main(String[] args) {
Integer[] arr = {1, 2, 3, 4, 5, 6};
ComplexLink<Integer> link = new ComplexLink<>();
link.createList(arr);
link.clone();
link.show();
}
}