《数据结构(Java版)(第2版)》习题解答

Comparable cmp = (Comparable)element;
if (this.head==null || pareTo(this.head.data)<=0)
this.head = new Node<E>(element,this.head);//头插入
else
{
Node<E> front=null, p=this.head;
{//若已排序返回true，否则返回false
if (table==null)
return false;
for (int i=0; i<table.length-1; i++)
if (table[i]>table[i+1])
return false;
return true;
}
public static boolean isSorted(Comparable[] table)//判断对象数组是否已按升序排序
int k=1;//k是自然数，递增变化
boolean up = true;//方向向上
for (int sum=0; sum<n; sum++)//左上三角，sum表示行列的下标和
{
if (up)
for (int i=sum;i>=0;i--)
mat[i][sum-i] = k++;//k先赋值后自加
rear = rear.next;
}
}
}
【习3.2】实验2.2单链表的查找、包含、删除操作详见8.2.1。
单链表的以下查找、包含、删除等操作方法详见8.2.1顺序查找。
public Node<E> search(E element, Node<E> start) //从单链表结点start开始顺序查找指定对象
public Node<E> search(E element)//若查找到指定对象，则返回结点，否则返回null
public boolean contain(E element)//以查找结果判断单链表是否包含指定对象
public boolean remove(E element)//移去首次出现的指定对象
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;
return p.data.equals(q.data) && equals(p.next, q.next);
return false;
}
【习3.7】建立按升序排序的单链表（不带头结点）。
采用直接插入排序算法将一个结点插入到已排序的单链表中。
import dataStructure.linearList.Node;
System.out.println();
}
}
}
【习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)//判断整数数组是否已按升序排序
}
}
第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所示。
{//若已排序返回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;
}
比较两条单链表是否相等的操作也可设计为以下的递归方法：
public boolean equals(Object obj)//比较两条单链表是否相等
{
if (obj == this)
return true;
if (obj instanceof SinglyLinkedList)
{
SinglyLinkedList list = (SinglyLinkedList)obj;
else
for (int j=n-1;j>sum-n;j--)
mat[sum-j][j] = k++;
up=!up;
}
for (int i=0; i<mat.length; i++)//输出二维数组元素
{
for (int j=0; j<mat[i].length; j++)//i、j是行、列下标
System.out.print(" "+mat[i][j]);
{
p = new Node(element[i]);
p.next = create(element, i+1);
}
return p;
}
单链表的复制操作也可设计为以下的递归方法：
public SinglyLinkedList(SinglyLinkedList<E> list)//以单链表list构造新的单链表
}
【习3.4】实验2.2首尾相接地连接两条单链表。
在SinglyLinkedList单链表类中，增加替换操作方法如下。
public void concat(SinglyLinkedList list)//将指定单链表list链接在当前单链表之后
{
if (this.head==null)
this.head = list.head;
import dataStructure.linearList.SinglyLinkedList;//不带头结点的单链表类
public class SortedSinglyLinkedList<E> extends SinglyLinkedList<E>
{
public SortedSinglyLinkedList()
{
this.head = null;
if (element!=null)
this.head = create(element,0);
}
private Node<E> create(E[] element, int i)//由指定数组构造单链表，递归方法
{
Node<E>p=null;
if (i<element.length)
采用二维数组实现。二维数组中，每一条斜线上各元素下标和相等，如图0.1所示。
图1.2下标和相等的数字方阵算法描述
程序如下。
public class Upmat
{
public static void main(String args[])
{
int n=4;//阶数
int[][] mat = new int[n][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个整数最大公因数
{//复制单链表
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)
{
rear.next = new Node<E>(p.data);
rear = rear.next;
p = p.next;
}
}
}
【习3.6】实验2.2单链表构造、复制、比较等操作的递归方法。
由指定数组中的多个对象构造单链表的操作也可设计为以下的递归方法：
public SinglyLinkedList(E[] element)//由指定数组中的多个对象构造单链表
{
super();
}
public boolean add(E element) //根据指定对象的大小插入在合适位置
{
if (element==null || !(element instanceof Comparable))
return false; //不能插入null或非Comparable对象