java lib 顺序 java实现顺序表

转载

小鱼儿 2023-08-19 10:45:38

文章标签 java lib 顺序 java 数据结构算法数组 文章分类 Java 后端开发

Java数据结构基础–顺序表的实现

1.定义：
把线性表中的所有表项按照其逻辑顺序依次存储到从计算机存储中指定存储位置开始的一块连续的存储空间中。
2.实现：
（1）基于java的一维数组来实现。只要定义了一个数组，就定义了一块可供用户使用的存储空间。数组的数据类型就是顺序表中的每个表项的数据类型。
（2）数组的大小要大于等于顺序表的长度。
（3）顺序表的第一个表项被存储在数组的起始位置，即下标为0的位置。第二个表项被存储在下标为1的位置上…第n个元素被存储在下表为n的位置上

java lib 顺序 java实现顺序表_数据结构

3. 完整代码：

package sequence_list;

public class Sequence {
	int size;// 最后元素所在下标
	Object data[];// 存放数组
	int maxSize = Integer.MAX_VALUE - 8;//最大数组长度
	int lenght = 0;//实际数组长度

	public Sequence(int sz) {// 构造函数
		size = -1;
		data = new Object[sz];// 创建顺序表存储数组
		lenght = sz;
	}

	public void resize(int newsize) {//扩容
		if (newsize < 0) {// 如果新的长度小于0
			System.out.println("无效的数组大小");
		}
		if (newsize != data.length && newsize <= maxSize) {// 如果新的长度与原来的不同且不大于最大长度
			Object newarray = new Object[newsize];//新建数组
			System.arraycopy(data, 0, newarray, 0, data.length);//复制数组
			data = (Object[]) newarray;//赋值新数组
		}
		lenght = data.length;//更新数组长度记录
	}
	
	public int search(Object x) {//查找关键字下标
		for(int i = 0; i <= size; i++ ) {
			if(data[i].equals(x)) {//顺序搜索
				return i;
			}
		}
		return -1;//查找失败
	}
	
	public boolean Insert(int i,Object x) {//将x插入到第i个元素前面
		if(size+1 ==data.length) {
			System.out.println("表元素已满");
			return false;
		}
		if(i<0||i>size+1) {
			System.out.println("插入位置无效");
			return false;
		}
		for(int j = size; j>=i; j--) {
			data[j+1]=data[j];//从最后一个元素开始，到第i个元素结束。依次后移一位
		}
		data[i] = x;
		size++;
		return true;
	}
	
	public boolean Remove(int i) {//根据下标索引删除元素
		if(size==-1) {
			return false;
		}else if(i<0||i>size) {
			return false;
		}
		int lenght = data.length-i-1;
		System.arraycopy(data, i+1, data, i, lenght);
		size--;
		return true;
	}
	
	public boolean Add(Object x) {//添加元素
		if(size+1==data.length) {
			System.out.println("数组元素已满");
			return false;
		}
		data[size+1]=x;
		size++;
		return true;
	}
	
	public boolean set(int i,Object x) {//修改元素值
		if(i>size) {
			System.out.println("此项未添加数据");
			return false;
		}
		data[i] = x;
		return true;
	}
	
	public Object get(int i) {//获取元素
		if(i<0||i>size) {
			return null;
		}
		return data[i];
	}
}

4.代码解析：

1.Sequence类

public class Sequence {
	int size;// 最后元素所在下标
	Object data[];// 存放数组
	int maxSize = Integer.MAX_VALUE - 8;//最大数组长度
	int lenght = 0;//实际数组长度
	}

size：记录顺序表中最后一个不为空元素的下标，表中没有元素时为-1.
data[]：是实现顺序表的数组。数据类型为Object，Object类是所有类的父类。则此顺序表可以存储不同类型的数据。
maxSize：数组的最大长度。
lenght：初始化数组时给定的长度，未初始化时为0；

2.构造函数：

public Sequence(int sz) {// 构造函数
		size = -1;
		data = new Object[sz];// 创建顺序表存储数组
		lenght = sz;
	}

size = -1：顺序表中没有元素，size数值为-1.
data = new Object[sz]：初始化数组长度为sz
lenght = sz：数组长度为sz。

3.resize扩容函数

public void resize(int newsize) {//扩容
		if (newsize < 0) {// 如果新的长度小于0
			System.out.println("无效的数组大小");
		}
		if (newsize != data.length && newsize <= maxSize) {// 如果新的长度与原来的不同且不大于最大长度
			Object newarray = new Object[newsize];//新建数组
			System.arraycopy(data, 0, newarray, 0, data.length);//复制数组
			data = (Object[]) newarray;//赋值新数组
		}
		lenght = data.length;//更新数组长度记录
	}

函数功能：初始化后数组长度不够用，调用此函数增加数组长度。
两个if语句：
（1）第一个if语句判断扩容后长度newSize是否是正数；
（2）第二个判断扩容后长度是否大于原先长度。等于或小于不操作。
Object newarray = new Object[newsize]：先创建一个长度为newSize的空数组。
System.arraycopy(data, 0, newarray, 0, data.length)：赋值操作，将data数组下标为0的位置开始，data.length个元素，复制到newarray数组去（从newarray下标为0的地方开始赋值）。

System.arraycopy(Object src,  int  srcPos, Object dest, int destPos,int length);
    src：要复制的数组(源数组)

    srcPos：复制源数组的起始位置

    dest：目标数组

    destPos：目标数组的下标位置

    length：要复制的长度

4.元素查找

public int search(Object x) {//查找关键字下标
		for(int i = 0; i <= size; i++ ) {
			if(data[i].equals(x)) {//顺序搜索
				return i;
			}
		}
		return -1;//查找失败
	}

参数：Object x：查找元素的值
for循环顺序查找，查找次数为size+1。
if判断：当元素值与顺序表的元素值相等，返回下标。
(因为字符串使用==比较返回的都是false，所以尽量用equals()函数)
for循环结束还没找到返回-1，表示没有此元素。

5.元素插入：

public boolean Insert(int i,Object x) {//将x插入到第i个元素前面
		if(size+1 ==data.length) {
			System.out.println("表元素已满");
			return false;
		}
		if(i<0||i>size+1) {
			System.out.println("插入位置无效");
			return false;
		}
		for(int j = size; j>=i; j--) {
			data[j+1]=data[j];//从最后一个元素开始，到第i个元素结束。依次后移一位
		}
		data[i] = x;
		size++;
		return true;
	}

第一个if判断数组是否已满。数组已满则不允许插入。
第二个if判断插入位置是否有效。
从最后一个赋值元素开始，依次往后挪。{for(int j = size; j>=i; j- -) }
挪动结束后将插入位置（i）赋值为x。

6.删除元素：

public boolean Remove(int i) {//根据下标索引删除元素
		if(size==-1) {
			return false;
		}else if(i<0||i>size) {
			return false;
		}
		int lenght = data.length-i-1;
		System.arraycopy(data, i+1, data, i, lenght);
		size--;
		return true;
	}

lenght = data.length-i-1：复制长度。
System.arraycopy(data, i+1, data, i, lenght)：
7.添加函数

public boolean Add(Object x) {//添加元素
		if(size+1==data.length) {
			System.out.println("数组元素已满");
			return false;
		}
		data[size+1]=x;
		size++;
		return true;
	}

if判断顺序表是否已满。
顺序表可添加元素：在下标为size+1位置赋值新元素x。（在最后一个元素后面添加新元素）

8.修改函数：

public boolean set(int i,Object x) {//修改元素值
		if(i>size) {
			System.out.println("此项未添加数据");
			return false;
		}
		data[i] = x;
		return true;
	}

不可给未赋值位置修改元素。
data[i] = x：将数组下标为i的地方赋值为x。
9.获取新元素

public Object get(int i) {//获取元素
		if(i<0||i>size) {
			return null;
		}
		return data[i];
	}

返回下标位置i的元素

测试数据：

package sequence_list;

public class Main {
	public static void main(String[] args) {
		Sequence list = new Sequence(4);//构造函数初始化
		list.Add(1);//添加
		list.Add(2);
		list.Add(3);
		System.out.println(list.get(1));//获取
		list.Insert(6,4);//插入
		System.out.println(list.get(2));
		list.Remove(2);//去除
		System.out.println(list.get(2));
		list.resize(6);//扩容
		System.out.println(list.lenght);
		System.out.println(list.get(1));
	}
}