java---表、栈和队列

题目4

(1)假设单链表使用一个头节点实现，但无尾节点，并假设它只保留对该头节点的引用。编写一个类，包含：
a. 返回链表大小的方法。
b. 打印链表的方法。
c. 测试值x是否含于链表的方法。
d. 如果值x尚未包含于链表，添加值x到该链表的方法。
e. 如果值x包含于链表，将x从该链表中删除的方法。
(2)保持单链表以排序的顺序重做(1)。

分析：

(1) 根据c,d,e的要求，链表的大小可能会发生变化，因此，实现的顺序应该是 c,d,e,a,b。
(2)由于链表是有序的，不妨假设链表的元素按照从小到大的顺序排列，那么在搜素链表中元素的过程中就可以使用接口Comparable中的CompareTo()方法。

注：链表的这些方法的实现本质上还是C语言中的指针操作。

(1)java代码：
public class SingleList {
    private Node<Object> head;//声明一个头节点类型引用。这和C语言中的结构体类似。
    private int theSize;
    private class Node<Object>
    {
        Object data;
        Node next;
        Node(){this(null,null);} //等价于Node(){data = null;next = null;}
        Node(Object d){this(d,null);}
        Node(Object d,Node n){data = d; next = n;}
    }
    //空参数的构造函数，用于链表的初始化。
    SingleList(){init();}
    //c.测试值x是否含于链表
    private boolean contains(Object x)
    {
        Node<Object> p = head.next;
        while(p!=null){
        if(x.equals(p.data)) return true;
        else  p = p.next;
        }
        return false;
    }
    //d.如果值x尚未包含于链表，添加值x到该链表的方法。
    boolean add(Object x)
    {
        if(contains(x))
            return false;
        else
        {
            //创建一个新节点，存储x
            Node<Object> p = new Node<Object>(x);
            p.next = head.next; //值为null;
            head.next = p;
            theSize++;
        }
        return true;
    }
    //e.如果值x包含于链表，将x从该链表中删除的方法。
    boolean remove (Object x)
    {
        if(!contains(x))
            return false;
        else
            {
                //节点型变量p引用链表的第一个节点。
                Node<Object> p = head.next;
                Node<Object> trailer = head;
                while(!p.data.equals(x))
                {
                    trailer = p; //trailer节点引用跟踪p节点引用。（类似于C语言中的指针）
                    p = p.next; //trailer节点引用始终相邻于p节点引用之后。
                }
                trailer.next = p.next;//删除存储x值的那个节点。
                theSize--;
            }
        return true;
    }
    //a.返回链表大小的方法。
    int size(){return theSize;}
    //b. 打印链表的方法。
    void print()
    {
        Node<Object> p = head.next;
        while(p!=null)
        {
            System.out.println(p.data);
            p = p.next;
        }
        System.out.println();

    }
    //链表的初始化方法。
    private void init() 
    {
        theSize = 0;
        head = new Node<Object>();//创建头节点
        head.next = null;//生成一个空链表
    }

}
(2)java代码：
public class SingleListSorted {
     private int theSize;
     private Node<Comparable> head;
     private class Node<Comparable>
     {
         //声明类成员变量
         Comparable data;
         Node next;

         //构造函数
         Node(){this(null,null);}
         Node(Comparable d){this(d,null);}
         Node(Comparable d,Node n){data = d;next = n;}
     }
     //创建一个空参数的够早函数，用于链表的初始化
    SingleListSorted() {init();}
    private void init() 
    {
        //链表的长度为0
        theSize = 0;
        //创建一个空头节点
        head = new Node<Comparable>();
        head.next = null;
    }
    //测试x是否包含于链表中
    boolean contains(Comparable x)
    {
        Node<Comparable> p = head.next; 
        while(p!=null && p.data.compareTo(x)<=0)
        {
            if (x.equals(p.data)) return true;
            else p = p.next;
        }
        return false;
    }
    //如果值x尚未包含于链表，添加值x到该链表的方法。
    boolean add(Comparable x)
    {
        if(contains(x))
            return false;
        else
        {
            Node<Comparable> p = head.next;
            Node<Comparable> trialer = head; 
            while(p!=null && p.data.compareTo(x)<0)
            {
                trialer = p;//trailer节点引用跟踪p节点引用。
                p = p.next;//p继续向后移动,trailer节点引用始终相邻于p节点引用之后
            }
            //找到了插入点：trialer.next
            trialer.next = new Node<Comparable>(x);
            trialer.next.next = p;
            theSize++;
        }
        return true;
    }
    //如果值x包含于链表，将x从该链表中删除的方法
    boolean remove(Comparable x)
    {
        if(!contains(x))
            return false;
        else
        {
            Node<Comparable> p = head.next;//引用第一个节点
            Node<Comparable> trailer = head;//跟踪节点类型p引用 

                while(!x.equals(p.data))
                {
                    trailer = p;
                    p = p.next;
                }
                trailer.next = p.next;
                theSize--;  
        }
            return true;
    }
    //返回链表的大小
    int size() {return theSize;}
    //打印链表
    void print()
    {
        Node<Comparable> p = head.next;
        while(p!=null)
        {
            System.out.println(p.data+" ");
            p = p.next;
        }
        System.out.println();
    }
}