数据结构之链表（单链表题目）

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

/*
求单链表中有效节点的个数
 */
private static int getEffectiveNodeNum(SingleLinkedList.Node head) {
    SingleLinkedList.Node temp = head;
    //判断链表是否为空
    if (temp.next == null) {
        return 0;
    }
    int count = 0;
    while (temp.getNext() != null) {
        count++;
        temp = temp.getNext();
    }
    System.out.printf("当前链表的节点数量是 %d  如下", count);
    return count;
}

 

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

 /*
查找单链表中的倒数第 k 个结点
 */
 private static SingleLinkedList.Node getNodeByNo(SingleLinkedList.Node head, int index) {
     SingleLinkedList.Node temp = head;
     //判断链表是否为空
     if (temp.next == null) {
         System.out.println("当前节点为空");
         return null;
     }
     int count = getEffectiveNodeNum(head);

     int position = count - index;
     for (int i = 0; i <= position; i++) {
         temp = temp.getNext();
     }
     //返回链表
     return temp;
 }

3.单链表的反转

 

/*
单链表的反转
 */
private static void reverse(SingleLinkedList.Node head) {
    //辅助指针
    SingleLinkedList.Node temp = head.next;
    if (temp == null) {
        System.out.println("链表为空");
        return;
    }
    if (temp.next == null) {
        System.out.println("当前链表只有一个节点");
        return;
    }
    //定义新的头节点
    SingleLinkedList.Node newHead = new SingleLinkedList.Node("", "", null);
    //当前节点的下一个节点，用于暂存，因为当前节点指针变化，保存下一个节点的位置
    SingleLinkedList.Node next = null;
    while (temp != null) {
        //暂存当前节点
        next = temp.next;
        //当前节点的下一个指针指向新节点的头节点的下一个，首节点的话，此处为空
        temp.next = newHead.next;
        //新节点的头节点的下一个节点指向当前节点
        newHead.next = temp;
        //当前节点指向暂存的节点
        temp = next;

    }
    //最后，将原头节点的next指向新节点的next
    head.next = newHead.next;

}

4.从尾到头打印单链表

/**
 * 从尾到头打印单链表
 * 方式1：反向遍历
 * 方式 2：Stack 栈
 *
 * @param head
 */
private static void reverseNodeOut(SingleLinkedList.Node head) {
    //使用栈FILO 先进后出的特性实现

    SingleLinkedList.Node temp = head.next;
    if (temp == null) {
        System.out.println("当前链表为空");
    }

    final Stack<SingleLinkedList.Node> stack = new Stack<>();

    while (temp != null) {
        stack.push(temp);
        temp = temp.next;
    }

    while (stack.size() > 0) {
        System.out.println(stack.pop());
    }

}

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

/*
合并两个有序的单链表，合并之后的链表依然有序
 */
private static void mergeLinkedList(SingleLinkedList first, SingleLinkedList second) {

    final SingleLinkedList.Node firstHead = first.getHead();

    final SingleLinkedList.Node secondHead = second.getHead();

    if (firstHead.next == null && secondHead.next == null) {
        return;
    }

    //定义链表1 的辅助节点
    SingleLinkedList.Node firstTemp = firstHead.next;
    //定义链表2的辅助节点
    SingleLinkedList.Node secondTemp = secondHead.next;

    //定义新链表的头节点
    SingleLinkedList.Node newHead = new SingleLinkedList.Node("", "", null);
    //定义新链表的辅助节点
    SingleLinkedList.Node temp = newHead;

    //比较两个节点的no大小，进行节点的加入在新链表中
    while (firstTemp != null && secondTemp != null) {
        if (firstTemp.no < secondTemp.no) {
            //当前节点的next 指向 遍历到的节点
            temp.next = firstTemp;
            //temp后移一位
            temp = firstTemp;
            //当前节点的链表后移一位
            firstTemp = firstTemp.next;
        } else {
            //当前节点的next 指向 遍历到的节点
            temp.next = secondTemp;
            //temp后移一位
            temp = secondTemp;
            //当前节点的链表后移一位
            secondTemp = secondTemp.next;
        }
    }

    //第一个链表还剩余元素
    while (firstTemp != null) {
        temp.next = firstTemp;
        temp = firstTemp;
        firstTemp = firstTemp.next;
    }

    //第二个链表还剩余元素
    while (secondTemp != null) {
        temp.next = secondTemp;
        temp = secondTemp;
        secondTemp = secondTemp.next;
    }

    System.out.println("");
}