单链表问题的汇总

汇总： 1.单链表的 增删改查

            2.求有效节点的个数

            3. 找到单链表倒数第k个节点

             4. 单链表反转

             5. 逆序打印单链表

// 定义一个 类管理链表
class SingleList{
    // 初始化一个节点，作为头节点,头节点不要动
    private static Node head = new Node(0,"");

    public static Node getHead() {
        return head;
    }

    // 添加数据的方法
    public void add(Node node){
        // 创建一个辅助节点，指向头节点开始
        // 让他等于当前节点的next，如果当前节点的next为空
        // 就加到后面
        Node temp = head;
        while(temp.next != null){
            // 下一个节点不为空，就等于下一个节点，一直往后找
            temp = temp.next;
        }
        // 跳出循环，说明temp.next = null 让它等于传进来的node
        temp.next = node;
    }

    // 按编号顺序添加
    public void addNum(Node node){
        Node temp = head;   // 找到头节点
        if(temp.next == null){  // 判断是否为空，是空直接添加，否则后面使用temp.next 会发生异常
            temp.next = node;
            return;
        }
        while(true){
            temp = temp.next;  // 已经最少有一个数据了，temp后移
            if(temp.next == null){  // 找到最后了，添加在最后
                temp.next = node;
                break;
            }
            Node help = null;  //创建一个辅助变量
            if(node.num < temp.next.num){  // 待添加的编号，小于temp后的编号
                help = temp.next;
                temp.next = node;
                node.next = help;
                break;
            }
        }
    }

    // 单链表的删除
    public void delete(int num){  // 传入需要删除的编号
        if(head.next == null){  //判断为空
            System.out.println("链表为空");
            return;
        }
        Node temp = head;
        while(true){
            if(temp.next.num == num){
                if(temp.next.next == null){  // 删除的是最后一个节点
                    temp.next = null;
                }else {
                    Node help = temp.next.next;
                    temp.next = help;
                }
                break;
            }
            if(temp.next == null){
                System.out.println("没有找到该节点");
                break;
            }
            temp = temp.next;
        }

    }

    // 修改节点
    public void revise(int num, String name){   // 传进来需要修改节点的编号，和需要修改的名字
        // 先判断是否为空
        if(head.next == null){
            System.out.println("链表为空，无法修改");
        }

        Node temp = head.next;
//         循环遍历，找到要修改的节点
        while(true){
            if(temp == null){  //链表已经遍历完了，此时temp已经指向链表最后一个元素的后面了
                System.out.println("没有找到该编号");
                break;
            }
            if(temp.num == num){
                temp.setName(name);
                break;
            }
            temp = temp.next;
        }

//        Node temp = head;
//        while(true){
//           temp = temp.next;
//           if(temp.num == num){
//               temp.setName(name);
//               break;
//           }
//           if(temp.next == null){
//               System.out.println("没有找到该节点");
//               break;
//           }
//        }

    }

    // 显示链表
    public void show(){
        // 先判断是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        // 不为空，则创建辅助节点，进行遍历
        Node temp = head.next;   //至少有一个数据了
        while(temp != null){
            System.out.println(temp);
            // 输出后，temp后移
            temp = temp.next;
        }
    }

    // 练习题，求单链表中有效节点的个数 接收一个头节点
    public static int listNodeNum(Node head){
        if(head.next == null){
            return 0;
        }
        int count = 1;
        Node temp = head.next; // 最少有一个数据了
        while(true){
            if(temp.next == null){
                return count;
            }
            temp = temp.next;
            count ++;
        }
    }

    // 练习题 找到单链表倒数第k个节点
    /**
     *     思路，编写一个方法，接收head节点，和一个 k
     *      先把链表从头到尾遍历，得到有效节点数，可以调用上面 listNodeNum()方法
     *      再从头遍历，辅助变量指向第一个有效节点，向后找 (总数-k)次，
     *      比如有3个节点，找倒数第一个，就是从一开始向后走两步
      */

    public Node getLastIndex(Node head,int k){
        if(head.next == null){  // 链表为空
            return null;
        }
        int num = listNodeNum(head);  // 得到有效数据个数
        // 进行数据的校验
        if(k <= 0 || k > num){
            return null;
        }
        Node temp = head.next;
        for (int i = 0; i < num - k; i++) {
            temp = temp.next;
        }
        return temp;
    }

    // 单链表的反转
    /**
     * 思路， 先创建一个新的头节点
     * 对原链表进行遍历，每遍历一个节点，就把它放在新链表的最前端
     * 最后，让原链表的head.next = 新链表的第一个节点
     */
    public void reverseList(Node head){  //接收原链表的头节点
        if(head.next == null || head.next.next == null){  //链表为空或者只有一个节点，不需要反转
            return;
        }
        Node temp = head.next;  // 用于遍历的辅助节点，从第一个有效节点开始
        Node help = null;    // 用于辅助遍历，保存指向的辅助节点，指向temp后
        Node head2 = new Node(0,"");   // 新节点的头
        while(temp != null){
            help =temp.next;
            temp.next = head2.next;
            head2.next = temp;
            temp = help;
        }
        head.next = head2.next;
    }

    // 逆序打印单链表
    /**
     * 遍历节点放入栈中，利用栈的先入后出的特点打印
     */
    public void reversePrint(){
        if(head.next == null){  // 链表为空
            return;
        }

        Stack<Node> nodes = new Stack<>();
        Node temp = head.next;
        while(temp != null){
            nodes.push(temp);  //将指向的节点放入栈中
            temp = temp.next;  // 后移
        }
        while (nodes.size() > 0){  // 当栈中有数据时，就出栈并打印
            System.out.println(nodes.pop());
        }
    }

}



class Node{
    public int num;
    public String name;
    public Node next;

    public Node(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node{" +
                "num=" + num +
                ", data='" + name + '\'' +
                '}';
    }
}