单链表以及单链表反转

单链表

单链表的简单实现以及小练习

贴一下代码

public class SingleLikeList {
    //初始化一个链表
    Student headStudent = new Student(null, null, null);

    //获取链表头
    public Student getHead() {
        return this.headStudent;
    }

    //往链表添加数据
    public void add(Student student) {
        //为了不改变原来的链表，创建一个临时的链表
        Student temp = headStudent;
        while (true) {
            if (temp.next == null) {
                break;
            }
            //判断插入的数据在链表中是否已经存在
            if (temp.next.no == student.no) {
                System.out.println("编号已存在");
                return;
            }
            //往后移
            temp = temp.next;
        }
        temp.next = student;
    }
	
    //添加数据按序号排列
    public void addByOrder(Student student) {
        Student temp = headStudent;
        while (true) {
            if (temp.next == null) {
                break;
                //如果temp.next.no大于插入进来的no的话，那么插入的位置就找到了，就在temp.next的前面
            } else if (temp.next.no > student.no) {
                break;
            } else if (temp.next.no == student.no) {
                System.out.println("编号已存在");
                return;
            }
            temp = temp.next;
        }
        //把插入进来数据的next与temp.next挂钩
        student.next = temp.next;
        //temp.next与插入进来的数据挂钩
        temp.next = student;
    }
    //删除指定编号的节点
    public void del(int no) {
        Student temp = headStudent;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                //这里的删除只是不引用要删除的节点，直接把要删的节点前一个节点挂钩到要删除的后一个节点上
                temp.next = temp.next.next;
                return;
            }
            temp = temp.next;
        }
        System.out.println("没有这个编号");
    }
    //获取有效节点
    public Integer getCount(Student head) {
        if (head.next == null) {
            return 0;
        }
        Student temp = head;
        Integer count = 0;
        while (true) {
            if (temp.next == null) {
                break;
            }
            count++;
            temp = temp.next;
        }
        return count;
    }
    //更新指定编号的节点
    public void update(Student student) {
        Student temp = headStudent;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == student.no) {
                //把temp.next.next后的节点挂钩在student.next上
                student.next = temp.next.next;
                //temp.next挂钩student
                temp.next = student;
                return;
            }
            temp = temp.next;
        }
        System.out.println("找不到该节点");
    }
    //打出链表的数据
    public void list() {
        Student temp = headStudent;
        if (temp.next == null) {
            System.out.println("没有数据");
            return;
        }
        while (true) {
            if (temp.next == null) {
                break;
            }
            System.out.println(temp.next);
            temp = temp.next;
        }
    }
}
class Student {
    public Integer no;
    public String name;
    public Integer age;
    public Student next;

    public Student(Integer no, String name, Integer age) {
        this.no = no;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

有序添加图

删除图

一些小练习

1. 找到倒数第N个的节点

   思路为：先算出总共有多个节点，然后把总共的节点减去要查找的节点的位置，就可以算出要循环多少次才能找到其节点

   public Student findLastIndexNode(Student head, int index) {
       if (head.next == null) {
           return null;
       }
       Integer size = getCount(head);
       if (index <= 0 || index > size) {
           return null;
       }
       Student temp = head.next;
       for (int i = 0; i < size - index; i++) {
           temp = temp.next;
       }
       return temp;
   }
   

   2. 将链表反转

   思路为 : 创建一个临时的链表，将原先的链表每遍历一个就将其插到临时链表的最前面上，然后将原先的链表挂钩到临时链表上，原先的扔弃

   public void reverseLink(Student head) {
       //如果链表为空或者只有一个的时候，直接return返回
       if (head.next == null || head.next.next == null) {
           return;
       }
       Student cur = head.next;
       //定义一个临时的储存变量
       Student next = null;
       Student reverse = new Student(null, null, null);
       while (cur != null) {
           //临时储存cur.next的变量，以便等下给cur赋值
           next = cur.next;
           //把reverse.next后的节点挂钩到cur.next上
           cur.next = reverse.next;
           //reverse.next等于 挂钩了reverse.next后全部节点的cur
           reverse.next = cur;
           //cur等于原先的cur.next
           cur = next;     
       }
       head.next = reverse.next;
   }
   

   
   

   3. 从链表的尾部开始打印

利用栈的先进后出即可实现，当然也可以使用递归

    public void reversePrint(Student head) {
        if (head.next == null) {
            return;
        }
        Student cur = head.next;
        Stack<Student> students = new Stack<>();
        while (cur != null) {
            students.push(cur);
            cur = cur.next;
        }
        while (students.size() > 0) {
            System.out.println(students.pop());
        }
    }

4. 合并两个有序列表

   先创建一个临时的链表，然后比较传进来的两个链表中的编号大小，然后进行往临时链表插入，最后让传进来的其中一个链表挂钩上即可

   public void combine(Student headOne, Student headTwo) {
       if (headOne.next == null && headTwo.next == null) {
           return;
       }
       Student cur1 = headOne.next;
       Student cur2 = headTwo.next;
       Student orderLink = new Student(null, null, null);
       Student temp = orderLink;
       while (cur1 != null || cur2 != null) {
           if (cur1 == null) {
               temp.next = cur2;
               break;
           }
           if (cur2 == null) {
               temp.next = cur1;
               break;
           }
           if (cur1.no < cur2.no) {
               temp.next = cur1;
               temp = temp.next;
               cur1 = cur1.next;
           } else {
               temp.next = cur2;
               temp = temp.next;
               cur2 = cur2.next;
           }
       }
       headOne.next = orderLink.next;
   }