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();
}
}