实验1线性表的基本操作
1.1顺序表
在顺序表类SeqList中增加以下成员方法:
· public void removeAll(Tkey)//删除所有关键字为key的数据元素，要求所有
元素一次移动到位
public void replaceFirst(TkeyTx)//将第一个关键字为key的元素替换为X public int searchLast(Tkey)/查找最后一个关键字为key的元素，返回其索引号
代码：
以下是修改后的SeqList类的实现：
public class SeqList<T> {
private Object[] element;
private int size;
private final int capacity;
public SeqList(int capacity) {
this.capacity = capacity;
element = new Object[capacity];
size = 0;
}
// 在顺序表的末尾添加元素
public boolean add(T data) {
if (size < capacity) {
element[size++] = data;
return true;
}
return false;
}
// 删除所有关键字为key的元素
public void removeAll(T key) {
int k = 0;
for (int i = 0; i < size; i++) {
if (!element[i].equals(key)) {
element[k++] = element[i];
}
}
size = k;
}
// 将第一个关键字为key的元素替换为X
public void replaceFirst(T key, T x) {
for (int i = 0; i < size; i++) {
if (element[i].equals(key)) {
element[i] = x;
return;
}
}
}
// 查找最后一个关键字为key的元素
public int searchLast(T key) {
for (int i = size - 1; i >= 0; i--) {
if (element[i].equals(key)) {
return i;
}
}
return -1;
}
// 打印顺序表元素
public void print() {
for (int i = 0; i < size; i++) {
System.out.print(element[i] + " ");
}
System.out.println();
}
}测试代码：
public class Test {
public static void main(String[] args) {
SeqList<Integer> list = new SeqList<>(10);
list.add(1);
list.add(2);
list.add(3);
list.add(2);
list.add(4);
list.add(5);
list.add(2);
list.add(6);
list.add(2);
list.add(7);
list.print(); // 1 2 3 2 4 5 2 6 2 7
list.removeAll(2);
list.print(); // 1 3 4 5 6 7
list.replaceFirst(4, 8);
list.print(); // 1 3 8 5 6 7
System.out.println(list.searchLast(3)); // 1
System.out.println(list.searchLast(9)); // -1
}
}运行结果：
1.2单链表
在单链表SinglyList中增加以下成员方法:
·public Nodelast()//返回最后一个结点
·public Node prev(Nodep)//返回p结点的前驱结点
·public SinglyListsubList(intiintlen)//返回从第i个结点开始，长度为len的子表，深拷贝
答案：
代码：
public class SinglyList<T> {
// 单链表的节点类
private static class Node<T> {
T data;
Node<T> next;
Node(T data, Node<T> next) {
this.data = data;
this.next = next;
}
}
private Node<T> head; // 头结点
private int size; // 链表的长度
// 构造方法，创建一个空链表
public SinglyList() {
head = null;
size = 0;
}
// 在链表末尾添加一个元素
public void add(T elem) {
if (head == null) {
head = new Node<T>(elem, null);
} else {
Node<T> p = head;
while (p.next != null) {
p = p.next;
}
p.next = new Node<T>(elem, null);
}
size++;
}
// 删除链表中的第一个与elem相等的元素
public boolean remove(T elem) {
if (head == null) {
return false;
}
if (head.data.equals(elem)) {
head = head.next;
size--;
return true;
}
Node<T> p = head;
while (p.next != null && !p.next.data.equals(elem)) {
p = p.next;
}
if (p.next != null) {
p.next = p.next.next;
size--;
return true;
}
return false;
}
// 返回链表的长度
public int size() {
return size;
}
// 返回最后一个结点
public Node<T> last() {
if (head == null) {
return null;
}
Node<T> p = head;
while (p.next != null) {
p = p.next;
}
return p;
}
// 返回p结点的前驱结点
public Node<T> prev(Node<T> p) {
if (head == null || p == head) {
return null;
}
Node<T> q = head;
while (q != null && q.next != p) {
q = q.next;
}
return q;
}
// 返回从第i个结点开始，长度为len的子表，深拷贝
public SinglyList<T> subList(int i, int len) {
if (i < 0 || i > size || len <= 0 || i + len > size) {
throw new IndexOutOfBoundsException();
}
SinglyList<T> sublist = new SinglyList<T>();
Node<T> p = head;
for (int j = 0; j < i; j++) {
p = p.next;
}
for (int j = 0; j < len; j++) {
sublist.add(p.data);
p = p.next;
}
return sublist;
}
// 测试输出
public static void main(String[] args) {
SinglyList<Integer> list = new SinglyList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println("size: " + list.size());
Node<Integer> last = list.last();
System.out.println("last element: " + last.data);
}
}运行结果：
