《尚硅谷数据结构》-单向链表面试题练习

目录

求单链表中节点的个数

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

单链表的反转

从尾到头打印单链表

合并两个有序的单链表

---

求单链表中节点的个数

    //获取单链表的节点个数（如果有头节点，则不统计头节点）
    public int getLength(HeroNode headNode){
        if(headNode.next == null){
            return 0;
        }
        int length = 0;
        HeroNode temp = headNode.next;
        while(temp!=null){
            length++;
            temp = temp.next;
        }
        return length;
    }

int number = singleLinkedlist.getLength(singleLinkedlist.getHead());

class SingleLinkedlist{
    // 先初始化一个头节点，不存放具体数据
    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead() {
        return head;
    }

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

//查找单链表中的倒数第k个节点
    public HeroNode findLastIndexNode(HeroNode headNode,int index){
        if(head.next == null){
            return null; //空节点
        }
        //第一次遍历，得到链表的长度
        int size = getLength(headNode);
        //第二次遍历，得到size-index，就是倒数节点
        //index校验
        if(index <=0||index>size){
            return null;
        }
        HeroNode temp = headNode.next;
        for(int i=0; i<size-index; i++){
            temp = temp.next;
        }
        return temp;
    }

单链表的反转

    //将单链表反转
    public void reverseList(HeroNode headNode){
        if(head.next == null ||head.next.next == null){
            return ;
        }
        HeroNode temp = headNode.next;
        HeroNode tempNext = null; //指向当前节点的下一个节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，每遍历一个节点，将其取出，并放在新的链表reverseHead的最前端
        while(temp!=null){
            tempNext = temp.next; //暂时保存当前节点的下一个节点
            temp.next = reverseHead.next;  //头插法，把新插入的节点指向 前一个插入的节点（reverseHead.next）
            reverseHead.next = temp; //把当前节点移过去
            temp = tempNext; //继续遍历
        }
        //替换head
        head.next = reverseHead.next;
    }

注意 reverseHead.next指代的是前一个插入的节点

从尾到头打印单链表

方法：可以利用 栈，通过栈的先进后出的特点实现逆向打印

    //使用栈实现逆序打印链表
    public void reversePrint(HeroNode headNode){
        if(headNode.next == null){
            return;
        }
        //创建一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode temp = headNode.next;
        while(temp!=null){
            stack.push(temp);
            temp = temp.next;
        }
        //打印栈
        while(stack.size()>0){
            System.out.println(stack.pop());
        }
    }

合并两个有序的单链表

解法一：自写的复杂版，两个过渡地址（等于是把链表2往链表1里加）

 //合并两个链表，并且按照顺序排列
    public void concate(HeroNode headNode1,HeroNode headNode2){
        if(headNode1.next == null || headNode2.next == null ){
            return;
        }
        HeroNode temp1 = headNode1;
        HeroNode temp2 = headNode2.next;
        HeroNode temp; //存放过渡地址
        HeroNode temp_2; //存放过渡地址
        //把链表2插入链表1中
        while(true){
            if(temp2 == null || temp1.next == null){
                break;
            }
            if(temp2.no>=temp1.next.no){
                temp1 = temp1.next;
            }else{
                temp = temp1.next;
                temp_2 =temp2.next;
                temp1.next = temp2;
                temp2.next = temp;
                temp2 = temp_2;
            }
        }
        if(temp2 != null){ //说明还有没加入的，即比链表1最大的编号还要大
            temp1.next = temp2;
        }
    }

解法二：用一个头节点（等于是新建了一个链表，把链表1和链表2里的节点往里加）

    public HeroNode concate2(HeroNode headNode1,HeroNode headNode2) {
        HeroNode head = new HeroNode(0,"","");
        HeroNode temp = head;
        while(headNode1.next != null && headNode2.next != null){
            if(headNode1.next.no<=headNode2.next.no){
                temp.next = headNode1.next;
                headNode1.next = headNode1.next.next;
            }else{
                temp.next = headNode2.next;
                headNode2.next = headNode2.next.next;
            }
            temp = temp.next;
        }
        //把剩下的节点加入  | A ？ B ：C (如果A为真执行B否则执行C)
        temp.next = headNode1.next == null? headNode2.next:headNode1.next;
        return head;
    }