基础链表结构
class NodeList {
private Node head = new Node(0);
public Node getHead() {
return head;
}
public void add(Node node) {
Node temp = head;
while (temp.next != null) {
temp = temp.next;
}
temp.next = node;
}
public void list() {
if (head.next == null) {
System.out.println("链表为空!");
return;
}
Node temp = head.next;
while (temp != null) {
System.out.println(temp.toString());
temp = temp.next;
}
}
}
class Node {
public int num;
public Node next;
public Node(int num) {
this.num = num;
}
@Override
public String toString() {
return "Node{" +
"num=" + num +
'}';
}
}
求单链表中有效节点的个数
/**
* 求单链表中有效节点的个数
*
* @param node 头结点
* @return 有效节点个数
*/
public static int getLength(Node node) {
if (node.next == null) {
return 0;
}
Node temp = node.next;
int len = 0;
while (temp != null) {
len++;
temp = temp.next;
}
return len;
}
查找单链表中的倒数第k个结点
思路:
- 编写一个方法,接收head结点,同时接收index
- index表示倒数index个结点
- 先把链表从头到尾遍历,得到链表总长度(getLength)
- 得到size后,从链表第一个遍历,遍历(size-index)个,就可以得到
如果找到返回该节点,否则返回空
/**
* 查找单链表中倒数第index个数
*
* @param index index
* @param node 头结点
* @return 倒数第index个结点
*/
public static Node findLastIndexNode(int index, Node node) {
if (node.next == null) {
return null;
}
int size = getLength(node);
if (index <= 0 || index > size) {
return null;
}
Node temp = node.next;
for (int i = 0; i < size - index; i++) {
temp = temp.next;
}
return temp;
}
单链表的反转
思路:
- 先定义一个新节点reverseHead = new HearNode();
- 从头到尾遍历原来链表,每遍历一个节点,就将其取出,并凡在新的链表的最前端
- 把原来的链表的head.next = reverseHead.next
/**
*反转单链表
*
* @param node 头结点
*/
public static void reverseList(Node node) {
if (node.next == null || node.next.next == null) {
return;
}
Node temp = node.next;
Node next = temp.next;
Node result = new Node(0);
while (temp != null) {
next = temp.next;
temp.next = result.next;
result.next = temp;
temp = next;
}
node.next = result.next;
}
从尾到头打印单链表
思路:
要求:逆序打印单链表
- 方式1:先将单链表反转操作,然后再遍历即可。这样做的问题是会破坏原来单链表的结构,不建议
- 方式2:利用栈这个数据结构,将各个节点压入到栈中,然后利用栈的先进后出的特点,就实现了逆序打印的效果
/**
* 从头到尾打印单链表
* 方法1:反转后打印
* 方法2:利用栈
*
* @param node 头结点
*/
public static void reversePrint(Node node) {
if (node.next == null) {
return;
}
Stack<Node> stact = new Stack<>();
Node temp = node.next;
while (temp != null) {
stact.add(temp);
temp = temp.next;
}
while (stact.size() > 0) {
System.out.println(stact.pop());
}
}
合并两个有序的单链表,合并之后的链表依然有序
/**
* 两个有序单链表合并为有序单链表
* @param head1 表1头节点
* @param head2 表2头节点
* @return 合并后头节点
*/
public static Node merge(Node head1, Node head2) {
Node h1 = head1.next;
Node h2 = head2.next;
if (h1 == null) return h2;
if (h2 == null) return h1;
Node res = new Node(0);
Node flag = res;
while (h1 != null && h2 != null) {
if (h1.num < h2.num) {
flag.next = h1;
h1 = h1.next;
} else if (h2.num < h1.num) {
flag.next = h2;
h2 = h2.next;
} else {
flag.next = h1;
h1 = h1.next;
h2 = h2.next;
}
flag = flag.next;
}
if(h1==null){
flag.next = h2;
}
if(h2==null){
flag.next = h1;
}
return res;
}