（二）单链表

线性表的顺序存储的特点是逻辑上相邻的两个元素在物理位置上也相邻。因此可以随机存取表中的任一一个元素。但是这种存储方式存在的缺点是插入或者删除的时候，需要大量移动元素。
链式存储可以避免顺序存储的弱点，但同时也失去了顺序表课随机存取的优点。
线性链表：链式存储结构–用一组任意的存储单元存储线性表的数据元素（这组讯处单元可以是连续的也可以是不连续的）。链表的基本单元称为节点（node）。节点包括两个域：其中，存储数据元素信息的域称作数据域；存储直接后继存储位置的域称作指针域。
用线性链表表示线性表的时候，数据元素之间的逻辑关系是由节点中的指针指示的。

单链表的基础操作

在定义链表这个整体的类之前，首先需要定义基本单元，也就是节点类。
节点类中，通过构造器对成员变量进行初始化，其中next指针域默认为空。

//定义HeroNode,每个HeroNode对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点
    public  HeroNode(int no,String name,String nickName){
        this.no=no;
        this.name=name;
        this.nickname=nickName;

    }

    //为了显示方便，重写toString方法

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

                '}';
    }
}

接下来定义链表类以及相关操作
在链表类中定义成员变量，空链表的成员只有头结点。初始化头结点对象即可。

•   	注意：
  

•   		1.所有的操作都需要一个辅助的节点temp进行移动来判断操作的位置。因为头结点是不可以移动的，只是作为单链表的标识。
  

•   		2.在链表的末尾添加节点的add操作、遍历list操作不需要flag标识之外，添加到指定位置addByOrder、修改节点信息update、删除节点del都需要标识flag表明找到需要进行操作的位置，先退出遍历的循环，根据flag的值判断是否进行操作
  

•   		3.指定位置添加元素，删除元素，这两个操作，temp指针需要指向操作元素的前一个元素；修改元素以及遍历以及在末尾添加元素，temp只需要指向指定元素或者链表尾即可。
  

//定义SingleLinkedList管理节点
class  SingleLinkedList{
    //先初始化头结点，头结点不要动，只是作为单链表的标识,不存放具体的数据
    private HeroNode head=new HeroNode(0,"","");

    //添加节点到单向链表
    //当不考虑标号顺序时：
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public  void add(HeroNode heroNode){
        //因为head节点不能动，所以需要一个辅助变量temp
        HeroNode temp=head;
        //遍历链表，找到最后
        while(true){
            //找到链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到，将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        temp.next=heroNode;
    }

    //添加到指定位置
    public void addByOrder(HeroNode heroNode){
        HeroNode tempNode=head;
        boolean flag=false;//标识添加的编号是否存在
        while (true){
            if (tempNode.next==null){
                break;
            }
            if (tempNode.next.no>heroNode.no){
                //在temp后面插入
                break;
            }else if (tempNode.next.no==heroNode.no){
                //当编号存在时
                flag=true;//说明已经存在
                break;
            }
            tempNode=tempNode.next;//后移

        }
        //判断flag
        if (flag){
            System.out.printf("准备插入的编号%d已经存在，不能加入",heroNode.no);
        }else {
            //插入到链表
            heroNode.next=tempNode.next;
            tempNode.next=heroNode;
        }
    }

    //修改节点信息，根据no编号来修改
    public void update(HeroNode newHeroNode){
        //判断是否空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        HeroNode temp=head;
        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);
        }
    }

    //删除节点

    /**
     * head不能动，temp指向删除节点的前一个节点
     * 在比较的时候，是temp.next.no和要删除节点的no比较
     */
    public void del(int no){
        HeroNode temp=head;
        boolean flag=false;//标识是否找到待删除节点的前一个节点
        while (true){
            if (temp.next==null){
                //已经到链表的最后
                break;
            }
            if (temp.next.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }else {
            System.out.printf("要删除的%d节点不存在\n",no);
        }
    }

    //显示链表[遍历]
    public void list(){
        //判断链表是否为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp=head.next;
        while(true){
            if (temp==null){
                break;
            }
            System.out.println(temp);
            temp=temp.next;
        }
    }
}

单链表常见题

1.求链表中有效节点的个数

方法：获取单链表的节点的个数 如果是带头结点的链表，不统计头结点

    /**
     *
     * @param head 链表的头结点
     * @return 返回的就是有效节点的个数
     */
    public static int getLength(HeroNode head){
        if (head.next==null){
            //空链表
            return 0;
        }
        int length=0;
        //定义一个辅助变量
        HeroNode cur=head.next;
        while(cur!=null){
            length++;
            cur=cur.next;
        }
        return length;
    }
}

2.查找单链表中倒数第k个节点

• 思路：
  • 1.编写一个方法，接收head节点，同时接收一个index index表示倒数第Index个节点
  • 2.先把链表从头到尾遍历，得到链表总的长度getLength
  • 3.得到size后从链表的第一个开始遍历（size-index）个
  • 4.如果找到则返回该节点，否则返回null

    //查找单链表中的倒数第k个节点
    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //如果链表为空，返回null
        if (head.next==null){
            return null;
        }
        //第一次遍历，得到链表的长度（节点个数）
        int size=getLength(head);
        //第二次遍历size-index位置，就是倒数的第k个节点
        //先做index的校验
        if (index<0||index>size){
            return null;
        }
        //定义辅助变量
        HeroNode cur=head.next;
        for (int i = 0; i <size-index ; i++) {
            cur=cur.next;
        }
        return cur;
    }

3.单链表的反转

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

//单链表的反转
    public static void reversetList(HeroNode head){
        //如果当前链表为空或者只有一个节点，无需反转，直接返回
        if (head.next==null||head.next.next==null){
            return;
        }
        //定义一个辅助的指针（变量），帮助遍历原来的链表
        HeroNode cur=head.next;
        HeroNode next=null;//指向当前节点的下一个节点
        HeroNode reverseHead=new HeroNode(0,"","");
        //遍历原来的链表。从头到尾遍历原来的链表，将其取出并放在心的链表reverseHead的最前端
        while (cur!=null){
            next=cur.next;//保留当前节点的下一个节点，否则下一个节点遍历的时候找不到链表
            cur.next=reverseHead.next;
            reverseHead.next=cur;
            cur=next;//让cur后移
        }
        //将head.next指向reverseHead.next
        head.next=reverseHead.next;
    }

4.从尾到头打印单链表

•   思路：
    		方式1：先将单链表进行反转操作，然后遍历。这样做的问题是会破坏原来单链表的结构。不建议使用
    	    方式2：可以利用栈的数据结构，将将各个节点压入到栈中，然后利用栈的先进后出的特点实现逆序打印。
  

 //逆序打印单链表中的元素
    public static void reversePrint(HeroNode head){
        if (head.next==null){
            return;//空链表不打印
        }
        //创建一个栈，将各个节点压入栈
        Stack<HeroNode>stack=new Stack<>();
        HeroNode cur=head.next;
        //将链表的所有节点压入栈
        while (cur!=null){
            stack.push(cur);
            cur=cur.next;//cur后移，压入下一个
        }
        //将栈中的节点进行打印，pop出栈
        while(stack.size()>0){
            System.out.println(stack.pop());
        }
    }