java 单链表是什么算法,java 数据结构单链表之算法

1. 链表的介绍

链表时有序的列表，但是它在内存中的存储如下：

1. 链表是以节点的方式来储存的，是链式存储。

2 . 每个节点包括 data域、 next域：指向下一个节点。

3 .  链表的每个节点不一定是连续存储的，如上图所示。

4   链表分为带头节点的链表 和不带头节点的链表。

带头节点的单链表的逻辑结构示意图如下：

2. 单链表的应用

使用带头节点的单向链表实现： 对水浒传的英雄排行榜进行增删改查。

第一 种方式在添加英雄时，至二级添加到链表的尾部。

具体思路：

1. 首先添加一个head头节点，作用就是表示单链表的头。

2. 后面每添加一个节点，就直接加入到链表的后面。

3. 通过一个辅助变量(指针)遍历整个链表。

代码实现

public class Linkedlist {

public static void main(String[] args) {

//测试。先创建节点

Lnode lnode1=new Lnode(1,"宋江");

Lnode lnode2=new Lnode(2,"卢俊义");

Lnode lnode3=new Lnode(3,"吴用");

Lnode lnode4=new Lnode(4,"林冲");

//创建链表

SingleLinkedList singleLinkedList=new SingleLinkedList();

//向链表中接入元素

singleLinkedList.add(lnode1);

singleLinkedList.add(lnode2);

singleLinkedList.add(lnode3);

singleLinkedList.add(lnode4);

//显示链表

singleLinkedList.list();

}

}

//定义SingleLinkedList单链表，管理我们的英雄

class SingleLinkedList{

//初始化一个头节点，头节点不要动，不存放具体的数据

private Lnode head=new Lnode(0,"");

//添加节点到单向链表

/**

* 思路：在不要考虑节点编号顺序时，

* 1.找到当前链表的最后一个节点

* 2 将最后节点的next指向新的节点

* @param lnode

*/

public void add(Lnode lnode){

//因为链表的头节点不能动，因此需要一个辅助的变量(指针)tmp.

Lnode temp=head;

//遍历链表，找到链表的最后一个节点

while (true){

if(temp.next==null){//链表的最后

break;

}

//如果没有遍历到链表的最后

temp=temp.next;

}

//退出while循环时，已经遍历到了链表的最后，将链表最后的节点指向新的节点就是添加了数据

temp.next=lnode;

}

//遍历链表

public void list(){

//先判断链表是否为空

if(head.next==null){

System.out.println("链表为空");

return;

}

//因为链表的头节点不能动，因此需要一个辅助的变量(指针)tmp.

Lnode temp=head.next;//tmp指向链表的第一个节点

while (true){

if(temp==null){//判断链表是否到了最后一个

break;

}

//输出节点信息

System.out.println(temp);

//将tmp后移

temp=temp.next;

}

}

}

//定义节点

class Lnode{

public int no;

public String name;

public Lnode next;//指向下一个节点

public Lnode(int no, String name) {//构造器时候，不要降next参数传入

this.no = no;

this.name = name;

}

//为了显示方法，重新定义toString

@Override

public String toString() {

return "Lnode{" +

"no=" + no +

", name='" + name + '\'' +

'}';

}

}

第二种方式添加英雄时，根据排名将英雄插入到指定的位置(如果已经有了这个排名，则添加失败，给出提示信息)

思路分析：

需要按照编号的顺序添加英雄。

1. 首先找到新添加的节点的位置，通过辅助变量指针，通过遍历的方式来寻找

2.  新的节点.next = temp.next;

3. temp.next= 新的节点 。

代码实现：

public class Linkedlist {

public static void main(String[] args) {

//测试。先创建节点

Lnode lnode1=new Lnode(1,"宋江");

Lnode lnode2=new Lnode(2,"卢俊义");

Lnode lnode3=new Lnode(3,"吴用");

Lnode lnode4=new Lnode(4,"林冲");

//创建链表

SingleLinkedList singleLinkedList=new SingleLinkedList();

//显示链表

singleLinkedList.list();

//向链表中接入元素

singleLinkedList.addByOrder(lnode1);

singleLinkedList.addByOrder(lnode4);

singleLinkedList.addByOrder(lnode3);

singleLinkedList.addByOrder(lnode2);

System.out.println("按照顺序插入后");

singleLinkedList.list();

}

}

//定义SingleLinkedList单链表，管理我们的英雄

class SingleLinkedList{

//初始化一个头节点，头节点不要动，不存放具体的数据

private Lnode head=new Lnode(0,"");

//添加节点考虑节点的顺序，根据排名的将英雄插入到指定的位置，如果已有排民，则显示添加失败

public void addByOrder(Lnode lnode){

// 因为链表的头节点不能动，因此需要一个辅助的变量(指针)tmp.

//我们遍历的位置是要遍历插入节点的前一个节点，这样才能插入

Lnode temp=head;

Boolean flag=false;//flag标志添加的编号是否存在，默认为false

while (true){

if(temp.next==null){//这是已经遍历到了链表的最后

break;

}

if(temp.no==lnode.no){//要添加的节点的编号已经存在了

flag=true;

break;

}

if(temp.next.no>lnode.no){//要添加的位置找到了

break;

}

temp=temp.next;//后移，遍历当前链表

}

if(flag){//不能添加，说明编号已经存在了

System.out.printf("要插入的节点编号 %d 已经存在了，不能加入\n",lnode.no);

}else {

//插入到链表，temp的后面

lnode.next=temp.next;//新的节点指向temp后面的节点

temp.next=lnode;//temp节点指向新的节点

}

}

//遍历链表

public void list(){

//先判断链表是否为空

if(head.next==null){

System.out.println("链表为空");

return;

}

//因为链表的头节点不能动，因此需要一个辅助的变量(指针)tmp.

Lnode temp=head.next;//tmp指向链表的第一个节点

while (true){

if(temp==null){//判断链表是否到了最后一个

break;

}

//输出节点信息

System.out.println(temp);

//将tmp后移

temp=temp.next;

}

}

}

//定义节点

class Lnode{

public int no;

public String name;

public Lnode next;//指向下一个节点

public Lnode(int no, String name) {//构造器时候，不要降next参数传入

this.no = no;

this.name = name;

}

//为了显示方法，重新定义toString

@Override

public String toString() {

return "Lnode{" +

"no=" + no +

", name='" + name + '\'' +

'}';

}

}

第三： 修改节点的功能

具体思路：

1. 首先找到该节点，通过遍历

2. temp. name=newlnode.neme

代码实现：

//修改节点的信息，根据no的编号来修改，

public void update(Lnode newlnode){

//判断链表是否为空

if(head.next==null){

System.out.println("链表为空");

return;

}

//根据编号no找到需要修改的节点

//定义一个辅助变量

Lnode temp=head.next;

boolean flag=false;//表示是否找到该节点

while (true){

if(temp==null) {//已经遍历完了链表

break;

}

if(temp.no==newlnode.no){

//找到需要修改的

flag=true;

break;

}

temp=temp.next;

}

//根据flag判断是否找到要修改的节点

if(flag){

temp.name=newlnode.name;

}else{

System.out.printf("没有找到编号 %d 的节点，不能修改",newlnode.no);

}

}

第四： 删除节点。

思路分析  ：

从单链表中删除节点。

1. 先找到需要删除节点的前一个节点temp。

2  temp.next = temp.next.next 。

3. 被删除的节点就不会指向其他节点  会被垃圾回收机制回收。

代码实现：

//删除节点

//1.head不能动，因为我们需要一个temp辅助节点找到待删除节点的前一个节点

//2 因此 我们 在寻找删除节点时，是用temp.next.no和需要删除的节点的no进行比较。

public void del(int no){

Lnode temp=head;

Boolean flag=false;//标志找到待删除的节点

while (true){

if(temp.next==null){//已经遍历到链表的最后了

break;

}

if(temp.next.no==no){

//找到了要删除的节点temp

flag=true;

break;

}

temp=temp.next;//temp后移，遍历

}

//判断flag

if(flag){

//找到了要删除的节点

temp.next=temp.next.next;//删除节点

}else {

System.out.printf("要删除的 %d 节点不存在\n",no);

}

}