单链表

最新推荐文章于 2022-08-25 20:39:04 发布

至安生

最新推荐文章于 2022-08-25 20:39:04 发布

阅读量144

点赞数

分类专栏：数据结构文章标签：数据结构 java 面试

本文链接：https://blog.csdn.net/qq_52672250/article/details/114993697

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

单链表（Linked List）

小结：

链表是以结点的方式来存储。
每个结点包含data域，next域：指向下一结点。
链表的各个结点不一定是连续存储的。
链表分带结点的和不带结点的链表，根据实际的需求确定。

实际存储情况不是连续存储的，而通过逻辑结构看是连续的。

在这里插入图片描述

第一种情况：只添加，不进行排序

package linkedlist;

public class SingleLinkedListDemo {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//进行测试，先创建结点
		HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
		HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
		HeroNode hero3 = new HeroNode(3,"吴用","智多星");
		HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
		//加入
		//创建一个链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		singleLinkedList.add(hero1);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero3);
		singleLinkedList.add(hero4);
		//显示一次
		singleLinkedList.list();		
	}
}
//定义SingleLinkedList管理我们的英雄，
class SingleLinkedList{
	//先初始化一个头节点，头节点不要动，不放具体的数据
	private HeroNode head = new HeroNode(0,"","");
	
	//添加结点到单向链表
	//思路，当先不考虑编号顺序时
	//1.找到当前结点的最后结点
	//2.将最后这个结点的next指向新的结点。
	public void add(HeroNode heroNode) {
		HeroNode temp = head;
		//遍历链表，找到最后
		while(true) {
			//找到链表的最后
			if(temp.next == null) {
				break;
			}
			//如果没有找到，九江temp后移
			temp=temp.next;
		}
		//当退出while循环后，temp就指向了链表的最后。
		temp.next = heroNode;
	}
	
	//显示遍历，通过辅助变量，head结点不能动
	public void list() {
		//判断链表是否为空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		//因为头结点，不能动，因此我们需要一个辅助变量遍历
		HeroNode temp = head.next;
		while(true) {
			//判断是否到了最后
			if(temp == null) {
				break;
			}
			//输出结点信息
			System.out.println(temp);
			//将next后移
			temp = temp.next;
		}
		
	}
}

//定义一个HeroNode，每一个HeroNode就是一个结点。
class HeroNode{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;//指向下一个结点
	//构造器,并且为了显示方便，我们重新toSting
	public HeroNode(int no,String name,String nickname) {
		this.no=no;
		this.name=name;
		this.nickname=nickname;
	}
	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}
	
}

遇到的问题：

在编写代码中有一处逻辑不对导致出现运行不了，空指针错误。错误如下：

Exception in thread "main" java.lang.NullPointerException
	at linkedlist.SingleLinkedList.add(SingleLinkedListDemo.java:44)
	at linkedlist.SingleLinkedListDemo.main(SingleLinkedListDemo.java:15)

//错误代码如下
public void add(HeroNode heroNode) {
		HeroNode temp = head;
		//遍历链表，找到最后
		while(true) {
			//找到链表的最后
			if(temp == null) {
				break;
			}
			//如果没有找到，就将temp后移
			temp=temp.next;
		}
		//当退出while循环后，temp就指向了链表的最后。
		temp.next = heroNode;
	}

//经过检查看提示主要错误的地方在temp.next = heroNode;但是对代码查看并没有错误。并且可以确定代码在15位置，即add方法。
//随后不对添加数据对代码测试，发现没有错误正常输出，经过一步一步走，发现有一处逻辑错误写错。
//错误原因：并不是在当前结点为空时判断链表为空，因为该链表是有头节点的链表，所以头节点为空，所以当链表为空时无论是头节点还
//是头节点的下一个结点判断为空都是一样的，所以当有结点加入时，辅助结点并没有后移，所以在第一次循环中，进行了temp=temp.next;
//当跳出循环后执行temp.next = heroNode;语句，temp是为空的，所以报空指针异常。

public void add(HeroNode heroNode) {
		HeroNode temp = head;
		//遍历链表，找到最后
		while(true) {
			//找到链表的最后
			if(temp.next == null) {
				break;
			}
			//如果没有找到，九江temp后移
			temp=temp.next;
		}
		//当退出while循环后，temp就指向了链表的最后。
		temp.next = heroNode;
	}

第二种：添加，并且要进行排序

注意：辅助指针必须是添加到插入结点的前一个结点，找到后面加不进。因为要对上插入结点的上一个结点。

package linkedlist;

public class SingleLinkedListDemo {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//进行测试，先创建结点
		HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
		HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
		HeroNode hero3 = new HeroNode(3,"吴用","智多星");
		HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
		//加入
		//创建一个链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		singleLinkedList.addByOrder(hero1);
		singleLinkedList.addByOrder(hero3);
		singleLinkedList.addByOrder(hero4);
		singleLinkedList.addByOrder(hero2);
		singleLinkedList.addByOrder(hero2);
	
		//显示一次
		singleLinkedList.list();		
	}
}
//定义SingleLinkedList管理我们的英雄，
class SingleLinkedList{
	//先初始化一个头节点，头节点不要动，不放具体的数据
	private HeroNode head = new HeroNode(0,"","");
	//通过编号进行排序添加
	//通过一个布尔变量去当相同编号时，给出提示。
	public void addByOrder(HeroNode heroNode) {
		HeroNode temp = head;
		boolean flag = false;//做一个标识
		while(true) {
			if(temp.next == null) {//说明temp已经在最后面
				break;//
				
			}
			if(temp.next.no > heroNode.no) {//位置已经找到，就在temp的后面加入
				break;
			}else if(temp.next.no == heroNode.no) {//说明希望添加的和肉Node的编号已经存在
				
				flag = true;
				break;
			}
			temp = temp.next;//后移一位
		}
		//判断flag的值，如果为真，不可添加，说明编号存在，
		if(flag) {
			System.out.println("添加的编号存在，不可添加"+heroNode.no);
		}else {
			//插入链表中
			heroNode.next = temp.next ;
			temp.next = heroNode;
		}
	}
	
	//显示遍历，通过辅助变量，head结点不能动
	public void list() {
		//判断链表是否为空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		//因为头结点，不能动，因此我们需要一个辅助变量遍历
		HeroNode temp = head.next;
		while(true) {
			//判断是否到了最后
			if(temp == null) {
				break;
			}
			//输出结点信息
			System.out.println(temp);
			//将next后移
			temp = temp.next;
		}
		
	}
}
//定义一个HeroNode，每一个HeroNode就是一个结点。
class HeroNode{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;//指向下一个结点
	//构造器,并且为了显示方便，我们重新toSting
	public HeroNode(int no,String name,String nickname) {
		this.no=no;
		this.name=name;
		this.nickname=nickname;
	}
	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}
}

//控制台输出结果
添加的编号存在，不可添加2
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=林冲, nickname=豹子头]

总结在内存将顺序排好，比在数据库排好效率更高。

链表修改（编号不变，信息修改）

	//修改结点信息，根据no编号来改，即no编号不能改，改了的话相当于是添加信息。
	//1.根据newHeroNode的no来修改
	public void update(HeroNode newHeroNoder) {
		//判断链表是否为空
		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 == newHeroNoder.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		//根据flag判断是否找到要修改的结点、
		if(flag) {
			temp.name= newHeroNoder.name;
			temp.nickname= newHeroNoder.nickname;
		}else {
			System.out.println("所要修改的结点不存在");
		}
		
	}

删除链表

//自己思路（删除链表）
//删除结点
	//首先判断链表是否为空
	//不为空，进行查找。
	public void delete(HeroNode deHeroNode) {
		if(head.next == null) {//链表为空
			System.out.println("链表为空");
		}
		HeroNode temp = head;//辅助变量进行查找
		boolean flag = false;
		while(true) {
			if(temp.next.no == deHeroNode.no) {//找到了需要删除的结点
				flag = true;
				break;
			}
			if(temp.next == null) {//表示并不存在当前结点				
				break;
			}
			temp = temp.next;
		}
		if(flag) {//删除结点
			temp.next=temp.next.next;
		}else {//
			System.out.println("不存在当前结点"+deHeroNode);
		}
		
	}

		//主方法代码
		HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
		HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
		HeroNode hero3 = new HeroNode(3,"吴用","智多星");
		HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
		//加入
		//创建一个链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();	
		singleLinkedList.addByOrder(hero1);
		singleLinkedList.addByOrder(hero3);
		singleLinkedList.addByOrder(hero4);
		singleLinkedList.addByOrder(hero2);
		HeroNode hero5 = new HeroNode(5,"林冲","豹子头");
		singleLinkedList.update(hero5);
		HeroNode hero6 = new HeroNode(3,"吴用","智多星");
		singleLinkedList.delete(hero6);
		//显示一次
		singleLinkedList.list();

//运行结果：
所要修改的结点不存在
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=4, name=林冲, nickname=豹子头]

删除结点思路：

1.我们首先找到需要删除的这个结点的前一个结点的temp

2.temp.next = temp.next.next

3.被删除的结点，将不会有其他的引用指向，会被垃圾回收机制回收

//删除结点
	//思路
	//1.head结点不能动，因此我们需要一个辅助结点找到待删除的结点的no比较
	//2.说明我们在比较时，是temp.next.no和删除的结点的no比较
	public void del(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;
		}
		if(flag) {
			//可以删除
			temp.next=temp.next.next;
		}else {
			System.out.printf("要删除的结点%d不存在",no);
		}
	}

单链表面试题

1.求单链表中节点的个数

2.查找单链表中的倒数第K个节点（新浪面试题）

3.单链表的反转（腾讯面试题）

4.从尾打印单链表（要求一：反向遍历、要求二：Stack栈）

5.合并两个有序的单链表，合并之后依然有序。（课后练习）

	//面试题1.求单链表中节点的个数
	public static int getLength(HeroNode head) {
//		return
		if(head.next == null) {
			return 0;
		}
		int length = 0;
		HeroNode cur = head.next;
		while(cur!=null) {
			length++;
			cur=cur.next;
		}
		return length;
	}

//2.查找单链表中的倒数第K个节点（新浪面试题）
//自己思路，可以先将总数求出，在求第K个
//老师思路：1.编写一个方法接收head结点，2.同时接收一个index，
// 3.index表示倒数第index个结点4.从头到尾遍历得到长度getLength,得到size，遍历size-index个
//如果找到返回该结点，否则返回空
	public static HeroNode findLastIndexNode(HeroNode head,int index) {
		if(head.next ==null) {
			return null;
		}
		//第一遍得到链表的长度
		int size = getLength(head);
		//第二遍遍历，size-index位置，就是我们倒数的位置
		//先做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;
	}

//结果
//测试得到倒数的结点
HeroNode res = findLastIndexNode(singleLinkedList.getHead(),1);
System.out.println("查找的倒数节点："+1+" "+res);
//console:
查找的倒数节点：1 HeroNode [no=4, name=林冲, nickname=豹子头]
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=林冲, nickname=豹子头]

//3.单链表的反转。双指针可以吗？一个指头一个指尾？好像不可以，因为如果将其使用两个节点的话，其next的指向无法准确判断。
//老师思路：1.定义一个节点，reverseHead=new HeroNode();2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，放在新链表的
//前端3.原来的链表的next指向新链表的头结点的next，使用的是头插法
	public static void reversetList(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;//暂时保存当前节点的下一个节点
			System.out.println("头结点的"+head.next);
			//头插步骤
			cur.next =reverseHead.next;//将cur的下一个节点指向新的链表的最前端。
			reverseHead.next = cur;
			//头插结束
			cur = next;//让cur后移	
		}
		//将head.next指向reverseHead.next
		head.next = reverseHead.next;		
	}    

//console
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=林冲, nickname=豹子头]
反转结果
HeroNode [no=4, name=林冲, nickname=豹子头]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=1, name=宋江, nickname=及时雨]
    
 //其中在代码的编写中，虽然根据代码的思路协处理啊，但在一开始的时候，并没有理解next的存在的意义，后面通过自己的画图的理解
 //发现next只是为了将下一个节点保存下来，因为在进行新链表的链接当中，cur.next的指针域是指向的新表的头节点的下一位，所以是为了
 //重新找到下一个节点。

不适当的错误示例

在这里插入图片描述

//面试4：1.反转打印，存在问题;对方只是需要逆序打印，没有说破坏链表的结构，如果链表大，如果对方说还要在顺序打印，那么非常浪费空
//间，并且效率也不高，所以不建议。比如逆序打印后又顺序打印。
//2.利用栈的先进后出实现逆序打印。
	//面试4，使用栈的思路打印逆序，Stack中add添加数据，pop取出栈顶的数据
	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.add(cur);
			cur = cur.next;
		}
		//将栈中的节点进行打印，pop出栈
		while(stack.size()>0) {
			//stack的特点先进后出
			System.out.println(stack.pop());
		}	
	}

至安生

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
单链表

单链表（Linked List）小结：链表是以结点的方式来存储。每个结点包含data域，next域：指向下一结点。链表的各个结点不一定是连续存储的。链表分带结点的和不带结点的链表，根据实际的需求确定。实际存储情况不是连续存储的，而通过逻辑结构看是连续的。第一种情况：只添加，不进行排序package linkedlist;public class SingleLinkedListDemo { public static void main(String[] args) {
复制链接

扫一扫

专栏目录