java seqlist_java_实现链表以及链表的测试类

顺序线性表的设计与实现

一、目的和要求：

(1)正确定义线性表接口；

(2)掌握线性表基本操作实现方法；

(3)能正确分析算法的时间复杂度；

(3)采用顺序线性表或链式线性表解决实际问题。

二、实验原理及内容：

(1)线性表的接口定义；

(2)顺序线性表的定义及基本操作；

(3)使用顺序线性表解决合并两个有序顺序线性表；

(4)使用链式线性表的解决约瑟夫环问题

三、实验步骤：(二选一)

1、顺序线性的定义、基本操作及解决实际问题

(1)顺序线性表的定义；

(2)顺序线性表的基本操作；

(3)合并两个有序顺序线性表

2、链式线性表的定义、基本操作及解决实际问题(自由完成)

(1)链式线性表的定义；

(2)链式线性表的基本操作；

(3)使用链式线性表解决约瑟夫环问题

四、实验过程

1、工程结构如下图所示：

2、线性表接口定义：ILinarList.java

package com.linearlist;

/**

* 接口

* 线性表的基本操作(添加、删除、修改、查询、清空、判断是否为空，求长度)

* 泛型，E代表元素类型

* @authorhhhlh

* Title:线性表接口

* Description:线性表的所有方法声明,E表示泛型，即任意类型,基本操作

* 基本操作有：添加、插入、删除、定位、查询、修改、求长度、清空、判断是否为空

*

*/

public interface ILinarList{

boolean add(E item); //在线性表末尾添加一个元素

boolean insert(int index,E item);//在线性表第index位置插入元素

E remove(int index); //删除线性表第index位置的元素

int indexOf(E item); //查询元素E所在的位置，如果不存在，返回位置为0

E get(int index); //获得index位置的元素

E set(int index,E item); //替换index位置元素为E

int size(); //获得线性表的长度，即元素个数

void clear(); //清空线性表，即删除所有的元素

boolean isEmpty(); //判断线性表是否为空

}

3、顺序线性表的定义及基本操作实现:SeqList.java

import java.lang.reflect.Array;

/*

* 顺序线性表的定义及基本操作

* 顺序线性表采用数组实现

* 顺序线性表的属性有：数组，数组空间大小，元素个数

*/

public class SeqList implements ILinarList {

// 属性

private int maxsize; // 数组空间大小

private E[] data;// 数组，存放元素

private int size; // 数组元素个数

// get和set方法

public int getMaxsize() {

return maxsize;

}

public void setMaxsize(int maxsize) {

this.maxsize = maxsize;

}

public E[] getData() {

return data;

}

public void setData(E[] data) {

this.data = data;

}

public int getSize() {

return size;

}

public void setSize(int size) {

this.size = size;

}

// 构造方法

@SuppressWarnings("unchecked")

public SeqList(Class type,int maxsize){

this.maxsize = maxsize;

this.data = (E[]) Array.newInstance(type, maxsize);

size = 0;

}

// 针对顺序线性表特意添加判断已满方法、下标是否合法方法、输出所有元素方法

/**

* 判断是否已满，满则返回true，否则返回false

*/

public boolean isFull() {

if (this.size == this.maxsize)

return true;

else

return false;

}

/**

* 判断位置是否超界，在此下标从0开始,但位置我们规定从1开始

*

* @param index即位置，从1开始计算

*/

public boolean indexOutofRange(int index) {

if (index >= 1 && index <= size)

return true;

else

return false;

}

// 以下为基本操作

/**

* 在末尾添加元素item如果满了，则不再添加，返回false如果不满，则在末尾添加，并设置元素个数为加1

*

* @param item要在末尾添加的元素

*/

public boolean add(E item) {

if (this.size == this.maxsize)

return false;

else {

this.data[this.size] = item;

this.size++;

return true;

}

}

/**

* 在index位置插入元素item 如果位置超界，则返回false表示插入失败(位置从1开始) 如果元素已满，则返回false表示插入失败

* 否则先将插入位置及后面的元素全部后移 插入新的元素 元素个数增加1 返回true表示插入成功

*

* @param index即位置，从1开始计算

* @param item插入的元素

*/

public boolean insert(int index, E item) {

/// size表示当前位置，

if (index <= 0 || index > this.size + 1 || this.size == this.maxsize)

return false;

for (int i = size + 1; i >= index; i--)

data[i] = data[i - 1];

data[index - 1] = item;

this.size++;

return true;

}

/**

* 删除位置为index的元素 如果位置不合法，则不删除，返回null 否则记录删除元素，然后将后面的元素前移 修改元素个数为减1

*

* @param index删除的位置，从1开始计算

*/

public E remove(int index) {

if (index <= 0 || index > size)

return null;

else {

E old = data[index - 1];

for (int i = index - 1; i < size; i++)

data[i] = data[i + 1];

this.size--;

return old;

}

}

/**

* 查询元素所在的位置(首次出现)，位置从1开始计算

*

* @param item要查询的元素

* @return如果为0表示查询失败，否则为元素所在的位置

*/

public int indexOf(E item) {

for (int i = 1; i <= size; i++)

if (data[i - 1].equals(item))

return i;

return 0;

}

/**

* 返回位置为index处的元素，如果位置不合法，返回null

*

* @param index位置，从1开始

* @return如果位置不合法，返回null，否则返回index位置处元素

*/

/**

* 替换位置index处的元素为item，并返回原来的元素，如果位置不合法，返回null

*

* @param index替换的位置

* @param item新元素

* @return原来位置处的元素，如果位置不合法，返回null

*/

public E set(int index, E item) {

if (index <= 0 || index > size)

return null;

E old = data[index - 1];

data[index - 1] = item;

return old;

}

/**

* 获得取元素个数

*

* @return返回的元素个数

*/

public int size() {

return this.size;

}

/**

* 清空线性表，将所有元素置为null

*/

public void clear() {

for (int i = 0; i < size; i++)

data[i] = null;

this.size = 0;

}

/**

* 判断线性表是否为空

*

* @return如果为空，返回true，否则false

*/

public boolean isEmpty() {

if (size > 0)

return false;

else

return true;

}

}

4、测试顺序线性表基本操作实现

(1)测试add()方法

package com.test.chapter02;

import com.linearlist.SeqList;

public class TestSeqList1 {

public static void main(String[] args) {

SeqList seqlist = new SeqList(Integer.class, 3);

printseq(seqlist);

seqlist.add(10);

seqlist.add(20);

seqlist.add(30);

seqlist.add(40);

seqlist.add(50);

printseq(seqlist);

}

private static void printseq(SeqList seqlist) {

if(seqlist.getSize()<1){

System.out.println("没有任何元素");

return;

}

System.out.println("顺序线性表中的元素如下：");

for(int i=1;i<=seqlist.getSize();i++){

Integer e = seqlist.getData()[i-1];

System.out.print(e+" ");

}

System.out.println();

}

}

(2)测试insert()方法

package com.test.chapter02;

import com.linearlist.SeqList;

public class TestSeqList2 {

public static void main(String[] args) {

SeqList seqlist = new SeqList(Integer.class, 10);

seqlist.insert(1,10);

seqlist.insert(3,20);

seqlist.insert(1,30);

seqlist.insert(1,40);

seqlist.insert(4,50);

printseq(seqlist);

}

private static void printseq(SeqList seqlist) {

if(seqlist.getSize()<1){

System.out.println("没有任何元素");

return;

}

System.out.println("顺序线性表中的元素如下：");

for(int i=1;i<=seqlist.getSize();i++){

Integer e = seqlist.getData()[i-1];

System.out.print(e+" ");

}

System.out.println();

}

}

(3)测试remove()方法

package com.test.chapter02;

import com.linearlist.SeqList;

public class TestSeqList3 {

public static void main(String[] args) {

SeqList seqlist = new SeqList(Integer.class, 3);

seqlist.add(10);

seqlist.add(20);

seqlist.add(30);

seqlist.add(40);

seqlist.add(50);

printseq(seqlist);

Integer x = seqlist.remove(1);

if (x !=null)

System.out.println("成功删除元素：" + x);

else

System.out.println("删除失败");

printseq(seqlist);

}

private static void printseq(SeqList seqlist) {

if (seqlist.getSize() < 1) {

System.out.println("没有任何元素");

return;

}

System.out.println("顺序线性表中的元素如下：");

for (int i = 1; i <= seqlist.getSize(); i++) {

Integer e = seqlist.getData()[i - 1];

System.out.print(e +" ");

}

System.out.println();

}

}

(4)测试indexOf()方法

package com.test.chapter02;

import com.linearlist.SeqList;

public class TestSeqList4 {

public static void main(String[] args) {

SeqList seqlist = new SeqList(Integer.class, 10);

seqlist.add(10);

seqlist.add(20);

seqlist.add(10);

seqlist.add(40);

seqlist.add(50);

printseq(seqlist);

Integer x = 10;

int loc = seqlist.indexOf(x);

if(loc==0){

System.out.println("没有查询到元素");

}

else

{

System.out.println(x+"所在的位置为："+loc);

}

}

private static void printseq(SeqList seqlist) {

if (seqlist.getSize() < 1) {

System.out.println("没有任何元素");

return;

}

System.out.println("顺序线性表中的元素如下：");

for (int i = 1; i <= seqlist.getSize(); i++) {

Integer e = seqlist.getData()[i - 1];

System.out.print(e +" ");

}

System.out.println();

}

}

(5)测试get()方法

package com.test.chapter02;

import com.linearlist.SeqList;

public class TestSeqList5 {

public static void main(String[] args) {

SeqList seqlist = new SeqList(Integer.class, 10);

seqlist.add(10);

seqlist.add(20);

seqlist.add(10);

seqlist.add(40);

seqlist.add(50);

printseq(seqlist);

int loc = 0;

Integer x = seqlist.get(loc);

if(x==null){

System.out.println("位置不合法，获取元素失败");

}

else

{

System.out.println(loc+"位置的元素为："+x);

}

}

private static void printseq(SeqList seqlist) {

if (seqlist.getSize() < 1) {

System.out.println("没有任何元素");

return;

}

System.out.println("顺序线性表中的元素如下：");

for (int i = 1; i <= seqlist.getSize(); i++) {

Integer e = seqlist.getData()[i - 1];

System.out.print(e +" ");

}

System.out.println();

}

}

(6)测试set()方法

package com.test.chapter02;

import com.linearlist.SeqList;

public class TestSeqList6 {

public static void main(String[] args) {

SeqList seqlist = new SeqList(Integer.class, 10);

seqlist.add(10);

seqlist.add(20);

seqlist.add(10);

seqlist.add(40);

seqlist.add(50);

printseq(seqlist);

// 替换

Integer x = seqlist.set(1, 60);

if (x ==null)

System.out.println("位置不合法，替换失败");

else {

System.out.println("替换成功");

printseq(seqlist);

}

// 求元素个数

int len = seqlist.size();

System.out.println("线性表元素个数为：" + len);

// 判断是否为空

if (seqlist.isEmpty())

System.out.println("线性表为空");

else

System.out.println("线性表不为空");

// 线性表清空

seqlist.clear();

printseq(seqlist);

// 判断是否为空

if (seqlist.isEmpty())

System.out.println("线性表为空");

else

System.out.println("线性表不为空");

}

private static void printseq(SeqList seqlist) {

if (seqlist.getSize() < 1) {

System.out.println("没有任何元素");

return;

}

System.out.println("顺序线性表中的元素如下：");

for (int i = 1; i <= seqlist.getSize(); i++) {

Integer e = seqlist.getData()[i - 1];

System.out.print(e +" ");

}

System.out.println();

}

}

5、合并两个有序顺序线性表

package com.test.chapter02;

import com.linearlist.SeqList;

/*

* 合法两个有序顺序线性表La和Lb到新的有序顺序线性表

*/

public class TestSeqList7 {

public static void main(String[] args) {

SeqList La = new SeqList(Integer.class, 10);

La.add(1);

La.add(5);

La.add(8);

La.add(10);

La.add(20);

printseq(La);

SeqList Lb = new SeqList(Integer.class, 10);

Lb.add(2);

Lb.add(4);

Lb.add(7);

Lb.add(9);

printseq(Lb);

SeqList Lc = new SeqList(Integer.class, La.getSize()+Lb.getSize());

mergeTwoSeqList(La,Lb,Lc);

printseq(Lc);

}

/**

* 合并两个有序顺序线性表

* @param la第一个有序顺序线性表

* @param lb第二个有序顺序线性表

* @param lc第三个有序顺序线性表，即合并后的有序顺序线性表

*/

public static void mergeTwoSeqList(SeqList l1, SeqList l2,SeqListl3) {

int i = 1, j = 1;

while (i <= l1.getSize() && j <= l2.getSize()) {

if (l1.get(i) <= l2.get(j)) {

l3.add(l1.get(i++));

}else{

l3.add(l2.get(j++));

}

}

while(i<=l1.getSize())

{

l3.add(l1.get(i));

i++;

}

while(j<=l2.getSize())

{

l3.add(l2.get(j));

j++;

}

}

}

/**

* 输出线性表所有元素

* @param seqlist要输出的线性表

*/

private static void printseq(SeqList seqlist) {

if (seqlist.getSize() < 1) {

System.out.println("没有任何元素");

return;

}

System.out.println("顺序线性表中的元素如下：");

for (int i = 1; i <= seqlist.getSize(); i++) {

Integer e = seqlist.getData()[i - 1];

System.out.print(e +" ");

}

System.out.println();

}

}