浅谈:数据结构之单链表,java代码演示单链表

单链表

本文是观看尚硅谷韩老师视频学习总结,部分来源网络.

单链表介绍

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

单向链表只有一个指针域，在整个节点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的节点。

　　单向链表中，每个节点的数据域都是通过一个 Object 类的对象引用来指向数据元素的，与数组类似，单向链表中的节点也具有一个线性次序，即如果节点 a1 的 next 引用指向节点 a2，则 a1 就是 a2 的直接前驱，a2 是 a1 的直接后续。只能通过前驱节点找到后续节点，而无法从后续节点找到前驱节点。
特点：
　　数据元素的存储对应的是不连续的存储空间，每个存储结点对应一个需要存储的数据元素。每个结点是由数据域和指针域组成。 元素之间的逻辑关系通过存储节点之间的链接关系反映出来。
　　逻辑上相邻的节点物理上不必相邻。
缺点：
1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多)。
2、查找结点时链式存储要比顺序存储慢（每个节点地址不连续、无规律，导致按照索引查询效率低下）。
优点：
1、插入、删除灵活 (不必移动节点，只要改变节点中的指针，但是需要先定位到元素上)。
2、有元素才会分配结点空间，不会有闲置的结点。

单链表Java代码模拟详解,演示单链表的增删改查

分析

按照节点的循序添加分析

按照节点的顺序插入一个节点分析

按照节点数删除某个节点分析图(修改了思路也类似,找到修改的节点,改变其属性即可)

代码(详细解释在代码注释中)

package com.fs.demo_2020_07_12_LinkedList;

/**
 * 单链表 演示
 *
 */
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //测试链表
        //先创建节点
        Node node1 = new Node(1, "节点一");
        Node node2 = new Node(2, "节点二");
        Node node3 = new Node(3, "节点三");
        Node node4 = new Node(4, "节点四");

        //创建链表,将节点(安装顺序)添加进去
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //按照循序添加节点到单项链表
//        singleLinkedList.add(node1);
//        singleLinkedList.add(node2);
//        singleLinkedList.add(node3);
//        singleLinkedList.add(node4);
//        singleLinkedList.add(node4);添加多个同样的节点会无限循环下去,因为next指向的是同一个节点

        //根据节点数的大小将节点插入指定位置
        singleLinkedList.addByOrder(node1);
        singleLinkedList.addByOrder(node4);
        singleLinkedList.addByOrder(node2);
        singleLinkedList.addByOrder(node3);

        //显示一下
        singleLinkedList.showLinkedList();

        System.out.println("--------测试修改节点---------");
        //测试修改节点
        Node newNode = new Node(2, "小付");
        singleLinkedList.updateByNum(newNode);
        System.out.println("修改后的链表显示如下");
        singleLinkedList.showLinkedList();//正常显示,说明根据节点num找到,修改成功

        System.out.println("---------测试删除节点---------------");
        //测试删除节点
        singleLinkedList.delNode(2);
        System.out.println("删除后链表显示如下");
        singleLinkedList.showLinkedList();


    }
}

//创建一个类来模拟单链表
class SingleLinkedList{
    //先初始化一个头节点,头节点不动,不存放具体信息
    private Node headNode = new Node(0,"头结点");

    /*
    一  按照循序添加节点到单项链表
        思路:
            找到当前链表的最后节点
            将最后这个节点next指向新的节点
     */
    public void add(Node node){
        //拿到初始化的头结点,作为辅助遍历temp
        Node temp = headNode;
        //遍历链表
        while (true){
            //由图解得知,单链表当遍历到最后一个节点后,next存储的值为null.因为没有下一个节点可以存储了
            if (temp.next==null){
                //那就停止循环
                break;
            }
            //如果没有找到最后,那就将temp后移一个节点
            temp = temp.next;
        }
        //循环结束后,所明temp到达最后一个节点了,那么就在最后一个节点后添加数据,将temp的next存储添加的节点值
        //将最后这个节点指向新的节点
        temp.next = node;
    }

    /*
    二  根据节点数的大小将节点插入指定位置
     */
    public void addByOrder(Node node){
        //同样,让头结点作为我们辅助遍历
        Node temp = headNode;
        //创建一个标记,默认为false
        boolean flag = false;
        while (true){
            if (temp.next==null){
                //说明已经到最后一个节点,说明就插入到最后一个的后面,循环结束
                break;
            }
            //若插入的节点数小于遍历当前temp的节点数,那么就插入在当前节点数的后面,找到插入位置,循环结束
            if (temp.next.num>node.num){
                break;

                //若当前节点数等于插入的节点数,说明在链表中已经存在这个节点,所以无需添加
                //那么就改变标记true,停止循环
            }else if (temp.next.num == node.num){
                flag = true;
                break;
            }

            //每次循环将当前节点向后移
            temp = temp.next;
        }

        //循环结束后要么是找到了插入的位子,要么就是找到了相同的节点
        if (flag){
            //说明找到了相同的节点,就打印说明
            System.out.println("准备插入的节点数:"+node.num+"已经存在,不能在次插入~~~");
        }else {
            //将temp.next接在node.next
            node.next = temp.next;
            //说明找到了插入的节点位置的,就是在temp后面
            temp.next = node;
        }
    }

    /*
    三  修改节点信息,根据num来修改,但是num不能修改,只能修改num节点的name
     */
    public void updateByNum(Node newNode){
        //还是先判断链表是否为空,判断头部节点的下一位是否为空
        if (headNode.next==null){
            System.out.println("链表为空~~~");
            return;
        }
        //找到需要修改的节点,根据num号
        //定义一个辅助节点,这次就不是头结点了,因为头结点不能更改
        Node temp = headNode.next;
        //立一个flag,表示是否找到这个节点
        boolean flag = false;
        while (true){
            if (temp == null){
                break;//说明已经遍历完了
            }
            if (temp.num == newNode.num){
                //说明找到
                flag = true;
                break;
            }
            //每次循环指针指向下一个
            temp = temp.next;
        }
        //根据flag来判断是否找到要修改的节点
        if (flag){
            //说明找到
            temp.name = newNode.name;
        }else {
            //没有找到
            System.out.println("没有找到编号为:"+newNode.num+"的节点~~~");
        }
    }


    /*
    删除节点
        思路:
            比较的是temp.next.num 与需要删除的节点的num比较
     */
    public void delNode(int num){
        //同样,标志是否摘掉带删除的节点
        Node temp = headNode;
        //立flag
        boolean flag = false;
        while (true){
            if (temp == null){
                //已经到达最后的节点
                break;
            }
            if (temp.next.num == num){
                //说明找到了删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;//循环后移
        }

        //判断flag
        if (flag){
            //说明找到.可以删除
            /*
            temp.next = temp.next.next;
            因为上面是找到了要删除的前一个节点,所以我们只需要将当前节点的next赋值为下下个节点,
            那么就达到了有个节点没有连接上,就会等待java垃圾回收
            假设我们需要删除2,那么上面的逻辑是temp.next.num = 2 的时候,flag为true
            那么temp就是节点1,那么节点1的next设置为下下一个那么就是节点三,那么就变相的将节点2
            移除链表
             */
            temp.next = temp.next.next;

        }else {
            System.out.println("您需要删除的节点:"+num+"在链表中不存在~~~");
        }

    }




    /*
    显示链表,遍历查看
     */
    public void showLinkedList(){
        //判断链表否为空
        if (headNode.next == null){
            System.out.println("链表为空,请添加后查看~~~");
            return;
        }

        //同样,头结点不能动,作为辅助遍历,从头节点的下一位开始显示,头节点不显示
        Node temp = headNode.next;
        while (true){
            //判断是否到最后一个节点了
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }


}




//创建一个类类模拟节点
class Node{
    public int num;//当前节点数
    public String name;//给当前节点取个名字,模拟节点存储的数据
    public Node next;//当前节点存储的下一个节点信息

    //提供构造方法来初始化这个节点信息
    public Node(int num, String name) {
        this.num = num;
        this.name = name;
    }


    @Override
    public String toString() {
        return "Node{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}

运行结果控制台显示

---------添加4个节点(1,2,3,4)------------
Node{num=1, name='节点一'}
Node{num=2, name='节点二'}
Node{num=3, name='节点三'}
Node{num=4, name='节点四'}
--------测试修改节点2的数据---------
修改后的链表显示如下
Node{num=1, name='节点一'}
Node{num=2, name='小付'}
Node{num=3, name='节点三'}
Node{num=4, name='节点四'}
---------测试删除节点2---------------
删除后链表显示如下
Node{num=1, name='节点一'}
Node{num=3, name='节点三'}
Node{num=4, name='节点四'}

单链表的试题案列

 /**
     * 试题,在不改变链表结构的情况下逆序打印输出
     * @param headNode 给一个头结点
     */
    public static void reversePrint(Node headNode){
        //判断是否有下一个
        if (headNode.next == null){
            return;
        }
        //定一个变量的获取
        Node temp = headNode.next;
        //创建一个栈来实现
        Stack<Node> nodes = new Stack<>();
        //循环压栈
        while (temp!=null){
            nodes.push(temp);
            //后移temp,这样就可以压入下一个节点了
            temp = temp.next;
        }
        //将栈中的节点弹栈取出
        while (nodes.size()>0){
            //stack栈的特点就是先进后出
            System.out.println(nodes.pop());
        }
    }



    /**
     * 试题:将链表反转
     * @param headNode 给定一个链表的头节点,让链表反转
     */
    public static void reverseLinkedList(Node headNode){
        //先判断链表是否为空,或者只有一个节点,那么就无需返转headNode.next.next 说明只有一个节点
        if (headNode.next == null || headNode.next.next == null){
            return;
        }
        //定义一个辅助指针,帮助我们遍历原来的链表
        Node temp = headNode.next;//将头结点的下一个节点给这个临时节点
        Node next = null;//定义一个节点,来暂时保存下一个节点,
        Node reverseHead = new Node(0,"反转节点");//创建一个新的头结点,来接反转后的节点
        //遍历原来的链表,没遍历一个节点,将其取出,并放在新的reverseHead 的最前端

        while (temp!=null){
            //当头结点的下一个节点不为null的时候,遍历
            next = temp.next;//先将temp的下一个节点暂时保存在next中,方便后面使用
            temp.next = reverseHead.next;//将temp的下一个节点指向新的链表的最前端
            reverseHead.next = temp;//在将temp连接到新的链表上
            temp = next;//让temp后移
        }
        //在将headNode指向reverseHead,实现单链表反转
        headNode.next = reverseHead.next;
    }


    /**
     * 试题:查找单链表中倒数第几个节点
     * @param headNode 头结点
     * @param index 要查找的倒数第几个节点
     * @return 查找出来返回的节点
     */
    public static Node findNodeByIndex(Node headNode, int index){
        //先判断头结点是否为空,为空就返回null
        if (headNode.next == null){
            return null;
        }
        //调用刚刚写的方法获取到链表的有效个数
        int length = getLength(headNode);
        //先对传入的index做判断,判断数据是否子啊合理范围内
        if (index <=0 || index > length){
            //index<=0 不能找倒数-1 或者倒数0 个节点吧
            //index>length 假设有效节点就3个,不能找倒数第4个节点吧
            return null;//满足条件就返回null
        }
        //定义零时Node为头结点的下一个,for循环定位倒数的index
        Node temp = headNode.next;//那么当前temp为节点1
        //循环遍历有效个数
        //假设length = 3 ,(节点顺序为1,2,3)我们要找的是倒数第1个,那么循环遍历2次,
        //为什么:i=0的时候,temp.next = 2,  i = 1的时候,temp.next = 3,
        //i = 2 的时候,for循环结束,返回temp,那么temp = 3,所以倒数第一个节点为节点3
        for(int i = 0 ; i < length - index; i++){
            //每次循环,就让temp指向下一个节点
            temp = temp.next;
        }
        //返回查找的节点
        return temp;
    }



    /**
     * 试题:获取单链表的节点个数,不统计头节点
     * @param headNode 把链表的头节点传递给方法
     * @return 返回链表有效节点的个数
     */

    public static int getLength(Node headNode){
        //先判断头结点的next是否为空,为空则表示链表为空
        if (headNode.next==null){
            System.out.println("链表为空,无有效个数~~~");
        }
        //定义一个变量来统计个数
        int length = 0;
        //代码走到这里说明有下一个节点,定义一个节点来保存下一个节点
        Node temp = headNode.next;
        // 循环 判断temp是否为null
        while (temp!=null){
            //说明为有效数据
            length++;
            //在将temp指向下一个节点
            temp = temp.next;
        }
        //返回最后的值
        return length;
    }

测试结果

反转单链表图解

在不改变单链表的结构倒序打印图解