单链表(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());
}
}