注:本篇文章较基础,主要介绍顺序表的实现,以及对java自带ArrayList的一些简单使用,适合需要简单了解顺序表的同学。
目录
一、顺序表定义
顺序表是一种在逻辑上,物理上(即地址)都连续的存储单元存储数据元素的一种数据结构,一般是使用数组来实现。
如图:
在物理地址上,每个数据元素都占了len个大小的空间,当知道第一个元素的地址后,第k个元素的地址就是 location+(k-1)*len。
那么根据定义,可以得到顺序表的两个特点:
1️⃣ 顺序表在地址存储上是连续的。
2️⃣ 顺序表中元素是同一种数据类型。
不多bb,直接开始介绍顺序表的实现☻。
二、自定义顺序表
1.创建一个MyArrayList类
public class MyArrayList {
private int[] elem;
private int usedSize;//记录当前表内元素个数
private static final int DEFAULT_SIZE = 4;//默认容量
public MyArrayList() {
this.elem = new int[DEFAULT_SIZE];
}
}
2.disPlay()
作用:打印顺序表。
本质上就是遍历一下数组,然后逐一打印。
但我们要留意的是,如果表为空的时候,应该怎么办。
RT:
private boolean isEmpty() {
if (this.usedSize==0)
return true;
return false;
}
public void display() {
if(isEmpty()){//判断是否为空表,返回boolean
System.out.println("空表");
return;
}
for (int i = 0; i < this.usedSize; i++) {
System.out.print(this.elem[i] + " ");
}
System.out.println();
}
3.Add()
作用:在数组末尾添加元素。
首先,我们回直接想到,让 this.elem[this.usedSize] = data;但执行这行代码的前期是数组没有满,即usedSize != DEFAULT_SIZE,所以我们先写一个判断表满的函数。
public boolean isFull() {
return (size() == this.elem.length);
}
那么,接下来就很简单了,如果满了就扩容。
注:对于扩容,如果每次扩的比较小,而实际对该表的Add使用次数较多的话,就会频繁扩容,降低效率,但扩的大的话,也同样会带来空间上的浪费,所以应当基于实际,选择合适的扩容范围。
RT:
// 新增元素,默认在数组最后新增
public void add(int data) {
if (isFull()) {
this.elem =
Arrays.copyOf(this.elem, 2 * this.elem.length);
}
this.elem[this.usedSize] = data;
this.usedSize++;
}
4.Add(int pos,int data)
作用:在指定的位置(默认为前),添加元素。
仔细想想,这个函数与Add()函数类似,同样只要this.elem[this.usedSize] = data;即可完成,
不同的是,我们要先判满,然后判断pos的值是否合法。
那就先实现下pos是否合法函数。
private boolean checkPosInAdd(int pos) {
if (pos < 0 || pos >= this.usedSize) {
return false;
}
return true;//合法
}
RT:
public void add(int pos, int data) {
if (!checkPosInAdd(pos)) {
throw new PosOutInedx("下标不合法");
}
if (isFull()) {
this.elem =
Arrays.copyOf(this.elem, 2 * this.elem.length);
}
for (int i = this.usedSize; i > pos; i--) {
this.elem[i] = this.elem[i - 1];
}
this.elem[pos] = data;
this.usedSize++;
}
5.contain(int toFind)
作用:判定表内是否包含给定元素。
不难想到,只要一遍遍历即可查找到,如果给定表为有序,还可以用二分。
RT:
public boolean contains(int toFind) {
if (isEmpty()) {
return false;
}
for (int i = 0; i < this.usedSize; i++) {
if (this.elem[i] == toFind) {
return true;
}
}
return false;
}
6.indexOf(int toFind)
作用:返回给定数据在表内的下标。
我们已经会了第五个函数,这个自然轻松拿捏。同样是遍历,然后return index;
RT:
public int indexOf(int toFind) {
if (isEmpty()) {
System.out.println("空");
return -1;
}
for (int i = 0; i < this.usedSize; i++) {
if (this.elem[i] == toFind) {
return i;
}
}
return -1;
}
7.get(int pos)
作用:获取pos位置的元素。
RT:
public int get(int pos) {
if (isEmpty()) {
throw new PosOutInedx("空表");
}
if(!checkPosInAdd(pos)){
throw new PosOutInedx("pos不合法");
}
return this.elem[pos];
}
看到这里了,各位应该可以感受到数据结构的严谨了吧,我们无论些什么函数,都一定考虑合法问题、扩容问题...... 只有我们做好了这些铺垫,我们就能大大减少Bug的数量。
8. set(int pos,int value)
作用:将表内pos位置的值更新为value。
这时,相信大家第一时间可以想到,pos是否合法,表是否为空了吧?
RT:
public void set(int pos, int value) {
if(isEmpty()){
throw new PosOutInedx("空表");//自定义异常
}
if (!checkPosInAdd(pos)) {
throw new PosOutInedx("pos不合法");
}
this.elem[pos] = value;
}
9.remove(int key)
作用:删除第一次出现的key。
首先,判断是否为空表,然后可以调用indexOf(key); 直接得到key的下标index,这时,要判断index是否合法,不合法也就是表内没有这个元素,那么什么都不做,直接return。合法就从index遍历到表尾,依次覆盖。
RT:
public void remove(int key) {
if(isEmpty()){
throw new PosOutInedx("空表");
}
int index = indexOf(key);
if(index == -1){
System.out.println("没这个元素捏");
return;
}
for (int i = index; i < this.usedSize - 1; i++) {
this.elem[i] = this.elem[i + 1];
}
this.usedSize--;
}
10.size()
作用:求表长。
RT:
public int size() {
return this.usedSize;
}
11.clear()
作用:清空。
RT:
public void clear() {
this.usedSize = 0;
}
因为MyArrayList的函数都是基于usedSize值执行操作的,所以这里将usedSize置为0后,就达到了清空的效果。
三、ArrayList的使用
1.构造方法
ArrayList()
源码展示:
这其中 DEFAULTCAPACITY_EMPTY_ELEMENTDATA就是一个Object数组。
ArrayList(int )
源码:
ArrayList(Collection<? extends E> c)
这个构造方法用于,你想让构造的ArrayList用来接收继承与Collection接口的类,而这个类中的数据是继承与E的。
2.add()
当使用ArrayList()构造顺序表后,实际上并没有开辟任何空间,只有当你第一次调用了add(int)后,类内部才会自行调用函数,开辟(grow)一个可以存放10个数据的空间。
3.常用操作,举🌰
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
//1.add(E e)
list.add(1);
list.add(2);
list.add(3);
System.out.println("1、 "+list);
//2.add(int index,E e) 【index<=list.size()】
list.add(2,4);//在下标为3前插入e
System.out.println("2、 "+list);
//3.addAll(Collection<? extends E> c)
LinkedList<Integer> list2 = new LinkedList<>();
list2.add(4);
list2.add(5);
list.addAll(list2);
System.out.println("3、 "+list);
//4.remove(int index) 删除下标为index的元素
list.remove(1);
System.out.println("4、 "+list);
}
运行结果:
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
//1.add(E e)
list.add(1);
list.add(2);
list.add(3);
System.out.println("初始打印: "+list);
//5.remove(Object o) 删除遇到的第一个o
list.remove(2);
System.out.println("5、 "+list);
//6.get(int index) 获取下标为index的元素
System.out.println("6、 "+list.get(1));
//7.set(int index,E element) 将下标为index的元素,更新为element
list.set(0,3);
System.out.println("7、 "+list);
//8.contains(Object o) 是否包含
System.out.println("8、 "+list.contains(3));
//9.indexOf(Object o) 返回第一个 o 所在下标
// lastIndexOf(Object o) 返回最后一个o所在下标
System.out.println("9、 "+list.indexOf(2));
//10.subList(int fromIndex, int toIndex) 截取部分list
System.out.println("10、 "+list.subList(0,1));//左开右闭
}
执行结果:
总结
提示:这里对文章进行总结:
例如:以上就是本文的全部内容,作者水平有限,如有错误,请谅解。