java数据结构-------线性表（一、顺序表）

在java中，线性表是一个统称，他包含了顺序表、链表、栈、队列……
今天我主要写一下顺序表。

1、线性表的简单介绍

线性表是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列………

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2、顺序表

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

说到顺序表，那么就必须要提一下ArrayList这个类，他与顺序表有着紧密的联系

3、ArrayList

1、简单介绍ArrayList

ArrayList是一个动态类型的顺序表。在集合框架中，ArrayList就是一个普通的类，但是他实现了很多接口，所以他更像是一个百宝箱。

注意：

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

2、ArrayList的使用

1、ArrayList的构造

//无参构造ArrayList
ArrayList<Integer> list = new ArrayList<>();
//设置ArrayList数组初始容量只有10个元素
ArrayList<Integer> arrayList = new ArrayList<>(10);

在实际应用中，更建议使用无参构造。

ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(25);
System.out.println(arrayList);

运行结果：
这是一个数组。
如果这样写就会报错

 arrayList.add("zhu");
 //因为我们上面已经设置了是整型类，所以放入字符串就会报错

注意：
我们在创建一个ArrayList对象的时候，必须设置类型，否则如果什么类型的数据都可以存放，那么将会产生非常大的麻烦。

3、对ArrayList的常见操作

ArrayList像是一个百宝箱，他有非常多的操作，在这里就不一一列举，只介绍几个比较常用的操作。

1、add方法

add(i): 在数组有效值后的第一位插入元素i

ArrayList<String> List = new ArrayList<>(10);
        list.add("红色");
        list.add("黄色");
        list.add("蓝色");
        list.add("绿色");
        System.out.println(list);

所谓尾插，就是在数组的最后插入元素

可以用对象.size()来获取对象中的有效元素的个数

// 获取List中有效元素个数
System.out.println(list.size());//4

2、set、get方法

set(i,k): 将i下标的元素改为k；
get(i): 获取i下标的元素

// 获取和设置index位置上的元素，注意index必须介于[0, size)间
 System.out.println(list.get(1));
 list.set(1, "猪猪");
 System.out.println(list.get(1));

运行结果：

3、add(i,k)方法

add(i,k)方法：在数组i下标插入元素k，并且i下标后面的元素往后移一位

// 在List的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
list.add(1, "你叫什么");
System.out.println(list);

运行结果：

4、remove(k)方法

// 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
//如果没在数组中找到这个元素，那么原数组不变
list.remove("黄色");
System.out.println(list);

运行结果：

5、contains()方法

// 检测list中是否包含指定元素，包含返回true，否则返回false
System.out.println(list.contains("..."));
System.out.println(list.contains("红色"));

运行结果：

6、indexOf()，lastIndexOf()方法

// 查找指定元素第一次出现的位置，并返回其下标：indexOf从前往后找，lastIndexOf从后往前找
list.add("JavaSE");
System.out.println(list.indexOf("JavaSE"));
System.out.println(list.lastIndexOf("JavaSE"));

运行结果：

7、.subList方法

注意：一定是左闭右开

//使用list中[0, 2)之间的元素构成一个新的ArrayList返回
List<String> ret = List1.subList(0, 2);
System.out.println(ret);

运行结果：

4、ArrayList的遍历

ArrayList 主要有种方式遍历：fori、foreach

ArrayList<String> list = new ArrayList<>(10);
list.add("红色");
list.add("黄色");
list.add("蓝色");
list.add("绿色");
System.out.println(list);
// 使用下标+for遍历
for (int i = 0; i < list.size(); i++) {
    System.out.print(list.get(i) + " ");
}

运行结果：

// 借助foreach遍历
for (String x : list) {
System.out.print(x + " ");
}

运行结果：

5、ArrayList的扩容机制

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容

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

6、关于ArrayList中方法的具体实现

import java.util.Arrays;

public class MyArraylist {


        public int[] elem;
        public int usedSize;//0
        //默认容量
        private static final int DEFAULT_SIZE = 10;

        public MyArraylist() {
            this.elem = new int[DEFAULT_SIZE];
        }

        public static void main(String[] args) {
                MyArraylist myArraylist = new MyArraylist();
                myArraylist.display();
        }

        /**
         * 打印顺序表:
         *   根据usedSize判断即可
         */
        public void display() {
                for (int i = 0; i < this.usedSize; i++) {
                        System.out.print(elem[i]+' ');
                }
                System.out.println();
        }

        // 新增元素,默认在数组最后新增
        public void add(int data) {
                //1、检查顺序表是不是满了
                if(isFull()){
                        this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
                }
                elem[usedSize] = data;
                this.usedSize++;

        }

//        /**
//         * 判断当前的顺序表是不是满的！
//         * @return true:满   false代表空
//         */
        public boolean isFull() {
                return size() >= this.elem.length;

        }
//
//
        private boolean checkPosInAdd(int pos) {

            return true;//合法
        }
//
//        // 在 pos 位置新增元素
        public void add(int pos, int data) {
                if(isFull()){
                        this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
                }
                if(pos<0 ||pos>this.usedSize){
                        System.out.println("pos位置不合法");
                        throw new PosWrongfulException("pos位置不合法");
                }
                //pos位置合法的情况下
                //挪动pos和pos位置之后的元素
                for (int i = this.usedSize-1; i >= pos ; i--) {
                        this.elem[i+1]=this.elem[i];
                }
                this.elem[pos] = data;
                this.usedSize++;


        }
//
//        // 判定是否包含某个元素
        public boolean contains(int toFind) {
                for (int i = 0; i < this.usedSize; i++) {
                        if(elem[i] == toFind){
                                return true;
                        }
                }
               return false;
        }
//        // 查找某个元素对应的位置
        public int indexOf(int toFind) {
                for (int i = 0; i < this.usedSize; i++) {
                        if(elem[i] == toFind){
                                return i;
                        }
                }
            return -1;
        }
//
        // 获取 pos 位置的元素
        public int get(int pos) {
                if(isEmpty()){
                        System.out.println("当前顺序表为空");
                }
                if(pos<0 ||pos>this.usedSize){
                        System.out.println("pos位置不合法");
                        throw new PosWrongfulException("pos位置不合法");
                }
                return this.elem[pos];

        }
//
        private boolean isEmpty() {
                if(this.usedSize == 0){
                        System.out.println("当前顺序表为空");
                        return true;
                }
                return false;
        }
//        // 给 pos 位置的元素设为【更新为】 value
        public void set(int pos, int value) {
                if(isEmpty()){
                        System.out.println("当前顺序表为空");
                }
                if(pos<0 ||pos>this.usedSize){
                        System.out.println("pos位置不合法");
                        throw new PosWrongfulException("pos位置不合法");
                }
                this.elem[pos] = value;


        }
//
//        /**
//         * 删除第一次出现的关键字key
//         * @param key
//         */
        public void remove(int key) {
                if(isEmpty()) {
                        throw new EmptyException("顺序表为空！");
                }
                int index = this.indexOf(key);
                if(index == -1) {
                        System.out.println("没有这个数字");
                        return;
                }
                for (int i = index; i < size()-1; i++) {
                        this.elem[i] = this.elem[i+1];
                }
                this.usedSize--;

        }
//
//        // 获取顺序表长度
        public int size() {
                return this.usedSize;

        }
//
//        // 清空顺序表
        public void clear() {
                this.usedSize = 0;


        }

}

7、杨辉三角

public List<List<Integer>> generate(int numRows) {
List<List<Integer>> ret = new ArrayList<>();
List<Integer> list1 = new ArrayList<>();
list1.add(1);//第一个内部顺序表开头第一个元素是1
ret.add(list1);//将上面的顺序表插入ret的第一个位置上

//上述第一行只有1个1，已经添加到了ret当中，接下来我们需要从第2行开始计算
for (int i = 1; i < numRows; i++) {
 //当前行
 List<Integer> curRow = new ArrayList<>();
 curRow.add(1);//一行开始的1
 //中间位置 就需要我来计算了
 List<Integer> prevRow = ret.get(i-1); //前一行
 for (int j = 1; j < i; j++) {
     int num = prevRow.get(j)+prevRow.get(j-1);
     curRow.add(j,num);
 }
 curRow.add(1);//一行结束的1
 ret.add(curRow);
}
return ret;
}

2022_9_15