线性表之顺序存储（JAVA）

线性表实现比较简单，难点主要在排序。

参考资料：数据结构与算法（Java语言版）

1.先写个接口List

import Exception.outOfBoundaryException;

public interface List {

public int getSize();//获得当前线性表元素个素

public boolean isEmpty();//判断是否为空

public boolean contains(Object e);//判断是否包含一个元素

public int indexOf(Object e);//根据元素找下标

public boolean insert(Object e);//插入一个元素到最后一个元素后面

public void insertByIndex(int i,Object e) throws outOfBoundaryException;//根据位置插入元素

public boolean insertBefore(Object e,Object e1);//插入到一个元素的后面

public boolean insertAfter(Object e,Object e1);//插入到一个元素的前面

public Object remove(int i) throws outOfBoundaryException;//移除第i个元素

public boolean remove(Object e);//移除元素e

public Object replace(int i ,Object e) throws outOfBoundaryException;//代替第i个元素

public Object get(int i)throws outOfBoundaryException;//获取第i个元素

public void showList();//打印线性表

public void sort1();
}

这个outOfBoundaryException异常是自己写的，下表不存在时抛出的异常，代码如下

public class outOfBoundaryException extends RuntimeException{
@SuppressWarnings("serial")
public outOfBoundaryException (String err) {
super(err);
}
}

2.比较器接口

如果你的线性表只存储基本数据类型的话就不用写比较器，如果想要存自定义类型并实现排序功能的话就要用到比较器。

public interface Strategy {
//判断对象是否相等
public boolean equal(Object o1,Object o2);
//比较两个对象
public int compare(Object o1,Object o2);
}

自定义学生类

public class Student{
//学生ID
private int id ;
//学生姓名
private String name;
//年龄
private int age;
//性别
private Gender gender;

public Student(int id) {
super();
this.id = id;
}

public Student(int id, String name) {
super();
this.id = id;
this.name = name;
}

@Override
public boolean equals(Object o1) {
if (this == o1)
return true;
if (o1 == null)
return false;
if (getClass() != o1.getClass())
return false;
Student other = (Student) o1;
if (id != other.id)
return false;
return true;
}

@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}

再写个子类实现这个接口

public class ComparaByStudentId implements Strategy{

@Override
public boolean equal(Object o1, Object o2) {
if(o1 instanceof Student && o2 instanceof Student){
Student s1 = (Student)o1;
Student s2 = (Student)o2;
return s1.getId()==s2.getId();
}
return false;
}

@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Student && o2 instanceof Student){
Student s1 = (Student)o1;
Student s2 = (Student)o2;
return s1.getId()-s2.getId();
}
else {
return o1.toString().compareTo(o2.toString());
}
}
}

3.实现链表

public class ListArray implements List{

//数组默认大小
private final int LENGTH = 10;
//数据元素比较策略
private Strategy s1;
//线性表中数据元素的个数
private int size;
//数据元素数组
private Object[] elements;
//用于冒泡排序临时存储变量
private Object temp;

//用于冒泡排序结束标志
private int swap;

public ListArray() {
size = 0;
elements = new Object[LENGTH];
}

public ListArray(Strategy s1) {
this.s1 = s1;
size = 0;
elements = new Object[LENGTH];
}

@Override
public int getSize() {
return size;
}

@Override
public boolean isEmpty() {

return size==0;
}

@Override
public boolean contains(Object e) {
for(int i=0;i<size;i++){
if(elements[i].equals(e))
return  true;
}
return false;
}

@Override
public int indexOf(Object e) {
for(int i=0;i<size;i++){
if(elements[i].equals(e))
return i;
}
return -1;
}

@Override
public boolean insert(Object e) {
if(size>=elements.length)
expandSpace();
elements[size]=e;
size++;
return true;
}

@Override
public void insertByIndex(int i, Object e) throws outOfBoundaryException {
if(i<0||i>size)
throw new outOfBoundaryException("错误，执行的插入序号越界");
if(size>=elements.length)
expandSpace();
for(int j=size;j>i;j--)
elements[j]=elements[j-1];
elements[i]=e;
size++;

}

private void expandSpace() {
Object[] a = new Object[LENGTH*2];
for(int i=0;i<size;i++)
a[i]=elements[i];
elements=a;
}

@Override
public boolean insertBefore(Object e, Object e1) {
int i = indexOf(e);
if(i<0)
return false;
insertByIndex(i, e1);
return true;
}

@Override
public boolean insertAfter(Object e, Object e1) {
int i = indexOf(e);
if(i<0)
return false;
insertByIndex(i+1, e1);
return true;
}

@Override
public Object remove(int i) throws outOfBoundaryException {

if(i<0||i>size)
throw new outOfBoundaryException("错误，执行的插入序号越界");
Object o1 = elements[i];
for(int j=i;j<size-1;j++)
elements[j]=elements[j+1];
elements[--size]=null;
return o1;
}

@Override
public boolean remove(Object e) {
int i = indexOf(e);
if(i<0) return false;
remove(i);
return true;
}

@Override
public Object replace(int i, Object e) throws outOfBoundaryException {
if(i<0||i>size)
throw new outOfBoundaryException("错误，执行的插入序号越界");
Object o1 = elements[i];
elements[i]=e;
return o1;
}

@Override
public Object get(int i) throws outOfBoundaryException {
return elements[i];
}

@Override
public void showList() {
for(int i=0;i<size;i++){
System.out.println(elements[i]);
}
}

@Override
public void sort1() {
for(int i=0;i<size;i++){
swap = 0;
for(int j=1;j<size;j++){
if(s1.compare(elements[j-1], elements[j])>0){
temp = elements[j-1];
elements[j-1] = elements[j];
elements[j] =temp;
}
swap = 1;
}
if (swap == 0)
break;
}
}
}

4.main测试

public class main1 {
public static void main(String[] args) {
ListArray l1 = new ListArray(new ComparaByStudentId());
//测试用例自由发挥，这里只写一例
l1.insert(new Student(1));
l1.insert(new Student(5));
l1.insert(new Student(6));
l1.insert(new Student(4));
l1.insert(new Student(3));
l1.insert(new Student(2));
l1.insert(new Student(7));
l1.insert(new Student(10));
l1.insert(new Student(11));
l1.insert(new Student(12));

l1.sort1();
l1.showList();
}
}

5.小结

1.比较器的思想值得学习。

2.逻辑比较简单就不写那么多注释了，哪里看不懂可以留言

3.用Java写数据结构感觉好傻。。。

最近买了算法导论，励志要成为高级算法狗，哈哈！