通过接口定义一组线性表中的操作
public interface MyList {
int getSize(); //返回线性表中元素的个数
boolean isEmpty(); //判断线性表是否为空
void insert(int i,Object e); //在线性表的i索引值添加元素e
boolean contains(Object e); //判断线性表中是否包含元素e
int indexOf(Object e); //返回线性表中元素e的索引值
Object remove(Object e); //删除线性表中第一个与e相同的元素并返回该元素
Object remove(int i); //删除线性表中第一个索引值为i的元素并返回该元素
Object replace(int i,Object e); //使用元素e替换线性表中i位置的元素并返回旧元素
Object get(int i); //返回索引值为i的元素
boolean insertBefore(Object p,Object e); //在线性表元素p之前插入元素e
boolean insertAfter(Object p,Object e); //在线性表元素p之后插入元素e
int getMax(); //返回线性表中的最大值
int getMin(); //返回线性表中的最小值
}
通过数组实现线性表
public class MyArrayList implements MyList {
private Object[] elements; //定义数组保存数据元素
private static final int DEFAULT_CAPACITY = 26; //数组默认初始化容量
private int size; //保存数据元素个数
//构造方法
public MyArrayList() {
elements = new Object[DEFAULT_CAPACITY];
}
public MyArrayList(int initialCapacity) {
elements = new Object[initialCapacity];
}
//返回元素个数
@Override
public int getSize() {
return size;
}
//判断线性表是否为空
@Override
public boolean isEmpty() {
return size == 0;
}
//在线性表的i索引值添加元素e
@Override
public void insert(int i, Object e) {
//判断索引值i是否超出
if (i < 0 || i > size) {
throw new IndexOutOfBoundsException(i + "越界");
}
//如果数组溢满则对数组扩容
if (size >= elements.length) {
expandSpace();
}
//从i+1开始元素依次后移
for (int j = size; j > i; j--) {
elements[j] = elements[j - 1];
}
//把元素e存储到i位置
elements[i] = e;
//元素个数加一
size++;
}
//判断线性表中是否包含元素e
@Override
public boolean contains(Object e) {
return indexOf(e) >= 0;
}
//返回线性表中元素e的索引值
@Override
public int indexOf(Object e) {
//遍历数组
if (e == null) {
//线性表中用户可能添加null
for (int i = 0; i < size; i++) {
if (elements[i] == null) {
return i;
}
}
} else {
for (int i = 0; i < size; i++) {
if (e.equals(elements[i])) {
return i;
}
}
}
return -1;
}
//删除线性表中第一个与e相同的元素并返回该元素
@Override
public Object remove(Object e) {
//获得e在线性表中的索引值
int index = indexOf(e);
if (index < 0) {
return 0;
}
return remove(index);
}
//删除线性表中第一个索引值为i的元素并返回该元素
@Override
public Object remove(int i) {
//判断i是否越界
if (i < 0 || i >= size) {
throw new IndexOutOfBoundsException(i + "越界");
}
//保存即将删除的元素
Object old = elements[i];
//把i+1开始的元素依次前移
for (int j = i; j < size - 1; j++) {
elements[j] = elements[j + 1];
}
elements[size - 1] = 0;
//修改元素个数
size--;
//返回删除元素
return old;
}
//使用元素e替换线性表中i位置的元素并返回旧元素
@Override
public Object replace(int i, Object e) {
//判断索引值是否越界
if (i < 0 || i >= size) {
throw new IndexOutOfBoundsException(i + "越界");
}
//保存元素原来的值
Object old = elements[i];
//替换
elements[i] = e;
//把原来的元素值返回
return old;
}
//返回索引值为i的元素
@Override
public Object get(int i) {
//判断索引值是否越界
if (i < 0 || i >= size) {
throw new IndexOutOfBoundsException(i + "越界");
}
return elements[i];
}
//在线性表元素p之前插入元素e
@Override
public boolean insertBefore(Object p, Object e) {
//确定元素p在线性表中的位置
int index = indexOf(p);
if (index < 0) {
//元素p不存在
return false;
}
//插入元素
insert(index, e);
return true;
}
//在线性表元素p之后插入元素e
@Override
public boolean insertAfter(Object p, Object e) {
//确定元素p在线性表中的位置
int index = indexOf(p);
if (index < 0) {
//元素p不存在
return false;
}
//插入元素
insert(index + 1, e);
return true;
}
//返回线性表中的最大值
@Override
public int getMax() {
int maxIndex = (int) elements[0];
for (int i = 1; i < size; i++) {
if (maxIndex < (int) elements[i]) {
maxIndex = (int) elements[i];
}
}
return maxIndex;
}
//返回线性表中的最小值
@Override
public int getMin() {
int minIndex = (int) elements[0];
for (int i = 1; i < size; i++) {
if (minIndex > (int) elements[i]) {
minIndex = (int) elements[i];
}
}
return minIndex;
}
//重写toString方法
@Override
public String toString() {
//把线性表中的每个元素连接起来,遍历数组中的已添加的元素
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < size; i++) {
sb.append(elements[i]);
if (i < size - 1) {
sb.append(",");
}
}
sb.append("]");
return sb.toString();
}
//数组扩容
private void expandSpace() {
//定义一个更大的数组
Object[] newElements = new Object[elements.length * 2];
//把原来的数据复制到新数组中
for (int i = 0; i < elements.length; i++) {
newElements[i] = elements[i];
}
//让原来的数组名指向新的1数组
elements = newElements;
}
}
测试类
public class MyListTest {
public static void main(String[] args) {
//创建一个MyArrayList对象 测试
MyArrayList list = new MyArrayList();
//判断是否为空 测试
System.out.println(list.isEmpty());
System.out.println(list.getSize());
//添加元素 测试
list.insert(0, "Cheng");
list.insert(1, "Shuang");
list.insert(0, "2001");
System.out.println(list.isEmpty());
System.out.println(list.getSize());
//把线性表中的内容输出 测试
System.out.println(list);
//判断元素是否存在 测试
System.out.println(list.indexOf("2001"));
System.out.println(list.indexOf("Shuang"));
System.out.println(list.indexOf("2019"));
System.out.println(list.contains("2001"));
System.out.println(list.contains("2000"));
//删除 测试
list.remove("2001");
System.out.println(list);
//替换 测试
list.insert(0, "Poke");
list.insert(0, "Tao");
list.insert(0, "Jie");
list.insert(0, "Hao");
System.out.println(list);
list.replace(0, "Van");
System.out.println(list);
//返回指定索引的元素 测试
System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println(list.get(3));
//在指定的元素前面或后面插入 测试
list.insertBefore("Van", "YYDS");
System.out.println(list);
list.insertAfter("Jie", "Ge");
System.out.println(list);
list.insertAfter("AWei", "BinBin");
System.out.println(list);
/*
//最大最小值 测试
list.insert(0, 22);
list.insert(1, 26);
list.insert(2, 28);
list.insert(3, 24);
list.insert(4, 16);
list.insert(5, 12);
System.out.println(list);
System.out.println(list.isEmpty());
System.out.println(list.getMax());
System.out.println(list.getMin());
*/
}
}
实例
1、编写程序,实现以下操作:在线性表中插入一个元素,再删除指定位置的元素,分别输出插入、删除后的线性表。
2、在顺序表中设计函数实现以下操作:
(1).求顺序表中的最大值和最小值。
(2).在顺序表中删除具有最小值的元素(假设顺序表中元素都不相同) ,并由函数返回被删除元素的值,空出的位置由最后一个元素填补。
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
//创建一个MyArrayList对象
MyArrayList list = new MyArrayList();
Scanner s = new Scanner(System.in);
System.out.println("请输入线性表长度:");
int a = s.nextInt();
System.out.println("请依次输入线性表元素:");
for (int i=0;i<a;i++){
int b = s.nextInt();
list.insert(i,b);
}
System.out.print("线性表:");
System.out.println(list);
System.out.println("请输入需插入的索引值与元素:");
int c = s.nextInt();
int d = s.nextInt();
list.insert(c,d);
System.out.print("线性表:");
System.out.println(list);
System.out.println("请输入需删除的元素的索引值:");
int e = s.nextInt();
list.remove(e);
System.out.print("线性表:");
System.out.println(list);
System.out.print("最小值:");
System.out.println(list.getMin());
int h = list.indexOf(list.getMin());
list.remove(h);
System.out.println("最小值已被删除。");
System.out.println("空出的位置由最后一个元素填补。");
list.insert(h,list.get(a-2));
list.remove(a-1);
System.out.print("线性表:");
System.out.println(list);
}
}