-
求单链表中节点的个数
-
查找单链表中的倒数第k个节点(新浪面试)
-
单链表的反转(腾讯面试)
-
从尾到头打印单链表(百度 要求:反向遍历,Stack栈)
1:求单链表中节点的个数(也就是有效节点的个数)
求一个链表的节点的个数,我们先创建一个链表,并且添加X个节点,然后获取节点个数
这里要注意:此链表是否有头节点
首先,创建一个链表,先给他定义一个节点,重写一下该节点的toString方法,方便显示,如果给成private私有变量,则需要加get、set方法,我这里用的是public,就不需要了
//定义HeroNode,每个HeroNode对象就是一个节点
class HeroNode{
public int no;
public String name;
public String nickname;
public HeroNode next; //指向下一个节点
//构造器
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//为了显示方便,我们重写一下toString方法
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
然后,创建一个链表,并且插入节点,这里呢,提供两种插入节点的方式。第一种没有顺序,即不按照属性no来插入,第二种按照属性no的顺序来插入
class SingleLinkedList{
//先初始化一个头节点,头节点不要动,不存储任何的数据
HeroNode head = new HeroNode(0,"","");
//添加节点到我们的单向链表
//思路:当不考虑顺序时
//1.先找到链表的最后一个节点
//2.将最后这个节点的next指向新的节点
public void addNode(HeroNode heroNode){
//因为head节点不能动,我们需要一个辅助变量temp
HeroNode temp = head;
//遍历链表,找到最后
while(true){
//找到最后一个节点
if(temp.next == null){
break;
}
//如果没有找到,则将temp后移
temp = temp.next;
}
//当退出循环的时候,temp指向了链表最后的节点
temp.next = heroNode;
}
//第二种方式插入节点
//按照英雄排名插入到指定位置,如果有这个排名,则提示插入失败
public void addNode2(HeroNode heroNode){
//因为我们找的temp是位于添加位置的前一个节点,否则添加不了
HeroNode temp = head;
boolean flag = false; //flag标志添加的编号是否存在,默认为false
while(true){
if(temp.next == null){ //说明temp已经在链表的最后
break;
}
if(temp.next.no > heroNode.no){ //位置已找到
break;
}else if(temp.next.no == heroNode.no){ //说明要添加的heroNode的no已存在于链表中
flag = true; //说明编号存在
break;
}
temp = temp.next; //后移,遍历当前链表
}
if(flag){ //如果flag为真,则说明heroNode.no已存在,打印提示信息
System.out.println("添加失败!此英雄的编号"+heroNode.no+"存在");
}else{
//插入到链表中,temp后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
}
最后,我们呢测试一下:
public class SingleLinkedListTest {
public static void main(String[] args){
//创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "无用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
//创建链表
SingleLinkedList list = new SingleLinkedList();
//加入节点,第一种方式,不按照顺序
// list.addNode(hero1);
// list.addNode(hero4);
// list.addNode(hero2);
// list.addNode(hero3);
//第二种方式,按照顺序
list.addNode2(hero1);
list.addNode2(hero4);
list.addNode2(hero2);
list.addNode2(hero3);
System.out.println(list.getLength(list.head));
}
}
结果展示:我们确实在测试案例里面添加了四个节点
注意:如果需要测试,新建一个SingleLinkedListTest类,也就是上文的测试类,然后将前面的两页代码按照顺序,copy至这个(SingleLinkedListTest)类下面。就Ok啦,,,欢迎大家提问!
2、查找单链表中的倒数第k个节点(新浪面试)
思路:
(1),编写一个方法,接收head节点,并且接收一个index
(2),index表示是倒数第index个节点
(3),先把链表从头遍历,得到链表的长度(length),
(4),得到 size(length) 后,我们从链表的第一个元素开始遍历(size-index)个
(5),如果找到了,则返回该节点,如果找不到,则给出提示:未查到该节点
//查找单链表中的倒数第k个节点
/*思路:
(1),编写一个方法,接收head节点,并且接收一个index
(2),index表示是倒数第index个节点
(3),先把链表从头遍历,得到链表的长度(length),
(4),得到 size(length) 后,我们从链表的第一个元素开始遍历(size-index)个
(5),如果找到了,则返回该节点,如果找不到,则给出提示:未查到该节点
* */
public HeroNode getLastIndexNode(HeroNode head,int index){
if(head.next == null){
return null;
}
//第一次遍历,得到链表节点的个数
int size = getLength(head); //此处方法为上一个题目,
//第二次遍历,遍历到size-index
//先做一个index的校验
if(index <= 0 || index > size){ //index的取值要合法合理
return null;
}
//定义一个辅助变量,for循环定位到倒数的index
HeroNode temp = head.next;
for(int i = 0; i < size-index; i++){
temp = temp.next;
}
return temp;
}
测试就一句话,在主方法上加上就行
//测试一下查找单链表中的倒数第k个节点
System.out.println(list.getLastIndexNode(list.head, 2));
测试结果:
3.单链表的反转(腾讯面试)
思路:
(1)、先定义一个节点reverseHead = new HeroNode();
(2)、从头到尾遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表的最前端
(3)、原来的链表的head.next = reverseHead
代码实现:
创建链表,添加节点,显示链表参考博客最前面,都有,下面为反转的方法
//单链表的反转
public void reverseList(HeroNode head){
//做个判断,如果此单链表为空或者一个节点,则直接返回
if(head.next == null || head.next.next == null){
return ;
}
//定义一个辅助变量,帮助我们遍历原来的链表
HeroNode temp = head.next;
HeroNode next = null; //指向当前节点[temp]的下一个节点
HeroNode reverseHead = new HeroNode(0,"","");
//遍历原来的链表
//每遍历一个节点,就将其取出,并放在新的链表reverseList的最前端
while(temp != null){
next = temp.next; //暂时保留当前节点的下一个节点,后面要使用
temp.next = reverseHead.next; //将temp的下一个节点指向新的链表的最前端
reverseHead.next = temp; //将temp连接到新的链表上
temp = next; //让temp后移
}
//将head.next reverseHead.next,实现单链表的反转
head.next = reverseHead.next;
}
测试:
//测试单链表的反转
System.out.println("原来的链表:");
list.showList(); //原来的链表
System.out.println("反转之后的链表:");
list.reverseList(list.head);
结果展示:
4.从尾到头打印单链表(百度 要求:反向遍历,Stack栈)
方式一:先将单链表反转,再打印即可,但是这样会破坏原始链表的结构,不建议
方式二:利用栈这个数据结构,将各个节点压入栈中,栈先进后出的特点,就实现了逆序打印
//从尾到头打印单链表(百度 要求:反向遍历,Stack栈)
//方式二:利用栈这个数据结构,将各个节点压入栈中,栈先进后出的特点,就实现了逆序打印
public void reversePrint(HeroNode head){
//做个判断,如果此单链表为空或者一个节点,则直接返回
if(head.next == null){
return ;
}
Stack<HeroNode> stack = new Stack<HeroNode>();
HeroNode temp = head.next;
while (temp != null){
stack.push(temp);
temp = temp.next;
}
while(stack.size()>0){
System.out.println(stack.pop());
}
}
测试:
System.out.println("原来的链表");
list.showList();
System.out.println("=====================");
//逆序打印单链表
System.out.println("逆序打印的链表:");
list.reversePrint(list.head);
结果展示:实现了
关于单链表的全部的代码如下:包括增删改查,以及四道面试题
package LinkedList;
import java.util.Stack;
//单链表的实现
public class SingleLinkedListTest {
public static void main(String[] args){
//创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "无用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
//创建链表
SingleLinkedList list = new SingleLinkedList();
//加入节点,第一种方式,不按照顺序
// list.addNode(hero1);
// list.addNode(hero4);
// list.addNode(hero2);
// list.addNode(hero3);
//第二种方式,按照顺序
list.addNode2(hero1);
list.addNode2(hero4);
list.addNode2(hero2);
list.addNode2(hero3);
//测试单链表的反转
// System.out.println("原来的链表:");
// list.showList(); //原来的链表
// System.out.println("反转之后的链表:");
// list.reverseList(list.head);
System.out.println("原来的链表");
list.showList();
System.out.println("=====================");
//逆序打印单链表
System.out.println("逆序打印的链表:");
list.reversePrint(list.head);
//显示链表
System.out.println("=============================");
list.showList();
//测试修改节点
HeroNode heroNode = new HeroNode(2, "玉麒麟", "卢俊义");
list.update(heroNode);
System.out.println("=========================");
//显示修改之后的链表
list.showList();
System.out.println("========================");
list.deleteNode(1); //删除节点1
list.showList();
//测试这个链表中有几个有效节点
System.out.println(list.getLength(list.head));
//测试一下查找单链表中的倒数第k个节点
System.out.println(list.getLastIndexNode(list.head, 2));
}
}
//定义一个SingleLinkedList来管理我们的Hero
class SingleLinkedList{
//先初始化一个头节点,头节点不要动,不存储任何的数据
HeroNode head = new HeroNode(0,"","");
//添加节点到我们的单向链表
//思路:当不考虑顺序时
//1.先找到链表的最后一个节点
//2.将最后这个节点的next指向新的节点
public void addNode(HeroNode heroNode){
//因为head节点不能动,我们需要一个辅助变量temp
HeroNode temp = head;
//遍历链表,找到最后
while(true){
//找到最后一个节点
if(temp.next == null){
break;
}
//如果没有找到,则将temp后移
temp = temp.next;
}
//当退出循环的时候,temp指向了链表最后的节点
temp.next = heroNode;
}
//第二种方式插入节点
//按照英雄排名插入到指定位置,如果有这个排名,则提示插入失败
public void addNode2(HeroNode heroNode){
//因为我们找的temp是位于添加位置的前一个节点,否则添加不了
HeroNode temp = head;
boolean flag = false; //flag标志添加的编号是否存在,默认为false
while(true){
if(temp.next == null){ //说明temp已经在链表的最后
break;
}
if(temp.next.no > heroNode.no){ //位置已找到
break;
}else if(temp.next.no == heroNode.no){ //说明要添加的heroNode的no已存在于链表中
flag = true; //说明编号存在
break;
}
temp = temp.next; //后移,遍历当前链表
}
if(flag){ //如果flag为真,则说明heroNode.no已存在,打印提示信息
System.out.println("添加失败!此英雄的编号"+heroNode.no+"存在");
}else{
//插入到链表中,temp后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//修改节点的信息,根据编号(no)来修改
public void update(HeroNode newHeroNode){
//判断是否为空
if(head.next == null){
System.out.println("链表为空!");
return;
}
//找到需要修改的节点,根据编号no
//定义一个辅助变量,来帮助我们遍历寻找节点
HeroNode temp = head.next;
boolean flag = false; //表示是否找到该节点
while(true){
if(temp == null){ //表示链表已经遍历完毕
break;
}
if(temp.no == newHeroNode.no){
flag = true; //说明找到了要修改的节点
break;
}
temp = temp.next;
}
//根据flag来判断是否找到这个节点
if(flag){
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
}else { //没有找到修改的节点的no
System.out.println("没有找到此编号的节点"+temp.no);
}
}
//删除节点
//head节点不能动,因此我们需要一个辅助节点temp,帮助我们找到待删除节点的前一个节点
//说明:我们在比较时是temp.next.no和需要删除的节点的no比较
public void deleteNode(int no){
HeroNode temp = head;
boolean flag = false; //代表是否找到待删除节点的前一个节点
while(true){
if(temp.next == null){ //已经到链表的最后了
break;
}
if(temp.next.no == no){ //找到待删除节点的前一个节点
flag = true;
break;
}
temp = temp.next; //temp后移,遍历
}
if(flag){ //找到
temp.next = temp.next.next;
}else{
System.out.println("要删除的这个节点不存在!");
}
}
//显示链表:通过一个辅助变量,帮助遍历整个单链表
public void showList(){
//判断链表是否为空
if(head.next == null){
System.out.println("链表为空!");
return;
}
//因为头节点不能动,因此我们需要一个辅助变量来遍历
HeroNode temp = head.next;
while(true){
//判断什么时候遍历完链表
if(temp == null){
break;
}
System.out.println(temp);
temp = temp.next;
}
}
//获取有效节点的个数(如果带头节点,不需要统计头节点)
//head:头节点
public 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),先把链表从头遍历,得到链表的长度(length),
(4),得到 size(length) 后,我们从链表的第一个元素开始遍历(size-index)个
(5),如果找到了,则返回该节点,如果找不到,则给出提示:未查到该节点
* */
public HeroNode getLastIndexNode(HeroNode head,int index){
if(head.next == null){
return null;
}
//第一次遍历,得到链表节点的个数
int size = getLength(head);
//第二次遍历,遍历到size-index
//先做一个index的校验
if(index <= 0 || index > size){ //index的取值要合法合理
return null;
}
//定义一个辅助变量,for循环定位到倒数的index
HeroNode temp = head.next;
for(int i = 0; i < size-index; i++){
temp = temp.next;
}
return temp;
}
//单链表的反转
public void reverseList(HeroNode head){
//做个判断,如果此单链表为空或者一个节点,则直接返回
if(head.next == null || head.next.next == null){
return ;
}
//定义一个辅助变量,帮助我们遍历原来的链表
HeroNode temp = head.next;
HeroNode next = null; //指向当前节点[temp]的下一个节点
HeroNode reverseHead = new HeroNode(0,"","");
//遍历原来的链表
//每遍历一个节点,就将其取出,并放在新的链表reverseList的最前端
while(temp != null){
next = temp.next; //暂时保留当前节点的下一个节点,后面要使用
temp.next = reverseHead.next; //将temp的下一个节点指向新的链表的最前端
reverseHead.next = temp; //将temp连接到新的链表上
temp = next; //让temp后移
}
//将head.next reverseHead.next,实现单链表的反转
head.next = reverseHead.next;
}
//从尾到头打印单链表(百度 要求:反向遍历,Stack栈)
//方式二:利用栈这个数据结构,将各个节点压入栈中,栈先进后出的特点,就实现了逆序打印
public void reversePrint(HeroNode head){
//做个判断,如果此单链表为空或者一个节点,则直接返回
if(head.next == null){
return ;
}
Stack<HeroNode> stack = new Stack<HeroNode>();
HeroNode temp = head.next;
while (temp != null){
stack.push(temp);
temp = temp.next;
}
while(stack.size()>0){
System.out.println(stack.pop());
}
}
}
//定义HeroNode,每个HeroNode对象就是一个节点
class HeroNode{
public int no;
public String name;
public String nickname;
public HeroNode next; //指向下一个节点
//构造器
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//为了显示方便,我们重写一下toString方法
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}