java实现数组型线性表

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_20009015/article/details/80687944

线性表接口如下

package IntefaceList;

public interface IList<T> {

    /**
     * 构造一个空的线性表 进行初始化
     */
    void InitList();

    /**
     * 销毁线性表
     */
    IList DestroyList();

    /**
     * 将线性表重置为空表
     */
    IList ClearList();

    /**
     * 判断线性表是否为空
     */
    Boolean ListEmpty();

    /**
     * 返回线性表中元素的个数
     */
    Integer ListLength();

    /**
     * 获取线性表中第i个元素
     */
    T GetElem(Integer i);

    /**
     * 根据元素获取它的位序,如果有多个符合,则返回第一个,如果没有则返回0
     */
    Integer LocateElem(T e);

    /**
     * 获取该元素的上一个元素
     */
    T PriorElem(T e);
    /**
     *获取该元素的下一个元素
     */
    T NextElem(T e);
    /**
     * 在指定位置插入元素
     */
    IList ListInsert(Integer i, T e);

    /**
     *删除指定位置的元素
     */
    IList ListDelete(Integer i);

    /**
     * 遍历所有的元素
     */
    void  ListTraverse();

    /**
     * 合并两个线性表 合并不重复的元素
     */
    IList Union(IList list);

    /**
     * 按照递增顺序合并两个线性表
     */
    IList MergeList(IList list);

    /**
     * 在尾部新增元素
     */
    void add(T e);

}
实现类
package Impl;
import IntefaceList.IList;
//todo 数组型线性表
public class SequenceList<T> implements IList {
private T[] arr;
//数组当前容量(里面实际包含的元素个素)
private Integer size = 0;
//数组当前大小
private Integer Length = 4;
@Override
public void InitList() {
this.arr = (T[]) new Object[Length];
}
@Override
public IList DestroyList() {
arr = null;
size=0;
return this; //这里应该直接让list对象为null
}
@Override
public IList ClearList() {
this.arr = (T[]) new Object[Length];
size=0;
return this;
}
@Override
public Boolean ListEmpty() {
if (size > 0) {
return Boolean.TRUE;
} else {
return Boolean.FALSE;
}
}
@Override
public Integer ListLength() {
return size;
}
@Override
public Object GetElem(Integer i) {
if (i > size) {
return null;
}
return arr[i - 1];
}
@Override
public Integer LocateElem(Object e) {
for (int i = 0; i < arr.length; i++) {
if (e.equals(arr[i])) {
return i + 1;
}
}
return -1;
}
@Override
public Object PriorElem(Object e) {
for (int i = 0; i < arr.length; i++) {
if (e.equals(arr[i])) {
return arr[i - 1];
}
}
return -1;
}
@Override
public Object NextElem(Object e) {
for (int i = 0; i < arr.length; i++) {
if (e.equals(arr[i])) {
return arr[i + 1];
}
}
return -1;
}
@Override
public IList ListInsert(Integer i, Object e) {
if (i>size){
return null;
}
size++;
addsize();
for (int j = i-1; j <this.size; j++) {
arr[size-j]=arr[size-j-1];
}
arr[i - 1] = (T) e;
return this;
}
@Override
public IList ListDelete(Integer i) {
size--;
for (int i1 = i - 1; i1 + 1 < arr.length; i1++) {
arr[i1] = arr[i1 + 1];
}
return this;
}
@Override
public void ListTraverse() {
for (int i = 0; i < arr.length; i++) {
if (arr[i] != null) {
System.out.print(arr[i]);
System.out.print(",");
}
}
System.out.println();
}
/**
* 合并不重复的元素
*
* @param list
* @return
*/
@Override
public IList Union(IList list) {
for (int i = 1; i <= list.ListLength(); i++) {
if (this.LocateElem(list.GetElem(i)) == -1) {
this.add(list.GetElem(i));
}
}
return this;
}
/**
* 合并两个列表 从小到大
*
* @param list
* @return
*/
@Override
public IList MergeList(IList list) {
//已知两个表都是递增的顺序
//借助新的第三张表
T[] NewArr = (T[]) new Object[Length + list.ListLength()];
int pa = 1;
int pb = 1;
int pc = 0;
while (pa <= list.ListLength() && pb <= this.ListLength()) {
if ((int) list.GetElem(pa) <= (int) this.GetElem(pb)) {
NewArr[pc] = (T) list.GetElem(pa);
pc++;
pa++;
} else {
NewArr[pc] = (T) this.GetElem(pb);
pc++;
pb++;
}
}
while (pa<=list.ListLength()){
NewArr[pc] = (T) list.GetElem(pa);
pc++;
pa++;
}
while (pb<=this.ListLength()){
NewArr[pc] = (T) this.GetElem(pb);
pc++;
pb++;
}
this.arr=NewArr;
size=size+ list.ListLength();
return this;
}
@Override
public void add(Object e) {
arr[size] = (T) e;
size++;
addsize();
}
/**
* 数组扩容
*/
private void addsize() {
if (size / (float) arr.length > 0.75) {
Length = (int) (size * 1.5);
T[] Newarr = (T[]) new Object[(Length)];
for (int a = 0; a < arr.length; a++) {
Newarr[a] = arr[a];
}
this.arr = Newarr;
}
}
}
/*
* 可以看出来,数组型的列表,时间都花在插入和删除上了,平均每次插入或者删除一个元素,需要移动一半的元素(根据期望值算出)
* 优点是取元素快,只要知道坐标 就可以
* */

测试类
package test;
import Impl.SequenceList;
public class SequenceTest {
    public static void main(String[] args) {


        SequenceList<Integer> list=new SequenceList<>();

        list.InitList();
      //  System.out.println(list.ListLength());
//        list.ListInsert(1,9);
//        list.ListInsert(2,2);
//        list.ListInsert(3,6);
//        list.ListInsert(4,5);
//        list.ListInsert(5,9);
        list.add(3);
        list.add(5);
        list.add(88);
        list.add(111);
//        System.out.println(list.ListLength());
//
//
//        list.ListTraverse();
//        System.out.println(list.GetElem(6));
//        System.out.println(list.LocateElem(99));
//        System.out.println(list.PriorElem(99));
//        System.out.println(list.NextElem(9));
//        list.ListDelete(1);
//        list.ListTraverse();

        SequenceList<Integer> list2=new SequenceList<>();
        list2.InitList();
        list2.add(2);
        list2.add(6);
        list2.add(8);
        list2.add(9);
        list2.add(11);
        list2.add(15);
        list2.add(2000);
        //list.Union(list2);
        list.MergeList(list2);
        list.ListTraverse();

        list.ListInsert(2,99);
        list.ListTraverse();
        System.out.println(list.PriorElem(99));
        System.out.println(list.NextElem(99));

    }
}

测试输出



阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页