数据结构小白之单向链表

链表(Linked List)介绍

链表是有序的列表，在内存中存储如下:

简单介绍:

1.链表以节点的方式来存储，属于链式存储
2.每个节点包括data域和next域
3.链表的各个节点不一定是连续存放的
4.链表分为带头节点和不带头节点的，根据实际的需求而定

单向链表介绍

1.逻辑结构:

2.单链表的创建思路:建立一个class，用来创建单向链表的节点

class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int hNo, String hName, String hNickName) {
             this.no = hNo;
            this.name = hName;
            this.nickName = hNickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\''+
                '}';
    }

}

3.单向链表的顺序添加（添加到单向链表的尾部）
*先创建一个head节点，作为单向链表的头部
*建立一个辅助节点temp，遍历到单向链表的尾部的前一个节点，则节点添加到temp.next

public void add(HeroNode heroNode) {
    //因为head节点不能动，因此需要一个辅助变量
    HeroNode temp = head;
    //遍历链表
    while (true) {
        //todo HeroNode temp=head if(temp.next==null)
        //当temp为空 说明找到最后了
        if (temp.next == null) {//
            break;
        }
        //未找到 temp后移
        temp = temp.next;
    }
    //当退出while循环时，temp指向了链表的最后
    temp.next = heroNode;
}

4.单链表的显示
*由于重写了toString方法，通过system.out 可以进行默认调用该方法显示节点信息
*所以只要循环遍历节点即可

//显示链表
public void showList() {
    if (head.next == null) {
        System.out.println("链表为空");
        return;
    }
    //因为头节点不能动，因此我们需要一个辅助变量来遍历
    HeroNode tempNode = head;
    while (true) {
        //是否到链表的最后
        if(tempNode.next==null){
            break;
        }
        //输出节点的信息
        System.out.println(tempNode.next);
        tempNode=tempNode.next;
    }
}

5.按照顺序进行链表的添加
*找到新节点的位置（通过辅助节点遍历）
*新节点.next=temp.next
*temp.next=新节点
*即将新的节点放在temp和temp.next之间

public void addByOrder(HeroNode mHeroNode){
    //头节点不能动，所以通过一个辅助指针找到添加的位置
    //temp是位于添加位置的前一个节点
    HeroNode temp=head;
    Boolean flag=false;//标志添加的编号是否存在
    while(true){
        if(temp.next==null){//temp到了链表的最后
            break;
        }
        if (temp.next.no>mHeroNode.no){//位置找到了 mHeroNode添加到temp和temp.next之间
            break;
        }else if(temp.next.no==mHeroNode.no){//找到位置 但是编号已经存在
            flag=true;
            break;
        }
        temp=temp.next;//后移【遍历当前的链表】
    }
    //flag为真 不能添加
    if(flag){
        System.out.printf("待插入的编号%d已经存在了，不能加入\n",mHeroNode.no);
    }
    else{
        //插入到链表中 temp的后面
        mHeroNode.next=temp.next;
        temp.next=mHeroNode;
    }
}

6.单向链表节点的更改
*通过遍历找到该节点
*通过给定的节点信息进行信息的更新

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;
    }
    if(flag){
        //已经找到了
        temp.name=newHeroNode.name;
        temp.nickName=newHeroNode.nickName;
    }else{
        System.out.printf("没有找到 编号%d 的节点，不能修改\n",newHeroNode.no);
    }
}

7.链表节点的删除
*找到待删除节点的前一个节点
*temp.next=temp.next.next

public void deleteNode(int no){
    if(head.next==null){
        //链表为空
    }
    HeroNode tempNode=head;
    boolean flag=false;
    while(true){
        if(tempNode.next==null){
            System.out.println("遍历结束");
            break;
        }
        if(tempNode.next.no==no){
            //找到了该节点
            //进行节点的删除
            flag=true;
            break;
        }
        tempNode=tempNode.next;
    }
    if(flag){
        //可以删除了
        tempNode.next=tempNode.next.next;
    }else{
        System.out.printf("没有找到 编号%d 的节点，不能修改\n",no);
    }
}

总体代码一栏（包含测试代码）

public class SingleLinkedListDemo {
    /**
     * 单向链表的创建 直接添加到链表的尾部
     * */
    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 singleLinkedList=new SingleLinkedList();
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero3);

        //show
        singleLinkedList.showList();
        //测试修改链表的代码
        System.out.println("链表修改后..");
        HeroNode newHeroNode=new HeroNode(2,"小卢","铁憨憨");
        singleLinkedList.update(newHeroNode);
        singleLinkedList.showList();
        //测试删除
        singleLinkedList.deleteNode(1);
        System.out.println("-------------------------");
        singleLinkedList.showList();
    }
}

//定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int hNo, String hName, String hNickName) {
        this.no = hNo;
        this.name = hName;
        this.nickName = hNickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\''+
                '}';
    }

}

//定义SingleLinkedList用来管理节点
class SingleLinkedList {
    //先初始化一个头节点,不存放具体的数值
    private HeroNode head = new HeroNode(0, "", "");
    //添加节点到单向链表

    /**
     * 当不考虑编号顺序时
     * 1.找到当前节点的最后节点
     * 2.将最后这个节点的next域指向新的节点
     */
    public void add(HeroNode heroNode) {
        //因为head节点不能动，因此需要一个辅助变量
        HeroNode temp = head;
        //遍历链表
        while (true) {
            //todo HeroNode temp=head if(temp.next==null)
            //当temp为空 说明找到最后了
            if (temp.next == null) {//
                break;
            }
            //未找到 temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp指向了链表的最后
        temp.next = heroNode;
    }
    //第二种添加的方式，根据排名来将节点插入到指定的位置内（如果有这个排名则添加失败，并给出提示）
    public void addByOrder(HeroNode mHeroNode){
        //头节点不能动，所以通过一个辅助指针找到添加的位置
        //temp是位于添加位置的前一个节点
        HeroNode temp=head;
        Boolean flag=false;//标志添加的编号是否存在
        while(true){
            if(temp.next==null){//temp到了链表的最后
                break;
            }
            if (temp.next.no>mHeroNode.no){//位置找到了 mHeroNode添加到temp和temp.next之间
                break;
            }else if(temp.next.no==mHeroNode.no){//找到位置 但是编号已经存在
                flag=true;
                break;
            }
            temp=temp.next;//后移【遍历当前的链表】
        }
        //flag为真 不能添加
        if(flag){
            System.out.printf("待插入的编号%d已经存在了，不能加入\n",mHeroNode.no);
        }
        else{
            //插入到链表中 temp的后面
            mHeroNode.next=temp.next;
            temp.next=mHeroNode;
        }
    }
    //修改节点的信息，根据编号来修改信息即no编号不变
    //根据newHeroNode的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;
        }
        if(flag){
            //已经找到了
            temp.name=newHeroNode.name;
            temp.nickName=newHeroNode.nickName;
        }else{
            System.out.printf("没有找到 编号%d 的节点，不能修改\n",newHeroNode.no);
        }
    }
    //删除节点:
    //1.head节点不动
    public void deleteNode(int no){
        if(head.next==null){
            //链表为空
        }
        HeroNode tempNode=head;
        boolean flag=false;
        while(true){
            if(tempNode.next==null){
                System.out.println("遍历结束");
                break;
            }
            if(tempNode.next.no==no){
                //找到了该节点
                //进行节点的删除
                flag=true;
                break;
            }
            tempNode=tempNode.next;
        }
        if(flag){
            //可以删除了
            tempNode.next=tempNode.next.next;
        }else{
            System.out.printf("没有找到 编号%d 的节点，不能修改\n",no);
        }
    }
    //显示链表
    public void showList() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助变量来遍历
        HeroNode tempNode = head;
        while (true) {
            //是否到链表的最后
            if(tempNode.next==null){
                break;
            }
            //输出节点的信息
            System.out.println(tempNode.next);
            tempNode=tempNode.next;
        }
    }

}