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<E>{
    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<E> implements ILinarList<E> {
	// 属性
	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<E> 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<Integer> seqlist = new SeqList<Integer>(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<Integer> 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<Integer> seqlist = new SeqList<Integer>(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<Integer> 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<Integer> seqlist = new SeqList<Integer>(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<Integer> 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<Integer> seqlist = new SeqList<Integer>(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<Integer> 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<Integer> seqlist = new SeqList<Integer>(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<Integer> 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<Integer> seqlist = new SeqList<Integer>(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<Integer> 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<Integer> La = new SeqList<Integer>(Integer.class, 10);
       La.add(1);
       La.add(5);
       La.add(8);
       La.add(10);
       La.add(20);
       printseq(La);
       SeqList<Integer> Lb = new SeqList<Integer>(Integer.class, 10);
       Lb.add(2);
       Lb.add(4);
       Lb.add(7);
       Lb.add(9);
       printseq(Lb);
       SeqList<Integer> Lc = new SeqList<Integer>(Integer.class, La.getSize()+Lb.getSize());
       mergeTwoSeqList(La,Lb,Lc);
       printseq(Lc);
    }
 
    /**
     * 合并两个有序顺序线性表
     * @param la第一个有序顺序线性表
     * @param lb第二个有序顺序线性表
     * @param lc第三个有序顺序线性表，即合并后的有序顺序线性表
     */
    public static void mergeTwoSeqList(SeqList<Integer> l1, SeqList<Integer> l2,SeqList<Integer>l3) {
       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<Integer> 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();
    }
}