单链表笔试题

遍历单链表并返回长度

class Student{
    public int student_id;
    public String student_name;
    public int student_age;
    public Student next;

    public Student(int student_id, String student_name, int student_age) {
        this.student_id = student_id;
        this.student_name = student_name;
        this.student_age = student_age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "student_id=" + student_id +
                ", studeng_name='" + student_name + '\'' +
                ", student_age=" + student_age +
                '}';
    }
}

//遍历单链表，返回长度
    public int showStudents(Student head){
        //辅助指针
        Student temp = head.next;
        //记录长度
        int length = 0;
        //判断单链表是否为空
        if(temp==null){
            System.out.println("单链表为空");
            return -1;
        }
        //循环遍历链表
        while (true){
            if(temp==null){
                break;
            }
            System.out.println("链表"+temp);
            temp = temp.next;
            length++;
        }
        return length;
    }

查找单链表中得倒数第K个

    //查找单链表中得倒数第K个
    public Student lastOfStudent(int reciprocalNum){
        //根据上面的方法获取到的单链表的长度
        int length = showStudents(head);
        //假如链表有8个，倒数第3个，就是正数第6个
        int num = length+1-reciprocalNum;
        //判断输入的倒数第几个是否合理
        if(num>length||num<1){
            return null;
        }
        //辅助指针
        Student temp = head;
        //查出现在是正数第几个
        int lengthDouble = 0;
        if(temp.next==null){
            return null;
        }
        while(true){
            if(temp.next==null){
                break;
            }
            if(lengthDouble == num){
                System.out.println(temp.student_id);
                break;
            }
            lengthDouble++;
            temp = temp.next;
        }
        return temp;
    }

反转单链表

方法一：将原本的链表倒着放入数组中或者正着放入栈中，之后取出，重新放入一个单链表

 //单链表反转
    public SingleLinked reversalSingleLinked(SingleLinked singleLinked){
        //原有链表的头节点的后一个
        Student temp = singleLinked.head.next;
        //原有单链表的长度
        int length = singleLinked.showStudents(singleLinked.head);
        //创建一个新的单链表
        SingleLinked sl = new SingleLinked();
        //新单链表的头节点
        Student s = sl.head;
        //根据原有链表长度创造数组
        Student[] students = new Student[length];
        //遍历原有单链表并向数组中增加值
        int a = 0;
        while(true){
            if(temp==null){
                break;
            }
            students[length-a-1] = temp;
            a++;
            temp = temp.next;
        }
        //将数组中的值添加进入新的单链表
        for(int i=0;i<students.length;i++){
            students[i].next = null;
            //找到最后一个节点
            Student lastStudent = findLastHeroNode(sl);
            lastStudent.next = students[i];
        }
        return sl;
    }

//找到最后一个节点
    public Student findLastHeroNode(SingleLinked sl){
        //辅助节点
        Student help = sl.head;

        while (true){
            if(help.next==null){
                break;
            }
            help = help.next;
        }
        return help;
    }

方法二：

 //第二种反转单链表的方法
    public void reversalSecond(){
        //原有列表的头节点的下一个
        Student cur = head.next;
        //用于记录cur的下一个
        Student next = null;
        //创建一个新的链表
        Student reserverHead = new Student(0,"",0);
        while (cur!=null){
            //将cur的下一个存入next中
            next = cur.next;
            //让cur指向新链表的头部的下一个
            cur.next = reserverHead.next;
            //再让新链表的头节点指向cur
            reserverHead.next = cur;
            //cur在原链表上后移
            cur = next;
        }
        //循环结束，让原链表的头节点指向新链表的头节点的下一个，完成反转
        head.next = reserverHead.next;
    }