Java数据结构---顺序表

最新推荐文章于 2024-06-14 15:02:13 发布

吃不胖的虾饺

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量626

点赞数 7

分类专栏：数据结构文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/m0_74760503/article/details/135886099

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

线性结构

定义：若结构是非空有限集，则有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前驱和一个直接后继。
结构特点：结点之间的逻辑关系是一对一。
① 有且仅有一个首结点和尾结点。
② 除首尾结点以外，其它结点有且仅有一个前驱结点和一个后继结点
线性结构包括：线性表、栈、队列、串、数组和广义表。

顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成
数据的增删查改。

常量定义

用一个接口实现

public class MyArrayList implements IList {

	public int[] elem;
	public int usedSize=0;//记录数组有多少个有效数据
	public static final int DEFAULT_CAPACITY=5;//默认容量
	public MyArrayList() {
		elem=new int[DEFAULT_CAPACITY];
		
	}

接口里需要实现的东西

public interface IList {
	public void add(int data);
	// 在 pos 位置新增元素
	public void add(int pos, int data) ;
	// 判定是否包含某个元素
	public boolean contains(int toFind) ;
	// 查找某个元素对应的位置
	public int indexOf(int toFind) ;
	// 获取 pos 位置的元素
	public int get(int pos) ;
	// 给 pos 位置的元素设为 value
	public void set(int pos, int value) ;
	//删除第一次出现的关键字key
	public void remove(int toRemove) ;
	// 获取顺序表长度
	public int size() ;
	// 清空顺序表
	public void clear() ;
	// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
	public void display() ;
    //判断是否满了
	boolean isFull();
	//
	boolean isEmpty();
}

接下来每个方法的具体实现

增加元素

1.尾插法

//添加元素，默认添加到数组的最后位置(尾插）
	public void add(int data) {
		//1.判断是否满了，满了要扩容
		if(isFull()) {
			elem=Arrays.copyOf(elem, 2*elem.length);
		}
		elem[usedSize]=data;
		usedSize++;
	}

2.指定位置添加法

//指定位置添加元素
	//1.移动元素，从后往前，  元素放进去
	public void add(int pos, int data) {
		//pos位置判断
		checkPosAdd(pos);
		if(isFull()) {
			elem=Arrays.copyOf(elem, 2*elem.length);
		}
		for(int i=usedSize-1;i>=pos;i--) {
			elem[i+1]=elem[i];
		}
		elem[pos]=data;
		usedSize++;
		
	}
	//检查pos是否符合标准
	//private原因只是给add方法 写
	private void checkPosAdd(int pos) {
		if(pos<0||pos>usedSize) {
			throw new PosException("pos位置为："+pos);
		}
		
	}
	public boolean isFull() {
		
		return usedSize==elem.length;//如果等于返回FALSE；
	}

查找

1.查找一个元素是否存在

public boolean contains(int toFind) {
		int i=0;
		for(i=0;i<usedSize;i++) {
			if(elem[i]==toFind)//如果是引用类型使用equal比较
				{
				return true;
				}
		}
		
			return false;
	}

2.查找指定元素的下标

//查找当前元素的下标
	public int indexOf(int toFind) {
		for(int i=0;i<usedSize;i++) {
			if(elem[i]==toFind)
				return i;
		}
		return -1;
	}

3.查找指定下标的值

@Override
	//获取pos的值
	public int get(int pos) {
		//1.判断pos
		checkPosGet(pos);
		//2.为空怎么办
		if(isEmpty()) {
			throw new EmptyException("顺序表为空");
		}
		
		return elem[pos];
	}
	private void checkPosGet(int pos) {
		if(pos<0||pos>=usedSize) {
			throw new PosException("pos位置不合法");
		}
	}
	public boolean isEmpty() {
		return usedSize==0;
	}

更改

//替换指定位置的值
	public void set(int pos, int value) {
		checkPosGet(pos);
		if(isEmpty()) {
			throw new EmptyException("顺序表为空");
		}
		elem[pos]=value;
		
	}

删除

//删除
	public void remove(int toRemove) {
		
		if(isEmpty()) {
			throw new EmptyException("顺序表为空");
		}
		int index=indexOf(toRemove);
		for(int i=index;i<usedSize-1;i++) {
			elem[i]=elem[i+1];
		}
		usedSize--;
	}

查看有多少个元素

public int size() {
		
		return usedSize;
	}

清空顺序表

//清空顺序表，防止内存泄漏
	public void clear() {
		usedSize=0;
	}

打印

//打印顺序表中所有元素
	public void display() {
		for(int i=0;i<usedSize;i++) {
			System.out.println(elem[i]+" ");
		}
		System.out.println();
		
	}

报错

//下标报错
public class PosException extends RuntimeException {
	public PosException() {
		
	}
	public PosException(String msg) {
		super(msg);
	}
}
//顺序表为空报错
public class EmptyException extends RuntimeException{
	public EmptyException() {
		
	}
	public EmptyException(String msg) {
		super(msg);
	}
     
}

以上就是我们常规的写法
然而在java中我们可以使用 ArrayList来实现以上功能

ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：在这里插入图片描述
【说明】

ArrayList是以泛型方式实现的，使用时必须要先实例化
ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者
CopyOnWriteArrayList
ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

ArrayList使用

1. ArrayList的构造
吃不胖的虾饺

public static void main(String[] args) {
// ArrayList创建，推荐写法
// 构造一个空的列表
List<Integer> list1 = new ArrayList<>();
// 构造一个具有10个容量的列表
List<Integer> list2 = new ArrayList<>(10);
list2.add(1);
list2.add(2);
list2.add(3);
// list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
// list3构造好之后，与list中的元素一致
ArrayList<Integer> list3 = new ArrayList<>(list2);
// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
List list4 = new ArrayList();
list4.add("111");
list4.add(100);
}

2. ArrayList常见操作

方法	解释
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)	尾插 c 中的元素
E remove(int index)	删除 index 位置元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空
boolean contains(Object o)	判断 o 是否在在线性表中
int indexOf(Object o)	返回第一个o所在的下标
int lastIndexOf(Object o)	返回最后一个o所在的下标
List subList(int fromIndex, int toIndex)	截取部分list

用来写顺序表：

public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("10");
		list.add("20");
		list.add("30");
		list.add("40");
		list.add("50");
		System.out.println("1:"+list);
		// 获取list中有效元素个数
		System.out.println("2:"+list.size());
		// 获取和设置index位置上的元素，注意index必须介于[0, size)间
		System.out.println("3:"+list.get(1));
		list.set(1, "100");
		System.out.println("4:"+list.get(1));
		// 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
		list.add(1, "99");
		System.out.println("5:"+list);
		// 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
		list.remove("40");
		System.out.println("6:"+list);
		// 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
		list.remove(list.size()-1);
		System.out.println("7:"+list);
		// 检测list中是否包含指定元素，包含返回true，否则返回false
		if(list.contains("40")){
		list.add("40");
		}
		// 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
		list.add("100");
		System.out.println("8:"+list);
		System.out.println("9:"+list.indexOf("100"));
		System.out.println("10:"+list.lastIndexOf("100"));
		// 使用list中[0, 4)之间的元素构成一个新的SubList返回,但是和ArrayList共用一个elementData数组
		List<String> ret = list.subList(0, 4);
		System.out.println("11:"+ret);
		list.clear();
		System.out.println("12:"+list.size());
		}

ArrayList的遍历

public static void main4(String[] args) {
		 //遍历
		 ArrayList<Integer> arrayList=new ArrayList<>();
		 arrayList.add(10);
		  arrayList.add(20);
		  arrayList.add(30);
		  //第一种
		  System.out.println(arrayList);
		  //第二种遍历 for
		  for(int i=0;i<arrayList.size();i++) {
			  System.out.print(arrayList.get(i)+" ");
		  }
		  System.out.println();
		  //3.for-each
		  for(int x:arrayList) {
			  System.out.print(x+" ");
		  }
		  System.out.println();
		  //4. 迭代器
		  Iterator<Integer> it=arrayList.iterator();
		  while(it.hasNext()) {
			  System.out.print(it.next()+" ");
		  }
		  System.out.println();
		  //5.ListIterator是Iterator的子类
		 ListIterator<Integer> it2=arrayList.listIterator();
		  while(it2.hasNext()) {
			  System.out.print(it2.next()+" ");
		  }
		  System.out.println();
		  //6.从后向前
		  ListIterator<Integer> it3=arrayList.listIterator(arrayList.size());
		  while(it3.hasPrevious()) {
			  System.out.print(it3.previous()+" ");
		  }
		  System.out.println();
		   
	 }

ArrayList的扩容机制

Object[] elementData; // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间
private static final int DEFAULT_CAPACITY = 10; // 默认容量大小
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;

if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// 获取旧空间大小
int oldCapacity = elementData.length;
// 预计按照1.5倍方式扩容
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 调用copyOf扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
// 如果minCapacity小于0，抛出OutOfMemoryError异常
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

检测是否真正需要扩容，如果是调用grow准备扩容
预估需要库容的大小
初步预估按照1.5倍大小扩容
如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
使用copyOf进行扩容

吃不胖的虾饺

关注

7
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
Java数据结构---顺序表

用一个接口实现//记录数组有多少个有效数据//默认容量接口里需要实现的东西// 在 pos 位置新增元素// 判定是否包含某个元素// 查找某个元素对应的位置// 获取 pos 位置的元素// 给 pos 位置的元素设为 value//删除第一次出现的关键字key// 获取顺序表长度// 清空顺序表// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的//判断是否满了//接下来每个方法的具体实现。
复制链接

扫一扫