先介绍一下接口
package linearlist;
public interface LinearListInterface {
public boolean isEmpty();
public int size();
public Object get(int index);
public int indexOf(Object theElement);
public Object remove(int index);
public void add(int index, Object theElement);
public String toString();
}
线性表实现
package ArrayList;
import linearlist.LinearListInterface;
public class ArrayLinearList
implements LinearListInterface {
// 保护类型数据成员
private Object[] element; // 元素的对象数组
private int size; // 数组中元素的个数
// 构造函数
/** 以初始化的initialCapacity值创建数组类型的线性表
* 若initialCapacity < 1 则抛参数异常
* */
public ArrayLinearList(int initialCapacity) {
if (initialCapacity < 1) {
throw new IllegalArgumentException
("initialCapacity must be >= 1");
}
element = new Object[initialCapacity];
}
/** 重载的构造函数,缺省的initialcapacity为10 */
public ArrayLinearList() {
this(10);
}
public ArrayLinearList(LinearListInterface list) {
this(list.size());
for (int i = 0; i < list.size(); i++) {
this.add(i, list.get(i));
}
}
// 实现接口的方法
/** @仅当空表时返回真 */
public boolean isEmpty() {
return size == 0;
}
/** @返回当前线性表的元素个数 */
public int size() {
return size;
}
/** @内部方法,检查下标的合法性(介于 0 和 size - 1之间)
* 否则抛越界异常*/
void checkIndex(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException
("index = " + index + " size = " + size);
}
}
/** @返回指定位置index的元素
* @若位置序号不合理,直接抛异常 */
public Object get(int index) {
checkIndex(index);
return element[index];
}
/** @返回该表中等于给定元素的第一个元素序号
* 若无此元素则返回 -1 */
public int indexOf(Object theElement) {
// 在element[]中查找元素theElement
for (int i = 0; i < size; i++) {
if (element[i].equals(theElement)) {
return i;
}
}
// 元素未找到
return -1;
}
/** 删除表中给定位置index的元素
* 所有高于index值的元素下标减1,即左移
* @若index不合理,抛越界异常
* @否则返回要删除的元素*/
public Object remove(int index) {
checkIndex(index);
// 把待删元素缓存为removedElement(以免元素左移覆盖)
Object removedElement = element[index];
// 相关元素左移一位
for (int i = index + 1; i < size; i++) {
element[i - 1] = element[i];
// size减1, 并置为null以便于垃圾回收
}
element[--size] = null;
// 返回所删除的元素
return removedElement;
}
// 内部方法,用新长度newLength进行表空间的扩容
Object[] ChangeArrayLength(Object[] element, int newLength) {
// 以希望的长度及同样的类型分配数组空间
Object[] newArray = new Object[newLength];
// 老空间元素到新空间的拷贝a
for (int i = 0; i < size; i++) {
newArray[i] = element[i];
// 返回新空间
}
return newArray;
}
/** 按给定的位序index插入一个元素.
* 所有等于或高于index值的元素下标增1,即右移
* @若index不合理,即index不在 0 和 size之间,则抛越界异常,*/
public void add(int index, Object theElement) {
if (index < 0 || index > size) {
// 非法位置则抛出异常
throw new IndexOutOfBoundsException
("index = " + index + " size = " + size);
}
// 对于合法的 index, 确认空间
if (size == element.length) {
// 若空间不够, 按双倍大小扩容
element = ChangeArrayLength(element, 2 * size);
}
// 相关元素右移一位
//如果size=0,就不执行
for (int i = size - 1; i >= index; i--) {
element[i + 1] = element[i];
}
element[index] = theElement;
size++;
}
/** 到字符串的转换 */
public String toString() {
StringBuffer s = new StringBuffer("[");
// 添加元素到字符缓冲区
for (int i = 0; i < size; i++) {
if (element[i] == null) {
s.append("null, ");
}
else {
s.append(element[i].toString() + ", ");
}
}
if (size > 0) {
s.delete(s.length() - 2, s.length()); // 去掉最后一个 ","
}
s.append("]");
// 返回创建的字符串 s
return new String(s);
}
} // ArrayLinearList
链表实现
// Package LinkList
//class LinkList
package LinkList;
import linearlist.LinearListInterface;
public class LinkList
implements LinearListInterface {
private int size;
protected LinkNode head = new LinkNode();
protected LinkNode current = head, tail = head;
public LinkList() {
}
//复制链表
public LinkList(LinearListInterface list) {
for(int i=0;i<size;i++){
this.add(i,list.get(i));
}
}
//判断是否为空
public boolean isEmpty() {
return size == 0;
}
//返回表长
public int size() {
return size;
}
//获得指定位置的对象
public Object get(int index) {
checkIndex(index);
// 移动到希望的结点
LinkNode p = head;
for (int i = 0; i <= index; i++) {
p = p.next;
}
return p.element;
}
//找对象的位置,找到返回位置,找不到返回-1
public int indexOf(Object theElement) {
// 在链表中查找元素值为theElement的结点
LinkNode p = head.next;
int index = 0; // 当前结点的序号
while (p != null &&
!p.element.equals(theElement)) {
//移动到下一个结点
p = p.next;
index++;
}
// 确认是否找到所匹配的元素
if (p == null) {
return -1;
}
else {
return index;
}
}
/** @位置参数不合理则抛越界异常
*/
void checkIndex(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException
("index = " + index + " size = " + size);
}
}
//删除指定位置的节点
public Object remove(int index) {
checkIndex(index);
Object removedElement;
// 以p取得所希望结点的前驱结点
LinkNode p = head;
for (int i = 0; i < index; i++) {
p = p.next;
}
removedElement = p.next.element;
p.next = p.next.next; // 正式删除符合给定要求的结点
size--;
return removedElement;
}
public void removeAll() {
head.next = null;
tail = current = head;
size = 0;
}
//在指定位置的前驱插入包含对象的节点
public void add(int index, Object theElement) {
if (index < 0 || index > size) {
// 非法位置
throw new IndexOutOfBoundsException
("index = " + index + " size = " + size);
}
if (size == index) {
this.add(theElement);
}
else {
LinkNode p = head;
for (int i = 0; i < index; i++) {
p = p.next;
}
// 插入到p之后
p.next = new LinkNode(theElement, p.next);
size++;
}
}
//利用尾指针在链表最后追加数据
public void add(Object theElement) {
tail.next = new LinkNode(theElement, null);
tail = tail.next;
size++;
}
public String toString() {
StringBuffer s = new StringBuffer("[");
// 放元素到缓冲区buffer
LinkNode p = head.next;
while (p != null) {
if (p.element == null) {
s.append("null, ");
}
else {
s.append(p.element.toString() + ", ");
}
p = p.next;
}
if (size > 0) {
s.delete(s.length() - 2, s.length()); // 去掉最后一个", "
}
s.append("]");
// 返回创建的等值串
return new String(s);
}
}
//class LinkNode
package LinkList;
class LinkNode {
//数据成员
LinkNode next;
Object element;
//构造函数
public LinkNode() {
}
public LinkNode(Object element){
this.next=null;
this.element=element;
}
LinkNode(Object element, LinkNode next)
{
this.element = element;
this.next = next;
}
}
//class Test
package LinkList;
import linearlist.LinearListInterface;
public class Test {
public Test() {
}
/** 测试程序*/
public static void main(String[] args) {
// 测试缺省的构造函数
LinkList x = new LinkList();
// 测试元素个数size
System.out.println("Initial size is " + x.size());
// 测试判空isEmpty
if (x.isEmpty()) {
System.out.println("The list is empty");
}
else {
System.out.println("The list is not empty");
// 测试插入add
}
x.add(0, new Integer(2));
x.add(1, new Integer(6));
x.add(0, new Integer(1));
x.add(2, new Integer(4));
x.add(3, new Integer(17));
x.add(4, new Integer(14));
x.add(new Integer(1345));
System.out.println("List size is " + x.size());
// 测试字符串输出toString
System.out.println("The list is " + x);
//测试复制构造函数
LinkList y=new LinkList(x);
System.out.println("y is " + x);
// 测试定位indexOf
int index = x.indexOf(new Integer(4));
if (index < 0) {
System.out.println("4 not found");
}
else {
System.out.println("The index of 4 is " + index);
}
index = x.indexOf(new Integer(3));
if (index < 0) {
System.out.println("3 not found");
}
else {
System.out.println("The index of 3 is " + index);
// 测试取得操作get
}
System.out.println("Element at 0 is " + x.get(0));
System.out.println("Element at 3 is " + x.get(3));
// 测试删除remove
System.out.println(x.remove(1) + " removed");
System.out.println("The list is " + x);
System.out.println(x.remove(2) + " removed");
System.out.println("The list is " + x);
// 输出线性表当前状态
if (x.isEmpty()) {
System.out.println("The list is empty");
}
else {
System.out.println("The list is not empty");
}
System.out.println("List size is " + x.size());
}
}
Package LinkList ///