数据结构与算法学习（第三天单链表节点数、倒数k个节点值、反转、尾到头打印）

求单链表中有效节点的个数

//获取到但链表的节点的个数（如果是带头节点的链表，需求不统计头节点）

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;
}

查找单链表中倒数第K个节点

 /**
     * 1、编写一个方法，接收head节点，同事接收一个index
     * 2、index 表示是倒数第index个节点
     * 3、先把链表从头到尾遍历，得到链表的总长度getLength
     * 4、得到size后，我们从链表的第一个开始遍历（size-index）个，就可以得到
     * 5、如果找到了，则返回该节点，否则返回null
     * @param head
     * @param index
     * @return
     */
    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;
        }
        //定义给辅助变量，for循环定位到倒数的index
        HeroNode cur = head.next;
        for(int i=0;i<size-index;i++){
            cur = cur.next;
        }
        return cur;
    }

单链表的反转

思路：

1.先定义一个节点 reverseHead = new HeroNode();

2.从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端

3.原来的链表的head.next = reverseHead.next

//将单链表反转
    public static HeroNode reversetlist(HeroNode head){
        //如果当前链表为空，或者只有一个节点，无需反转，直接返回
        if(head.next == null || head.next == null){
            return null;
        }

        //定义一个辅助的指针（变量），帮助我们遍历原来的节点
        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;
        }
        head.next = reverseHead.next;
        return reverseHead;
    }

从尾到头打印单链表

思路：

1.可以利用栈这个数据结构，将各个节点压入栈中，然后利用栈的先进先出的特点，就实现了逆序打印的效果

    public static void reversePrint(HeroNode head){
        if(head.next == null){
            return;
        }
        //创建要给一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈
        while(cur != null){
            stack.push(cur);
            //cur后移，这样就可以压入下一个节点
            cur = cur.next;
        }
        //将栈中的节点进行打印，出栈
        while (stack.size() > 0){
            //stack的特点是先进后出
            System.out.println(stack.pop());
        }
    }