线性表接口LList:
package com.clarck.datastructure.linear;
/**
* 使用顺序表类SeqList求解约瑟夫环问题。
*
* @author clarck
*
*/
public class Josephus {
/**
* 创建约瑟夫环并求解
*
* @param number
* 参数指定环长度
* @param start
* 起始位置
* @param distance
* 计数
*/
public Josephus(int number, int start, int distance) {
// 采用顺序表存储约瑟夫环的元素,元素类型是字符串,构造方法参数指定顺序表容量
SeqList<String> list = new SeqList<String>(number);
for (int i = 0; i < number; i++) {
list.append((char) ('A' + i) + "");
}
System.out
.print("约瑟夫环(" + number + "," + start + "," + distance + "),");
System.out.println(list.toString());
int i = start;
while (list.length() > 1) {
// 计数按循环规律变化,顺序表可看作是环形结构
i = (i + distance - 1) % list.length();
// 删除指定位置对象
System.out.print("删除" + list.remove(i).toString() + ",");
System.out.println(list.toString());
}
System.out.println("被赦免者是" + list.get(0).toString());
}
public static void main(String args[]) {
new Josephus(5, 0, 2);
}
}
顺序表(线性表的顺序存储结构)类,实现线性表接口,T是泛型参数,指定任意类
package com.clarck.datastructure.linear;
/**
* 顺序表(线性表的顺序存储结构)类,实现线性表接口,T是泛型参数,指定任意类
*
* @author clarck
*
* @param <T>
*/
public class SeqList<T> implements LList<T> {
/**
* 对象数组,保护成员
*/
protected Object[] element;
/**
* 顺序表长度,记载元素个数
*/
protected int len;
/**
* 默认构造方法,创建默认容量的空表
*/
public SeqList() {
this(64);
}
/**
* 构造方法,创建容量为size的空表
*
* @param size
*/
public SeqList(int size) {
this.element = new Object[size];
this.len = 0;
}
/**
* 判断顺序表是否空,若空返回true,O(1)
*/
@Override
public boolean isEmpty() {
return this.len == 0;
}
/**
* 返回顺序表长度,O(1)
*/
@Override
public int length() {
return this.len;
}
/**
* 返回第i(≥0)个元素。若i<0或大于表长则返回null,O(1)
*/
@SuppressWarnings("unchecked")
@Override
public T get(int i) {
if (i >= 0 && i < this.len) {
return (T) this.element[i];
}
return null;
}
/**
* 设置第i(≥0)个元素值为x。若i<0或大于表长则抛出序号越界异常;若x==null,不操作
*/
@Override
public void set(int i, T x) {
if (x == null)
return;
if (i >= 0 && i < this.len) {
this.element[i] = x;
} else {
throw new IndexOutOfBoundsException(i + ""); // 抛出序号越界异常
}
}
/**
* 顺序表的插入操作 插入第i(≥0)个元素值为x。若x==null,不插入。 若i<0,插入x作为第0个元素;若i大于表长,插入x作为最后一个元素
*/
@Override
public void insert(int i, T x) {
if (x == null)
return;
// 若数组满,则扩充顺序表容量
if (this.len == element.length) {
// temp也引用elements数组
Object[] temp = this.element;
// 重新申请一个容量更大的数组
this.element = new Object[temp.length * 2];
// 复制数组元素,O(n)
for (int j = 0; j < temp.length; j++) {
this.element[j] = temp[j];
}
}
// 下标容错
if (i < 0)
i = 0;
if (i > this.len)
i = this.len;
// 元素后移,平均移动len/2
for (int j = this.len - 1; j >= i; j--) {
this.element[j + 1] = this.element[j];
}
this.element[i] = x;
this.len++;
}
/**
* 在顺序表最后插入x元素
*/
@Override
public void append(T x) {
insert(this.len, x);
}
/**
* 顺序表的删除操作 删除第i(≥0)个元素,返回被删除对象。若i<0或i大于表长,不删除,返回null。
*/
@SuppressWarnings("unchecked")
@Override
public T remove(int i) {
if (this.len == 0 || i < 0 || i >= this.len) {
return null;
}
T old = (T) this.element[i];
// 元素前移,平均移动len/2
for (int j = i; j < this.len - 1; j++) {
this.element[j] = this.element[j + 1];
}
this.element[this.len - 1] = null;
this.len--;
return old;
}
/**
* 删除线性表所有元素
*/
@Override
public void removeAll() {
this.len = 0;
}
/**
* 查找,返回首次出现的关键字为key元素
*/
@SuppressWarnings("unchecked")
@Override
public T search(T key) {
int find = this.indexOf(key);
return find == -1 ? null : (T) this.element[find];
}
/**
* 顺序表比较相等 比较两个顺序表是否相等 ,覆盖Object类的equals(obj)方法,O(n)
*/
@SuppressWarnings("unchecked")
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj instanceof SeqList) {
SeqList<T> list = (SeqList<T>) obj;
// 比较实际长度的元素,而非数组容量
for (int i = 0; i < this.length(); i++) {
if (!this.get(i).equals(list.get(i))) {
return false;
}
}
return true;
}
return false;
}
/**
* 顺序查找关键字为key元素,返回首次出现的元素,若查找不成功返回-1
*
* @param key
* 可以只包含关键字数据项,由T类的equals()方法提供比较对象相等的依据
* @return
*/
public int indexOf(T key) {
if (key != null) {
for (int i = 0; i < this.len; i++) {
// 对象采用equals()方法比较是否相等
if (this.element.equals(key)) {
return i;
}
}
}
return -1;
}
// 返回顺序表所有元素的描述字符串,形式为“(,)”,覆盖Object类的toString()方法
public String toString() {
String str = "(";
if (this.len > 0)
str += this.element[0].toString();
for (int i = 1; i < this.len; i++)
str += ", " + this.element[i].toString();
return str + ") "; // 空表返回()
}
}
线性表的顺序表示和实现,测试类:
package com.clarck.datastructure.linear;
/**
* 线性表的顺序表示和实现
*
* @author clarck
*
*/
public class SeqList_test {
public static void main(String args[]) {
//空表
SeqList<String> lista = new SeqList<String>(4);
System.out.println("lista is empty: "+lista.toString());
//扩容
for (int i = 5; i >= 0; i--) {
lista.insert(i, new String((char)('A' + i) + ""));
}
System.out.println("lista insert finished: "+lista.toString());
lista.set(3, new String((char)(lista.get(3).charAt(0) + 32) + ""));
System.out.println("lista set 3 : "+lista.toString());
lista.remove(0);
System.out.println("lista remove 0 position: "+lista.toString());
lista.remove(3);
System.out.println("lista remove 3 position: "+lista.toString());
}
}
运行结果如下:
复制代码
lista is empty: ()
lista insert finished: (A, F, B, E, C, D)
lista set 3 : (A, F, B, e, C, D)
lista remove 0 position: (F, B, e, C, D)
lista remove 3 position: (F, B, e, D)
转载自
https://www.cnblogs.com/tanlon/p/4026655.html