一、获取到单链表的节点的个数

/*
* head 链表的头节点
* 返回有效节点的个数,没有统计头节点
* */
public static int getLength(HeroNode head) {
    if(head.next == null) {
		return 0;
	}
	int length = 0;
	//定义一个辅助变量
	HeroNode cur = head.next;
	while(cur != null) {
		length++;
		cur = cur.next;
	}
	return length;
}

二、查找单链表的第K个节点

//思路
//1、编写一个方法接收，接收head节点，同时接收一个index
//2、index表示倒数第index个节点
//3、先把链表从头到尾遍历，得到链表的总的长度
//4、得到size后，我们从链表的第一个开始遍历（size-index）个
//5、找到返回该节点，没有返回空
public static HeroNode findLastIndexNode(HeroNode head,int index) {
	if(head.next == null) {
		return null;
	}
	//第一次遍历得到链表的长度（节点的个数）
	int size = getLength(head);
	//第二次遍历 size-index位置，就是我们倒数的第K个节点
	//先做一个index的校验
	if(index<=0||index>size) {
		return null;
	}
	//定义以辅助变量,for循环定位到倒数的index个
	HeroNode cur = head.next;
	for(int i=0;i<size-index;i++) {
		cur = cur.next;
	}
	return cur;
}

三、单链表的反转

//单链表的反转
public static void reverseList(HeroNode head) {
	//如果链表为空，或只有一个节点，无需反转，直接返回
	if(head.next == null||head.next.next == null) {
		return;
	}
	//定义一个辅助指针（变量），帮助我们遍历原来的链表
	HeroNode cur = head.next;
	HeroNode next = null;//指向当前节点[cur]的下一个节点
	HeroNode reverseHead = new HeroNode(0,"","");
	//遍历原来的链表，并完成从头遍历原来的链表，每遍历一个节点，就将其取出，放在reverseHead的最前端
	while(cur != null) {
		next = cur.next;//暂时保存当前节点的下一个节点，因为后面需要使用
		cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
		reverseHead.next = cur;//将cur连接到新的链表上
		cur = next;//让cur指向下一个节点，后移
	}
	//将head.next指向reverseHead.next,实现单链表反转
	head.next = reverseHead.next;
}

四、实现逆序打印

//使用方式二，实现逆序打印，栈
public static void reversePrint(HeroNode head) {
	if(head.next == null) {
		return;
	}
	//创建一个栈
	Stack<HeroNode> stack = new Stack<HeroNode>();
	HeroNode cur = head.next;
	//将链表的所有节点压入栈中
	while(cur != null) {
		stack.push(cur);
		cur = cur.next;//压入下一个节点
	}
	//将栈中的节点进行打印,pop()
	while(stack.size()>0) {
		System.out.println(stack.pop());
	}
}

五、合并两个有序的单链表，合并之后的链表依然有序

public static void combineList(HeroNode head1,HeroNode head2){
	HeroNode next1 = head1.next;
	HeroNode next2 = head2.next;
	//合并后的链表头
	HeroNode joinedHead = new HeroNode(0,"","");
	if(head1.next == null){
		joinedHead.next = head2.next;
    }else if (head2.next == null){
       	joinedHead.next = head1.next;
    }
	//合并后的链表
	SingleLinkedList joinedLinkedList = new SingleLinkedList();
	HeroNode nextJoined = joinedHead;
	joinedLinkedList.head = nextJoined;
	while(next1 != null||next2 != null) {
		if(next1 == null && next2 != null) {
			nextJoined.next = next2;
			next2 = next2.next;
		}else if(next1 != null && next2 == null) {
			nextJoined.next = next1;
			next1 = next1.next;
		}else {
			if(next1.no <= next2.no) {
				nextJoined.next = next1;
				next1 = next1.next;
			}else {
				nextJoined.next = next2;
				next2 = next2.next;
			}
		}
		nextJoined = nextJoined.next;
	}
	SingleLinkedList singleLinkedList = new SingleLinkedList();
    singleLinkedList.list2(joinedHead);
}

递归思路

特殊情况：如果有一个链表为空，返回另一个链表如果pHead1 节点值比小pHead2，下一个节点应该是 pHead1，应该return pHead1，在return之前，指定pHead1的下一个节点应该是pHead1.next和pHead2俩链表的合并后的头结点如果pHead1 节点值比pHead2大，下一个节点应该是pHead2，应该return pHead2，在return之前，指定pHead2的下一个节点应该是pHead1和pHead2.next俩链表的合并后的头结点