在IDEA上对链表oj题的测试方法

以链表的基本操作为栗子

• 新建一个类（ListNode），里面包含两个成员变量，三个构造方法（不同的oj里面的方法略有不同，此处将三个都写出来，是为了可以反复使用）

 

public class ListNode {
    int val;
    ListNode next;

    public ListNode(){

    }

    public ListNode(int val){
        this.val = val;
    }

    public ListNode(int val,ListNode next){
        this.val = val;
        this.next = next;
    }
}

 

 

• 新建一个单链表的类 （singleList），编写一个add的方法，以便插入元素，最后将toString方法重写，看起来就更加贴切

public class SingleList {
    ListNode head;

    public void add(int val){
        ListNode newNode = new ListNode(val);

        if (head == null){
            head = newNode;
        }else{
            ListNode cur = head;
            while(cur.next != null){
                cur = cur.next;
            }
            cur.next = newNode;
        }
    }

    @Override
    public String toString() {
        ListNode cur = head;
        String s = "[";
        while(cur.next != null){
            s += cur.val;
            s += ",";
            cur = cur.next;
        }
        s += cur.val;
        s += "]";
        return s;
    }
}

•  最后建一个TestListNode的类，来进行最后测试的操作

public class TestListNode {
 //   已知一条链表，不知道其长度的情况下
 //   通过遍历，打印链表的每个元素
    public void print(ListNode head){
        ListNode cur = head;
        while(cur != null){
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
 //   通过遍历，找到链表的最后一个结点
    public void lastNode(ListNode head){
        ListNode cur = head;
        while (cur.next != null){
            cur = cur.next;
        }
        System.out.println(cur.val);
    }
//    通过遍历，找到链表的倒数第二个结点
    public void penultimateNode(ListNode head){
        ListNode cur = head;
        while(cur.next.next != null){
            cur = cur.next;
        }
        System.out.println(cur.val);
    }
//    通过遍历，找到链表的第 n 个结点（链表的长度 >= n)
    public void unknownNode(ListNode head,int n){
        ListNode cur = head;
        n -= 1;
        while(n != 0){
            cur = cur.next;
            n--;
        }
        System.out.println(cur.val);
    }
//    通过遍历，计算链表中元素的个数
    public void size(ListNode head){
        ListNode cur = head;
        int count = 0;
        while(cur != null){
            count++;
            cur = cur.next;
        }
        System.out.println(count);
    }
//    通过遍历，找到链表中是否包含某个元素
    public void containsElement(ListNode head,int n){
        ListNode cur = head;
        while(cur != null){
            if (cur.val == n){
                System.out.println("这个链表里面包含" + n + "元素！");
                break;
            }
            cur = cur.next;
        }
        if (cur == null){
            System.out.println("这个链表里面不包含" + n + "元素！");
        }
    }
    public static void main(String[] args) {

        SingleList s = new SingleList();
        s.add(1);
        s.add(2);
        s.add(3);
        s.add(4);
        s.add(5);
        s.add(6);
        s.add(7);
        System.out.println(s);

        TestListNode st = new TestListNode();

        st.print(s.head);                       // 1 2 3 4 5 6 7
        st.lastNode(s.head);                    // 7
        st.penultimateNode(s.head);             // 6
        st.unknownNode(s.head,5);            //  5
        st.unknownNode(s.head,6);            //  6
        st.unknownNode(s.head,4);            //  4
        st.size(s.head);                        //  7
        st.containsElement(s.head,2);        //  包含
        st.containsElement(s.head,10);       //  不包含
    }
}

 

 在此处就可以对在oj中不能调试的这个功能进行完善