单链表的面试题
先定义单链表，代码实现：
public class SingleLinked {
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(2, "余生", "遵纪守法");
SingleLinkedList singleLinkedList=new SingleLinkedList();
// 添加节点
singleLinkedList.addOrder(hero3);
singleLinkedList.addOrder(hero1);
singleLinkedList.addOrder(hero2);
// 显示链表数据
singleLinkedList.list();
// 删除节点信息
// singleLinkedList.delete(2);
// System.out.println("删除后的的链表");
// singleLinkedList.list();
System.out.println(getLength(singleLinkedList.getHead()));
}
//求单链表中有效节点的个数
public static int getLength(HeroNode head){
if(head.next==null){
return 0;
}
HeroNode temp=head.next;
int length=0;
while(true){
if(temp==null){
return length;
}
length++;
temp=temp.next;
}
}
}
// 定义一个LinkedList来管理HeroNode
class SingleLinkedList{
// 先初始化头节点，head节点不能动,也不能放其他具体信息
HeroNode head=new HeroNode(0,"","");
// 添加节点到单链表
// 思路：不考虑编号顺序问题的话首先遍历到链表的最后，让最后节点的next指向新的节点
public void add(HeroNode heroNode){
// 创建一个辅助变量来遍历链表（因为head头节点不能改变）
HeroNode temp=head;
while(true){
// 找到链表的最后
if(temp.next==null){
break;
}
// 如果链表没有到最后，那么temp需要后移
temp=temp.next;
}
// 当循环退出之后，证明链表到最后了
// 将这个最后节点的next指向新节点
temp.next=heroNode;
}
//按照no顺序添加节点
public void addOrder(HeroNode heroNode){
HeroNode temp=head;
// 作为是否已经存在no相等的节点
boolean flag=false;
// 循环链表
while(true){
if(temp.next==null){
break;
}
//查找新节点在哪
if(temp.next.no>heroNode.no){ // 位置找到了在temp后面添加新节点
break;
}
if(temp.next.no==heroNode.no){ //编号已经存在，不能添加
flag=true;
break;
}
// temp后移
temp=temp.next;
}
if(flag){
System.out.println("该编号已经存在"+ heroNode.no+"，不能添加该节点");
}else{
// 先把temp指向的下一个节点让新节点指向
heroNode.next=temp.next;
// 后temp指向的下一个节点设置为新节点
temp.next=heroNode;
}
}
//修改节点的信息，通过no来修改即no是唯一的
public void update(HeroNode heroNode){
// 首先判断链表是否为空
if(head.next==null){
System.out.println("链表为空");
return;
}
// 找到需要修改的节点
HeroNode temp=head.next;
boolean flag=false;
while(true){
if(temp==null){
break;
}
if(heroNode.no==temp.no){
flag=true;
break;
}
temp=temp.next;
}
if(flag){
temp.name=heroNode.name;
temp.nickName=heroNode.nickName;
}else{
System.out.println("未找到相对应的节点信息");
}
}
//删除节点
public void delete(int no){
if(head.next==null){
return;
}
HeroNode temp=head;
boolean flag=false;
while(true){
if(temp.next==null){
break;
}
// 找到要删除节点的前一个节点
if(temp.next.no==no){
flag=true;
break;
}
temp=temp.next;
}
if(flag){
// 让要删除的节点的前一个节点指向要删除节点的后一个节点
temp.next=temp.next.next;
}else{
System.out.println("未找到相对应的no节点");
}
}
//返回链表的head
public HeroNode getHead(){
return head;
}
//显示链表
public void list(){
// 首先判断链表是否为空
if(head.next==null){
System.out.println("链表为空~~~");
return;
}
// 创建一个辅助变量来遍历链表（因为head头节点不能改变）
HeroNode temp=head.next;
while (true){
if(temp==null){
System.out.println("链表遍历完了~~~");
break;
}
// 输出节点信息
System.out.println(temp.toString());
// 后移
temp=temp.next;
}
}
}
// 定义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 +
'}';
}
}
1、求单链表中有效节点的个数
1）在SingleLinkedList中创建一个返回head节点的方法
//返回链表的head
public HeroNode getHead(){
return head;
}
2）在SingleLinked类中创建得到单链表中有效节点的个数方法
//求单链表中有效节点的个数
public static int getLength(HeroNode head){
if(head.next==null){
return 0;
}
HeroNode temp=head.next;
int length=0;
while(true){
if(temp==null){
return length;
}
length++;
temp=temp.next;
}
}
2、查找单链表中倒数第k个节点
思路：既然想查找单链表中倒数第k个节点，我就先计算出单链表中的有效节点总数size，即是查找单链表中第size-k+1个节点
// 查找单链表中倒数第k个节点
public static HeroNode getLastIndexNext(HeroNode head,int index){
// 判断单链表是否为空
if(head.next==null){
return null;
}
// 获取单链表中的有效节点个数
int size=getLength(head);
// 校验index
if(index<0||index>size){
return null;
}
// 查找倒数第k个节点，相当于查找第size-k+1个节点
//这种写法 先让cur指向第一个节点，需要循环size-index+1次
HeroNode cur=head;
for(int i=1;i<=size-index+1;i++){
cur=cur.next;
}
// 这种写法 先让curr指向第二个节点即curr就是第一个节点,只需要循环size-index次
// HeroNode curr=head.next;
// for(int i=1;i<=size-index;i++){
// curr=curr.next;
// }
return cur;
}
3、单链表的反转
思路：假如链表heroHead有三个节点，就是把最后节点的下一个节点指向变为倒数第二个节点，head节点指向最后一个节点，依次类推。
创建一个新链表，还有temp为head.next，当把第一个节点赋值到新链表的时候，如果没有一个值来保存第一个节点的下一个节点，那么链表就会断层，所以在赋值之前，先把要赋值节点的下一个节点保存在t中，然后再把节点赋值给新链表，添加第二个节点时，就是把第三个节点保存在t中，然后新链表的头节点的指向赋值给指向temp的下一个节点，然后新链表的头节点指向temp节点，temp后移，循环结束后，head.next=reverseHead.next
// 单链表的反转
public static void reversetList(HeroNode head){
// 将原来的单链表依次取出放入一个新的单链表
if(head.next==null||head.next.next==null){
return;
}
// 定义一个辅助的变量，帮助我们遍历原来的链表
HeroNode temp=head.next;
HeroNode reverseHead=new HeroNode(0,"","");
// 指向当前节点temp的下一个节点
HeroNode t=null;
// 遍历原来的链表，每遍历一个节点，就将其取出，并放在新链表reverseHead的最前端
while(temp!=null){
t=temp.next; // 先暂时保存当前节点的下一个节点
temp.next=reverseHead.next; // 将temp的下一个节点指向新的链表的第一个节点
reverseHead.next=temp; // 将新链表的头结点指向temp节点
temp=t; // temp后移
}
head.next=reverseHead.next;
}
4、从尾到头打印单链表
这个可以利用第3题的反转方法进行操作
5、合并两个有序单链表，合并之后的链表仍然有序
思路：先判断两个单链表是否为空，如果都为空就不需要合并，如果一个单链表为空，则也不需要合并，我创建一个空的链表3，首先把链表1的节点存入链表3，直接让链表3的头结点指向链表1的头结点指向的节点就行了。然后遍历链表2，在遍历链表2中，遍历链表3，在链表3中找到第一个大于链表2中节点编号的节点，找到的节点时位于添加位置的前一个节点，如果链表3遍历完了还没有找到，就直接放在链表3的最后。
// 合并两个有序的单链表，合并之后的链表依然有序
public static void mergeNode(HeroNode head1,HeroNode head2,HeroNode head3){
// 如果两个链表均为空，则无需合并
if(head1.next==null&&head2.next==null){
return;
}
HeroNode temp1=head1.next;
// 将链表1的节点连接到链表3
head3.next=temp1;
// 定义一个辅助变量，帮助我们遍历链表2
HeroNode temp2=head2.next;
// 定义一个辅助变量，帮助我们遍历链表3
HeroNode temp3=head3.next;
//
HeroNode temp=null;
while(temp2!=null){
// 链表3遍历完之后，可以将剩下链表2的节点连接到链表3的末尾
if(temp3==null){
temp3.next=temp2;
break;
}
// 在链表3中，找到第一个大于链表2中的节点编号的节点
// 因为是单链表，找到的节点是位于添加位置的前一个节点，否则无法插入
if(temp2.no<=temp3.next.no){
temp=temp2.next; // 先暂时保存链表2中中当前节点的下一个节点，方便后续使用
temp2.next=temp3.next; // 将head2的下一个节点指向head3的下一个节点
temp3.next=temp2; // 将temp2连接链表3上
temp2=temp; // 让head2后移
}
// 后移temp3(遍历链表3)
temp3=temp3.next;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
