1. 单链表
1.1 java实现
先定义一个Node类用来存储节点的值域和指针域
public class LNode {
protected int data;
protected LNode next;
public LNode(int data) {
this.data = data;
}
}
定义一个链表主类,并且定义各种对链表操作的方法
//带头结点的单链表
public class Linklist {
private LNode head;// 定义一个头结点
Linklist() {
head = new LNode(0);
this.head.next = null;
}
// 插入节点--默认头插法
public void add(int data) {
LNode node = new LNode(data);
LNode head = this.head.next;
node.next = head;
this.head.next = node;
}
// 指定位置之前插入节点
// pos--插入的位置 value--插入的值
public boolean add(int pos, int value) {
LNode p = this.head;
int j = 0;
while (p != null && j < pos - 1) {
p = p.next;
j++;
}
// 插入位置小于1或者大于表长+1
if (p == null || j > pos - 1)
return false;
LNode node = new LNode(value);
node.next = p.next;
p.next = node;
return true;
}
// 删除节点
public LNode delete(int value) {
LNode current = this.head.next;
LNode previous = this.head; // 记住上一个节点
while (current.data != value) {
if (current.next == null) {
return null;
}
previous = current;
current = current.next;
}
previous.next = current.next;
return current;
}
// 显示出所有的节点信息
public void displayAllNodes() {
LNode current = this.head.next;
while (current != null) {
System.out.println(current.data + " ");
current = current.next;
}
System.out.println();
}
}
2.从尾到头打印链表(剑指offer-5)
题目:输入一个链表的头结点,从尾到头反过来打印出每个结点的值。
解析:这就是典型的“后进先出”,可以用栈实现这种顺序。每经过一个结点的时候,把该结点放到一个栈中。当遍历完整个链表后,再从栈顶开始逐个输出结点的值,此时输出的结点的顺序已经反转过来了。
栈实现:
//从尾到头打印链表
public void PrintListReverse(Linklist L) {
Stack<Integer> s = new Stack<Integer>();
LNode Lhend = L.head.next;
while (Lhend != null) {
s.add(Lhend.data);
Lhend = Lhend.next;
}
while(!s.isEmpty()){
System.out.print(s.peek()+" ");
s.pop();
}
}
递归实现:
public void PrintListReverse(LNode L) {
if(L!=null){
if(L.next!=null){
PrintListReverse1(L.next);
}
System.out.print(L.data+" ");
}
}
题目:给定单链表头指针和一个结点指针,定义一个函数在O(1)时间内删除该结点。
解析:对于上图实例链表(a)删除指针p有两种方式
思路1:(b)找到前一个指针pre,赋值pre->next = p->next,删掉p
思路2:(c)目的是删除p,但是不删p,直接用p->next的值赋值给p,把p->next删除掉(好处:不用遍历找到p的前一个指针pre,O(1)时间内搞定)
于是,定位到思路2,但是思路2有两个特例:
删除的是尾指针,需要遍历找到前一个指针
整个链表就一个结点(属于删尾指针,但没法找到前面的指针,需要单独处理)
java代码实现:
// 删除给定指针的节点
public void deleteNode(LNode head, LNode toBeDelete) {
if (head == null || toBeDelete == null) {
return;
}
if (toBeDelete.next != null) { // 不是尾结点
LNode node = toBeDelete.next;
toBeDelete.data = node.data;
toBeDelete.next = node.next;
node = null;
} else if (head == toBeDelete) {// 只有一个结点,删除头结点
toBeDelete = null;
head = null;
return;
} else {// 多个结点,删除尾结点
LNode node = head;
while (node.next != toBeDelete) {
node = node.next;
}
node.next = null;
toBeDelete = null;
}
}
4. 链表中倒数第K个结点(剑指offer-15)
题目:输入一个链表,输出该链表中倒数第K个结点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾结点是倒数第1个结点。例如一个链表有6个结点,从头结点开始它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个结点是值为4的结点。
解析:设定两个指针p1和p2,两个指针刚开始都指向链表的第一个结点,然后让p1指针先走(k-1)步,然后再让两个指针一起往后走,当p1指针指向链表最后一个结点的时候,p2指针刚好指向链表中的倒数第k个结点。
在写代码的时候需要考虑鲁棒性,最好采用防御性编程,就是考虑在哪些地方会出错,然后提前加上错误判断,这样避免因此错误输入而导致程序崩溃。
java代码:
// 查找链表中倒数第K个结点
public LNode findKthToTail(LNode head, int k) {
if (head.next == null || k == 0)
return null;
LNode pNode = head;
LNode pKthNode = head;
while (k - 1 > 0) {
if (pNode.next != null) {
pNode = pNode.next;// 让pNode先走k-1步
--k;
} else {
return null;
}
}
while (pNode.next != null) {
pNode = pNode.next;
pKthNode = pKthNode.next;
}
return pKthNode;
}
相关题目
1.求链表的中间结点。如果链表中结点总数为奇数,返回中间结点;如果结点总数是偶数,返回中间两个结点的任意一个。为了解决这个问题,我们也可以定义两个指针,同时从链表的头结点出发,一个指针一次走一步,另一个指针一次走两步。当走得快的指针走到链表的末尾时,走得慢的指针正好在链表的中间。
2.判断一个单向链表是否形成了环状结构。和前面的问题一样,定义两个指针,同时从链表的头结点出发,一个指针一次走一步,另外一个指针一次走两步。如果走得快的指针追上了走得慢的指针,那么链表就是环状结构;如果走得快的指针走到了链表的末尾(m_pNext指向NULL)都没有追上走得慢的指针,那么链表就不是环状结构。
参考来源: