单链表大厂面试题

求单链表的有效个数(不算头节点)

//求单链表的有效个数(不算头节点)
    public static int getLength(HeroNode head){
        if (head.next == null){
            return 0;
        }
        HeroNode temp = head.next;
        int length = 0;
        while (temp != null){
            length++;
            temp = temp.next;
        }
        return length;
    }

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

思路
1.编写一个方法,接收head节点，同时接收一个index
2. index 表示是倒数第index个节点
3.先把链表从头到尾遍历，得到链表的总的长度getLength
4.得到size后,我们从链表的第一个开始遍历(size- index)个,就可以得到
5.如果找到了，则返回该节点，否则返回null

public static HeroNode findNode(HeroNode head,int index){
        if (head.next == null){//为空
            return null;
        }
        int size = getLength(head);
        HeroNode node = head.next;// 1 2 3
        for (int i = 0; i < size - index; i++) {
            node = node.next;
        }
        return node;
    }

单链表反转

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

示意图：

这种是有虚拟指针的（意思就是第一个节点没有值，从第二个开始）

//单链表反转
    public static void reverseNode(HeroNode head){
        if (head.next == null || head.next.next == null){
            return;//判断链表是否为空或者只有一个元素，只有一个元素不用反转
        }
        HeroNode temp = head.next;//辅助变量
        HeroNode cur = null;//存放temp指向的下一个变量
        HeroNode node = new HeroNode(0,"","");//创建一个新的链表，用来暂时存放反转数据
        遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
        while (temp != null){
            cur = temp.next;//先暂时保存当前节点的下一个节点，因为后面需要使用
            temp.next = node.next;//将cur的下一个节点指向新的链表的最前端
            node.next = temp;//将cur连接到新的链表上
            temp = cur;//后移
        }
        head.next = node.next;

    }

leecode正常版

public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        ListNode next = null;
        while (curr != null) {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }

倒序打印链表

思路
1.上面的题的要求就是逆序打印单链表.
2.方式1:先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
3.方式2:可以利用栈这个数据结构,将各个节点压入到栈中,然后利用栈的先进后出的特点，就实现了逆序打印的效果.
举例演示栈的使用Stack

public static void reversePrint(HeroNode head){
        if (head.next == null || head.next.next == null){
            return;//判断链表是否为空或者只有一个元素，只有一个元素不用反转
        }
        HeroNode temp = head.next;
        Stack<HeroNode> heroNodes = new Stack<>();
        while (temp != null){
            heroNodes.add(temp);
            temp = temp.next;
        }
        int size = heroNodes.size();
        for (int i = 0; i < size; i++) {
            System.out.println(heroNodes.pop());
        }
//        heroNodes.pop();
    }

合并两个有序的单链表，合并之后的链表依然有序

思路：
1.传三个链表，list1和list2是有序单链表，list3是空链表
2.把list1和list2进行对比，小的加入到list3的后面，然后循环比较，从小到大依次加在list3的后面
3.每次执行完一次添加操作，让temp.next为null，是为了保证list3链表每次新增加的节点都是加在最后的

//合并两个有序的单链表，合并之后的链表依然有序
    //list1和list2是有序单链表，list3是空链表
    public static SingleLinkedList MergeNode(SingleLinkedList  list1,SingleLinkedList list2,SingleLinkedList list3){
        if (list1.getHead().next == null || list2.getHead().next == null){
            return list1.getHead().next == null ? list2 : list1;
        }
        HeroNode head1 = list1.getHead();
        HeroNode head2 = list2.getHead();
        HeroNode head3 = list3.getHead();
        HeroNode temp1 = head1.next;
        HeroNode temp2 = head2.next;
        HeroNode temp3 = head3.next;
        while (temp1!=null && temp2!=null){
            if (temp1.no< temp2.no){
                temp3 = temp1;
                temp1 = temp1.next;
            }else if (temp1.no > temp2.no){
                temp3 = temp2;
                temp2 = temp2.next;
            }else {
                temp3 = temp1;
                temp3.next = temp2;
            }
            list3.addNode(temp3);//就是前边写的添加节点方法（遍历，不为空，后移，添加，循环）
            temp3.next = null;
        }
        while (temp1==null && temp2!=null) {
            temp3 = temp2;
            temp2 = temp2.next;
            list3.addNode(temp3);
            temp3.next = null;
        }
        while (temp2==null && temp1!=null){
            temp3 = temp1;
            temp1 = temp1.next;
            list3.addNode(temp3);
            temp3.next = null;
        }
        return list3;
    }