数据结构--单链表

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

 

1) 链表是以节点的方式来存储,是链式存储

2) 每个节点包含 data 域， next 域：指向下一个节点.

3) 如图：发现链表的各个节点不一定是连续存储.

4) 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

5） 各个节点是分散的存在，他们的联系是指向，节点A指向了节点B，构建时关键是搭建出联系指向，遍历时只要找到

6） 由后给前赋值，如删除：tempNode.nextNode = tempNode.nextNode.nextNode;

二、单链表(带头结点) 逻辑结构示意图如下

 

三、单链表的应用实例

使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作

3.1、第一种方法在添加英雄时，直接添加到链表的尾部

3.2、第二种方式在添加英雄时，根据排名将英雄插入到指定位置

1）思路的分析示意图

3.3、修改节点功能

思路

(1) 先找到该节点，通过遍历，

(2)temp.name = newHeroNode.name ; temp.nickname= newHeroNode.nickname

3.4、删除节点

1）思路的分析示意图

四、上代码

Node节点类

public class HeroNode {
    public Integer no;
    public String name;
    public String nickName;
    public HeroNode nextNode;

    public HeroNode() {
    }

    public HeroNode(Integer 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 + '\'' +
                '}';
    }
}

服务类

public class SingleLinkListServe {

    //初始化一个头节点，头节点不要动，不存放任何数据
    HeroNode headNode = new HeroNode();

    //1、向链表尾部添加节点
    /**
     * 思路：当不考虑编号的顺序时
     * 1、找到当前链表的最后节点
     * 2、将最后节点的nextNode指向新的节点
     */
    public void addNode(HeroNode newNode){
        //创建一个临时节点
        HeroNode tempNode = headNode;
        //循环，直到找到最后一个节点就退出
        while (true){
            if(tempNode.nextNode == null){
                break;
            }
            tempNode = tempNode.nextNode;
        }
        //循环退出后即找到最后一个节点了，在最后一个节点的nextNode进行添加新节点
        tempNode.nextNode = newNode;
    }

    //2、根据序号添加节点
    /**
     * 思路：（如果有这个排名，则添加失败，并给出提示）
     * 1、找到添加的位置
     * 2、新的节点.nextNode = temp.nextNode
     * 3、temp.next = 新的节点
     */
    public void addByOrder(HeroNode newHeroNode){
        //创建临时节点
        HeroNode tempNode = headNode;
        //创建一个标记
        boolean flag = false;

        while(true){
            if(tempNode.nextNode == null){
                break;
            }
            if(tempNode.nextNode.no > newHeroNode.no){
                break;
            }
            if(tempNode.nextNode.no == newHeroNode.no){
                flag = true;
                break;
            }
            tempNode = tempNode.nextNode;
        }

        if(flag){//编号存在，不能添加
            System.out.printf("编号%d的节点已经存在，不能添加",tempNode.no);
        }else {
            newHeroNode.nextNode = tempNode.nextNode;
            tempNode.nextNode = newHeroNode;
        }


    }
    
     //3、根据编号修改节点信息
    public void update(HeroNode newNode){
        HeroNode tempNode = headNode;
        //是否找到的标识
        boolean flag = false;
        if(headNode.nextNode == null){
            System.out.println("链表为空");
            return;
        }
        while (true){
            tempNode = tempNode.nextNode;
            //最后一个节点
            if(tempNode == null){
                break;
            }
            //找到了，标识为true
            if(tempNode.no == newNode.no){
                flag = true;
                break;
            }
        }
        //根据flag判断是否找到节点
        if(flag){
            tempNode.name = newNode.name;
            tempNode.nickName = newNode.nickName;
        }else {
            System.out.println("未找到节点");
        }
    }
    //4、删除节点
    public void delNode(int no){
        HeroNode tempNode = headNode;
        boolean flag = false;
        if(tempNode == null){
            System.out.println("链表为空");
        }
        while(true){
            if(tempNode.nextNode == null){
                break;
            }
            if(tempNode.nextNode.no == no){
                flag = true;
                break;
            }
            tempNode = tempNode.nextNode;
        }

        if(flag){//表示找到节点了
            tempNode.nextNode = tempNode.nextNode.nextNode;
        }else {
            System.out.println("节点没找到");
        }


    }
    //5、遍历链表
    public void printList(){
        //创建一个临时节点
        HeroNode tempNode = headNode;
        //判断链表是否为空
        if(tempNode.nextNode== null){
            System.out.println("链表为空");
            return;
        }
        while(true){
            //判断是否为最后节点
            if(tempNode.nextNode== null){
                break;
            }
            //非最后节点就输出打印，并将临时节点往下移动
            System.out.println(tempNode.nextNode);
            tempNode = tempNode.nextNode;
        }


    }


}

测试执行类

public class SingleLinkListDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
        HeroNode heroNode4 = new HeroNode(4,"林冲","豹子头");

        SingleLinkListServe singleLinkListServe = new SingleLinkListServe();
        //直接添加
        /*singleLinkListServe.addNode(heroNode1);
        singleLinkListServe.addNode(heroNode2);
        singleLinkListServe.addNode(heroNode3);
        singleLinkListServe.addNode(heroNode4);*/
        //有序添加
        singleLinkListServe.addByOrder(heroNode1);
        singleLinkListServe.addByOrder(heroNode2);
        singleLinkListServe.addByOrder(heroNode4);
        singleLinkListServe.addByOrder(heroNode3);
        singleLinkListServe.printList();
        System.out.println("————————————————————————————————————————————————————————————————");
       //更新
        HeroNode updateNode = new HeroNode(4,"林冲冲","豹子头大哥");
        singleLinkListServe.update(updateNode);
        singleLinkListServe.printList();
        System.out.println("————————————————————————————————————————————————————————————————");
        //删除
        singleLinkListServe.delNode(4);
        singleLinkListServe.printList();
    }
}

 

五、反转单链表

//单链表反转
    public HeroNode turnNode(){
        HeroNode head = headNode;
        if(head.nextNode == null || head.nextNode.nextNode == null){
            return head;
        }
        HeroNode curr = head;
        HeroNode prev = null;

        while(curr != null){
            HeroNode next = curr.nextNode;
            curr.nextNode = prev;
            prev = curr;
            curr = next;
        }

        return prev;

    }
    //遍历反转链表
    public void printList(HeroNode headNode){
        //创建一个临时节点
        HeroNode tempNode = headNode;
        while(tempNode !=null){
            if(tempNode.nextNode != null){
                System.out.println(tempNode);
            }
            tempNode = tempNode.nextNode;
        }
    }

 

六、利用栈反转输出

//从尾到头打印单链表（不改变链表结构）
    public void printListUseStack(){

        HeroNode tempNode = headNode;

        Stack<HeroNode> stack = new Stack<>();
        
        if(tempNode.nextNode == null){
            System.out.println("链表为空");
            return;
        }
        
        while(tempNode.nextNode != null){
            //将获取的数据放入栈中
            stack.push(tempNode.nextNode);
            tempNode = tempNode.nextNode;
        }
        while(stack.size()>0){
            //从栈中输出
            System.out.println(stack.pop());
        }

    }