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));

    }
}

 

测试输出

 

源码的github地址,可以下载到本地运行

 

 

 

 

阅读更多

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