单链表面试题

 /**
     * 计算链表长度
     * @param head
     * @return
     */
    public int length(HeroNode head){
        int length = 0;
        if (null==head.next){
            return 0;
        }
        HeroNode curHero = head.next;
        while (null != curHero){
            length++;
            curHero = curHero.next;
        }
        return length;
    }

    /**
     * 查找单链表中的倒数第k个节点
     * @param head
     * @param index
     * @return 查找的节点
     */
    public HeroNode findLastIndex(HeroNode head , int index){
        //存在性判断
        if (null == head.next){
            return null;
        }
        //计算总长度
        int size = length(head);
        //index合法性判断
        if (index>size || index<0){
            System.out.println("index 超出范围");
            return null;
        }
        //辅助节点
        HeroNode curHero = head.next;
        //查找该节点，遍历size-index次
        for (int i = 0; i < size-index ; i++) {
            curHero = curHero.next;
        }
        return curHero;
    }

    /**
     * 将单链表反转
     * 头插法
     * @param head
     */
    public void reverseList(HeroNode head){
        //合法性判断,当没有或只有一个元素，直接返回
        if (null == head.next || null == head.next.next){
            return;
        }
        //辅助节点
        HeroNode curHero = head.next;
        //用来保存当前节点的下一个节点，避免数据丢失
        HeroNode next = null;
        //定义临时头节点
        HeroNode tempHead = new HeroNode(0,"","");
        //遍历链表并且用头插法查到临时链表里
        while (null != curHero){
            //暂时保存当前节点的下一个节点，避免数据丢失
            next = curHero.next;
            //遍历得到的元素插到第一个
            curHero.next = tempHead.next;
            //头指针指向第一个元素
            tempHead.next = curHero;
            //让cur后移
            curHero = next;
        }
        //最后将原来的头指针指向新链表
        head.next = tempHead.next;
    }

    /**
     * 从尾到头打印单链表，
     * 要求：不能改变链表的顺序
     * 使用栈的特性：先进后出
     * @param head
     */
    public void reversePrint(HeroNode head){
        //空链
        if (null == head.next){
            return;
        }
        //定义栈
        Stack<HeroNode> stack = new Stack<>();
        //辅助节点
        HeroNode curHero = head.next;
        while (null != curHero){
            //进栈
            stack.push(curHero);
            //指向下一个节点
            curHero = curHero.next;
        }
        //出栈，所得结果即为倒序输出
        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }

合并两个有序链表(待修改)

/**
     * 合并两个有序链表
     * @param head1
     * @param head2
     * @return
     */
    public HeroNode mergeSortedList(HeroNode head1 , HeroNode head2 ){
        //辅助头节点
        HeroNode head = new HeroNode(0,"","");

        if (head1.next == null){
            return head2;
        }
        if (head2.next == null){
            return head1;
        }
        if (head1.next == null && head2.next == null){
            return null;
        }

        HeroNode curFirst = head1.next;
        HeroNode curSeond = head2.next;
        //定义临时节点
        HeroNode temp = head;
        //循环选择较小的插入新链表的尾部
        while (curFirst != null && curSeond != null){
            temp = temp.next;
            if (curFirst.no <= curSeond.no){
                temp=curFirst;
                curFirst = curFirst.next;
            }else {
                temp = curSeond;
                curSeond = curSeond.next;
            }
            System.out.println(temp);


        }
        //有一条为空了直接
        if (curFirst == null){
            temp.next = curSeond;
        }
        if (curSeond == null ){
            temp.next = curFirst;
        }
        return head;
    }