{
this.head = null;
if (element!=null)
this.head = create(element,0);
}
private Node<E> create(E[] element, int i)//由指定数组构造单链表，递归方法
{
Node<Biblioteka >p=null;if (i<element.length)
return p.data.equals(q.data) && equals(p.next, q.next);
return false;
}
【习3.7】建立按升序排序的单链表（不带头结点）。
采用直接插入排序算法将一个结点插入到已排序的单链表中。
import dataStructure.linearList.Node;
图1.2下标和相等的数字方阵算法描述
程序如下。
public class Upmat
{
public static void main(String args[])
{
int n=4;//阶数
int[][] mat = new int[n][n];
int k=1;//k是自然数，递增变化
boolean up = true;//方向向上
{
rear.next = new Node<E>(p.data);
rear = rear.next;
p = p.next;
}
}
}
【习3.6】实验2.2单链表构造、复制、比较等操作的递归方法。
由指定数组中的多个对象构造单链表的操作也可设计为以下的递归方法：
public SinglyLinkedList(E[] element)//由指定数组中的多个对象构造单链表
}
}
}
【习1.1】实验0.5找出一个二维数组的鞍点
【习1.2】实验0.6复数类。
【习1.3】实验0.8图形接口与实现图形接口的类
第2章
【习2.1】实验1.1判断数组元素是否已按升序排序。
程序见例1.4的SortedArray.java。
public static boolean isSorted(int[] table)//判断整数数组是否已按升序排序
for (int sum=0; sum<n; sum++)//左上三角，sum表示行列的下标和
{
if (up)
for (int i=sum;i>=0;i--)
mat[i][sum-i] = k++;//k先赋值后自加
else
for (int i=0;i<=sum;i++)
mat[i][sum-i] = k++;
}
}
第3章
【习3.1】习2-5图2.19的数据结构声明。
table数组元素为单链表，声明如下：
SinglyLinkedList<E> table[]
【习3.2】习2-6如果在遍历单链表时，将p=p.next语句写成p.next=p，结果会怎样？
使p.next指向p结点自己，改变了结点间的链接关系，丢失后继结点，如图2.1所示。
{//复制单链表
this.head = null;
if (list!=null && list.head!=null)
{
this.head = new Node(list.head.data);
Node<E> p = list.head.next;
Node<E> rear = this.head;
while (p!=null)
return equals(this.head, list.head);
}
return false;
}
private boolean equals(Node<E> p, Node<E> q)//比较两条单链表是否相等，递归方法
{
if (p==null && q==null)
return true;
if (p!=null && q!=null)
else
{
Node<E> p=this.head;
while (p.next!=null)
p = p.next;
p.next = list.head;
}
}
【习3.5】实验2.2复制单链表。
在SinglyLinkedList单链表类中，增加构造方法如下。
public SinglyLinkedList(SinglyLinkedList<E> list)//以单链表list构造新的单链表
}
比较两条单链表是否相等的操作也可设计为以下的递归方法：
public boolean equals(Object obj)//比较两条单链表是否相等
{
if (obj == this)
return true;
if (obj instanceof SinglyLinkedList)
{
SinglyLinkedList list = (SinglyLinkedList)obj;
{
super();
}
public boolean add(E element) //根据指定对象的大小插入在合适位置
{
if (element==null || !(element instanceof Comparable))
return false; //不能插入null或非Comparable对象
}
【习2.2】实验1.3用递归算法求两个整数的最大公因数。
public class Gcd
{
public static int gcd(int a, int b)//返回a,b的最大公因数，递归方法
{
if(b==0)
return a;
if(a<0)
return gcd(-a,b);
if(b<0)
return gcd(a,-b);
while(p!=null && pareTo(p.data)>0)
{
front = p;//front是p的前驱结点
{//若已排序返回true，否则返回false
if (table==null)
return false;
for (int i=0; i<table.length-1; i++)
if (table[i].compareTo(table[i+1])>0)
return false;
return true;
{
this.head = copy(list.head);
}
private Node<E> copy(Node<E> p)//复制单链表，递归方法
{
Node<E>q=null;
if (p!=null)
{
q = new Node(p.data);
q.next = copy(p.next);
}
return q;
if (obj==null || element==null)
return false;
Node<E> p=this.head;
while (p!=null)
{
if (obj.equals(p.data))
{
p.data = element;
return true;
}
p = p.next;
}
return false;
【习3.3】实验2.2单链表的替换操作。
在SinglyLinkedList单链表类中，增加替换操作方法如下。
public boolean replace(Object obj, E element)//将元素值为obj的结点值替换为element
{//若替换成功返回true，否则返回false，O(n)
return gcd(b,a%b);
}
public static void main(String args[])
{
int a=12,b=18,c=24;
System.out.println("gcd("+a+","+b+","+c+")="+gcd(gcd(a,b),c));//获得3个整数最大公因数
import dataStructure.linearList.SinglyLinkedList;//不带头结点的单链表类
public class SortedSinglyLinkedList<E> extends SinglyLinkedList<E>
{
public SortedSinglyLinkedList()
public Node<E> search(E element)//若查找到指定对象，则返回结点，否则返回null
public boolean contain(E element)//以查找结果判断单链表是否包含指定对象
public boolean remove(E element)//移去首次出现的指定对象
if (element!=null && element.length>0)
{
this.head = new Node(element[0]);
