JAVA数据结构（四）单链表

单链表

链表是以节点的方式来存储
每个节点包含data域，next域(指向下一个节点)
链表的各个节点不一定是连续存储
链表分带头节点和没有头节点的链表，根据实际的需求来确定

结点结构
┌───┬───┐
│data │next │
└───┴───┘
data域–存放结点值的数据域
next域--存放结点的直接后继的地址（位置）的指针域（链域）

代码分析

这里我们以英雄的信息为节点
首先先定义一个英雄节点（HeroNode）

class HeroNode{
    public int num;//编号
    public String name;//英雄名称
    public HeroNode next = null;
    //构造器
    public HeroNode(){
        this.name =null;
        this.num = 0;
    }
    public HeroNode(int num, String name){
        this.name =name;
        this.num = num;
    }
    @Override
    public String toString() {
        return "{" + "num=" + num + ", name='" + name + '\'' + '}';
    }
}

创建带头节点（head）的单链表

class SingleLinkedList{
     HeroNode head = new HeroNode(0,"");//定义链表头节点
    public HeroNode getHead() {
        return head;
    }
}

编写节点添加的方法（尾插法）
思路：
1.先创建一个head头节点，作用就是表示单链表的头
2.后面每添加一个节点，就直接加入到链表到最后

   public void add(HeroNode node){//在链表最后插入数据
        HeroNode temp = head;//head节点是不可改动，设一个temp辅助节点代替head节点
        while (true){
            if (temp.next == null){//遍历到链表最后
                break;
            }
            temp = temp.next;//节点后移
        }
        temp.next = node;
    }

添加节点时以节点data数值进行排序插入
思路：
1.首先找到新添加的节点位置，是通过辅助变量（temp），通过遍历来实现
2.新的节点.next =temp.next
3.temp.next = 新的节点

public void addByOrder(HeroNode node){//根据英雄编号排序插入
        HeroNode temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while(true){
            if (temp.next == null){//说明temp已经在链表的最后
                break;
            }
            if (temp.next.num >node.num){//位置找到，在temp的后面插入
                break;
            }else if (temp.next.num == node.num){//发现链表里有相同编号，无法插入
                flag =true;
                break;
            }
            temp = temp.next;//temp继续后移，遍历当前链表
        }
        if (flag){//判断flag值，不能添加说明编号存在
            System.out.println("编号已存在");
        }else{//插入节点到temp的后面
            node.next = temp.next;
            temp.next = node;
        }
    }

修改节点的信息
思路：
1.遍历链表找出要修改的节点
2.temp.name =newNode.name;

public void update(HeroNode newNode){
        if (head.next == null){//判断链表是否为空
            return;
        }
        //根据编号找到需要修改的节点
        HeroNode temp = head.next;//定义一个辅助节点
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }
            if (temp.num == newNode.num){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name =newNode.name;
        }else {
            System.out.println("没有相应编号的节点");
        }
    }

删除节点
思路：
1.要先找到需要删除的节点的前一个节点（temp）
2.temp.next = temp.next.next（待删除节点的前一个节点指向待删除节点的后一个节点）
3.被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收

public void delet(int num){
        if (head.next == null){//判断链表是否为空
            return;
        }
        HeroNode temp = head;//定义一个辅助节点
        boolean flag = false;//标志是否找到待删除的节点
        while (true){
            if (temp.next == null){//已经到达链表最后
                break;
            }
            if (temp.next.num == num){//找到待删除节点的前一个节点
                flag = true;
                break;
            }
            temp  = temp.next;//节点后移
        }
        if (flag){//找到待删除节点
            temp.next = temp.next.next;//待删除节点的前一个节点直接指向待删除节点的后一个节点
        }else {
            System.out.println("没有相应编号的节点");
        }
    }

获取单链表的有效节点个数（如果带头节点就不包含头节点）

 /**
     * 获取单链表的有效节点个数（不包括头节点）
     * @return 有效节点的个数
     */
    public  int getLength(){
        HeroNode temp = head.next;
        if (temp == null){
            System.out.println("链表为空");
            return 0;
        }
        int length = 0;
        while (temp != null){
            length++;
            temp = temp.next;
        }
        return length;
    }

查找单链表中的倒数第K个节点
思路：
1.编写一个方法，传入index（表示是倒数第index个节点）
2.先把链表从头到尾遍历得到链表总长度 int size = getLength();
3.得到size后，再从链表的第一个开始遍历至（size-index）

/**
     * 获取链表中倒数第index个节点
     * @param index
     * @return
     */
    public HeroNode findLastIndexNode(int index){
        HeroNode temp = head.next;
        if (temp == null){

            return null;
        }
        int size = getLength();
        if (index <=0 || index > size){
            return null;
        }
        for (int i = 0; i<size-index; i++){
            temp = temp.next;
        }
        return temp;
    }

思路：
1.定义一个新的头节点 HeroNode reverseHead = new HeroNode();
2.从头到尾遍历链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
3.原来的链表指向新节点 head.next = reverseHead.next;

public void  reverse(){
        HeroNode reverseHead = new HeroNode();
        HeroNode temp = head.next;
        if (temp == null || temp.next == null){
            return;
        }
        HeroNode next=null;
        while (temp != null){
            next = temp.next;
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            temp = next;
        }
        head.next = reverseHead.next;
    }

从头到尾打印单链表
思路：
1.如果将单链表进行反转操作，再遍历，这样会破坏原来的单链表的结构，不建议
2.利用栈的先进后出的原理，将各个节点压入栈中，然后利用栈的特点，实现逆序打印的效果

public void reversePrint(){
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode temp  = head.next;

        if (temp == null ){
            return;
        }
        while (temp!= null){
            stack.push(temp);
            temp = temp.next;
        }
        while (stack.size()>0){
            System.out.println(stack.pop().toString());
        }

    }

完整代码

public class SingleLinkedListDemo {
    public static void main(String[] args) {//测试代码
        SingleLinkedList list = new SingleLinkedList();
        HeroNode hero1 = new HeroNode(1, "德玛西亚");
        HeroNode hero2 = new HeroNode(7, "提莫");
        HeroNode hero3 = new HeroNode(3, "赏金猎人");
        HeroNode hero4 = new HeroNode(4, "诺克萨斯");
        HeroNode updateHero = new HeroNode(4, "诺克萨斯之手");
        list.addByOrder(hero1);
        list.addByOrder(hero2);
        list.addByOrder(hero3);
        list.addByOrder(hero4);
        list.update(updateHero);
        list.delet(7);
        list.print();
        System.out.println(list.getLength());
        list.reverse();
        list.reversePrint();
        System.out.println();
        list.print();
        System.out.println(list.findLastIndexNode(4).toString());

    }
}


class SingleLinkedList{
     HeroNode head = new HeroNode(0,"");
    public HeroNode getHead() {
        return head;
    }
    public void add(HeroNode node){//在链表最后插入数据
        HeroNode temp = head;//head节点是不可改动，设一个temp辅助节点代替head节点
        while (true){
            if (temp.next == null){//遍历到链表最后
                break;
            }
            temp = temp.next;//节点后移
        }
        temp.next = node;
    }
    public void addByOrder(HeroNode node){//根据英雄编号排序插入
        HeroNode temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while(true){
            if (temp.next == null){//说明temp已经在链表的最后
                break;
            }
            if (temp.next.num >node.num){//位置找到，在temp的后面插入
                break;
            }else if (temp.next.num == node.num){//发现链表里有相同编号，无法插入
                flag =true;
                break;
            }
            temp = temp.next;//temp继续后移，遍历当前链表
        }
        if (flag){//判断flag值，不能添加说明编号存在
            System.out.println("编号已存在");
        }else{//插入节点到temp的后面
            node.next = temp.next;
            temp.next = node;
        }
    }
    public void update(HeroNode newNode){
        if (head.next == null){//判断链表是否为空
            return;
        }
        //根据编号找到需要修改的节点
        HeroNode temp = head.next;//定义一个辅助节点
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }
            if (temp.num == newNode.num){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name =newNode.name;
        }else {
            System.out.println("没有相应编号的节点");
        }
    }
    public void delet(int num){
        if (head.next == null){//判断链表是否为空
            return;
        }
        HeroNode temp = head;//定义一个辅助节点
        boolean flag = false;//标志是否找到待删除的节点
        while (true){
            if (temp.next == null){//已经到达链表最后
                break;
            }
            if (temp.next.num == num){//找到待删除节点的前一个节点
                flag = true;
                break;
            }
            temp  = temp.next;//节点后移
        }
        if (flag){//找到待删除节点
            temp.next = temp.next.next;//待删除节点的前一个节点直接指向待删除节点的后一个节点
        }else {
            System.out.println("没有相应编号的节点");
        }
    }
    public void print(){//遍历链表
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            if (temp == null){
                break;
            }
            System.out.println(temp.toString());
            temp = temp.next;
        }
    }

    /**
     * 获取单链表的有效节点个数（不包括头节点）
     * @return 有效节点的个数
     */
    public  int getLength(){
        HeroNode temp = head.next;
        if (temp == null){
            System.out.println("链表为空");
            return 0;
        }
        int length = 0;
        while (temp != null){
            length++;
            temp = temp.next;
        }
        return length;

    }
    /**
     * 获取链表中倒数第index个节点
     * @param index
     * @return
     */
    public HeroNode findLastIndexNode(int index){
        HeroNode temp = head.next;
        if (temp == null){

            return null;
        }
        int size = getLength();
        if (index <=0 || index > size){
            return null;
        }
        for (int i = 0; i<size-index; i++){
            temp = temp.next;
        }
        return temp;
    }
    public void  reverse(){
        HeroNode reverseHead = new HeroNode();
        HeroNode temp = head.next;
        if (temp == null || temp.next == null){
            return;
        }
        HeroNode next=null;
        while (temp != null){
            next = temp.next;
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            temp = next;
        }
        head.next = reverseHead.next;
    }
    public void reversePrint(){
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode temp  = head.next;

        if (temp == null ){
            return;
        }
        while (temp!= null){
            stack.push(temp);
            temp = temp.next;
        }
        while (stack.size()>0){
            System.out.println(stack.pop().toString());
        }
    }
}


class HeroNode{
    public int num;//编号
    public String name;//英雄名称
    public HeroNode next = null;
    //构造器
    public HeroNode(){
        this.name =null;
        this.num = 0;
    }
    public HeroNode(int num, String name){
        this.name =name;
        this.num = num;
    }
    @Override
    public String toString() {
        return "{" + "num=" + num + ", name='" + name + '\'' + '}';
    }
}