数据结构Java --- 线性表与ArrayList

已于 2022-11-25 17:57:34 修改
阅读量144 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 java 算法
于 2022-11-17 17:01:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62414152/article/details/127723059
版权

文章目录

一. 线性表

线性表有顺序表,链表,栈和队列
存储结构分为线性存储(线性表)和链式存储(链式表)

二. 线性表

线性表通常用数组来实现

public class Emptyfull extends RuntimeException{
    public Emptyfull(){

    }
    public Emptyfull(String message){
        super(message);
    }
}

public class FindFulException extends RuntimeException{
    public FindFulException(){

    }
    public FindFulException(String message){
        super(message);
    }
}

public class ListWrongful extends RuntimeException{
    public ListWrongful(){

    }

    public ListWrongful(String message) {
        super(message);
    }
}

import java.util.Arrays;

public class MyArrayList {
    private int[] list;
    private int usesize;
    public MyArrayList(){
        list = new int[10];
    }
    public boolean isFull(){
        return usesize >= list.length;
    }
    public boolean isEmpty(){
        return this.usesize == 0;
    }
    //默认最后加
    public void add(int data){
        if (isFull()){
            System.out.println("已满,准备扩容中...");
            this.list = Arrays.copyOf(this.list, 2 * this.list.length);
            System.out.println("扩容成功");
        }
        this.list[this.usesize] = data;
        this.usesize++;
    }
    public void add(int pos, int data) throws ListWrongful{
        if (isFull()){
            System.out.println("已满,准备扩容中...");
            list = Arrays.copyOf(list, 2 * usesize);
            System.out.println("扩容成功");
        }
        if (pos < 0 || pos > usesize) {
            throw new ListWrongful("pos不合法异常");
        }
        for (int i = usesize - 1; i >= pos; i--){
            list[i + 1] = list[i];
        }
        list[pos] = data;
        usesize++;
    }
    public boolean contains(int toFind){
        for (int i = 0; i < this.usesize; i++){
            if(toFind == this.list[i]){
                return true;
            }
        }
    return false;
    }
    public int indexOf(int toFind){
        for(int i =0; i < this.usesize; i++){
            if (toFind == list[i]){
                return i;
            }
        }
    return -1;
    }
    public int get(int pos)throws Emptyfull{
        if (isEmpty()){
            throw new Emptyfull("获取元素时线性表为空异常");
        }
        if (pos < 0 || pos >= usesize){
            throw new ListWrongful("获取元素时,pos不合法异常");
        }
    return list[pos];
    }
    public void set (int pos, int value)throws Emptyfull, ListWrongful{
        if(isEmpty()){
            throw new Emptyfull("修改元素时,pos不合法异常");
        }
        if (pos < 0 || pos >= usesize){
            throw new ListWrongful("修改元素时,pos不合法异常");
        }
        list[pos] = value;
    }
    public void remove(int toRemove)throws Emptyfull, FindFulException{
        if (isEmpty()) {
            throw new Emptyfull("删除元素时,线性表为空");
        }
        if(indexOf(toRemove) < 0){
            throw new FindFulException("删除元素时,未找到该元素");
        }
        for(int i = indexOf(toRemove); i < this.usesize - 1; i++){
            this.list[i] = list[i + 1];
        }
        this.list[usesize - 1] = 0;
        this.usesize--;
    }
    public int size(){
        return usesize;
    }
    public void clear(){
        this.usesize = 0;
    }
    public void display(){
        for(int i = 0; i < usesize; i++){
            System.out.print(list[i] + " ");
        }
        System.out.println();
    }
}

public class ArrayList {
    public static void main(String[] args) {
        MyArrayList myarraylist = new MyArrayList();
        myarraylist.add(1);
        myarraylist.add(2);
        myarraylist.add(3);
        try{
            myarraylist.add(10, 10);
        }
        catch(ListWrongful e){
            e.printStackTrace();
        }
        myarraylist.display();
    }
}

Arraylist简介

Arraylist是以泛型方式实现的,使用时需要实例化
在这里插入图片描述

import java.util.ArrayList;
public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> array = new ArrayList<Integer>();
        array.add(1);
        //array.add("wang");
    }
}

ArrayList底层是一段连续的空间,可以动态扩容,是一个动态的线性表

Arraylist 使用

Arraylist有三种构造方法

Arraylist 的常见操作

在这里插入图片描述需要注意的有:
remove方法:

//删除下标位1的元素;
        list.remove(1);
//删除元素值为1的元素
        list.remove(new Integer(1));

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //删除下标位1的元素;
        list.remove(1);
        System.out.println(list);
        //删除元素值为1的元素
        list.remove(new Integer(1));
        System.out.println(list);
    }
}

在这里插入图片描述sublist方法:

   List<Integer> list1 = list.subList(1,2);
        System.out.println(list1);
        list.set(1, 9);
        System.out.println(list+" "+list1);

在这里插入图片描述list1 截取list时是将list中对应下标元素的地址赋值给了list

迭代器Arraylist的遍历

Iterator迭代器:

        Iterator<Integer> list2 = list.iterator();
        while(list2.hasNext()){
            System.out.print(list2.next() + " ");
        }

在这里插入图片描述ListIterator 迭代器:

ListIterator<Integer> list3= list.listIterator();
while(list3.hasNext()){
System.out.print(list3.next());
}

void remove()：删除迭代器刚越过的元素

Arraylist的具体使用

小练习

1 集合的排序(Collections.sort)

Arraylist可以存放指定自定义类型
Collections.sort可以对Arraylist进行排序,自定义类需要实现Comparable.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;

class Student implements Comparable<Student>{
    String name;
    int age;
    double score;
    public Student(String name, int age, double score){
        this.age = age;
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }
}
public class Test1 {
    public static void main(String[] args) {
        ArrayList<Student> array = new ArrayList<Student>();
        array.add(new Student("e张三", 19, 78.45));
        array.add(new Student("a李四", 30, 89.34));
        array.add(new Student("r王五", 20, 90.23));
        //System.out.println(array);
        Collections.sort(array);
        Iterator<Student> array1 = array.iterator();
        while(array1.hasNext()){
            System.out.println(array1.next());
        }
    }
}

2. 删除第一个字符串中在第二个字符串中出现的字符

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        String s1 = "welcome to \"Shangxi\"";
        String s2 = "come";
        ArrayList<Character> array = new ArrayList<>();
        for(int i = 0; i < s1.length(); i++){
            char s = s1.charAt(i);
            if (!s2.contains(s + "")){
                System.out.print(s);
                array.add(s);
            }
        }

    }
}

3. 实现一个简单洗牌算法

一个牌类:

package dome;

public class Poker {
    private String decor;
    private int number;

    public String getDecor() {
        return decor;
    }

    public void setDecor(String decor) {
        this.decor = decor;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
    public Poker(String decor, int number){
        this.decor = decor;
        this.number = number;
    }
    public String toString(){
        return decor + " " + number;
    }
}

一副牌类:

package dome;
import java.util.ArrayList;
import java.util.Random;
public class Pokers {
    private String[] decors = {"♥", "♠", "♣", "♦"};
    ArrayList<Poker> pokers = new ArrayList<>();
    public ArrayList<Poker> buyPoker () {
        for(int i = 0; i < 4; i++){
            for(int j = 1; j <= 13; j++){
                pokers.add(new Poker(decors[i], j));
            }
        }
        return pokers;
    }
    public void swap(ArrayList<Poker> pokers, int i, int j){
        Poker poker = pokers.get(i);
        pokers.set(i, pokers.get(j));
        pokers.set(j, poker);
    }
    public ArrayList<Poker> shuffle(ArrayList<Poker> decors) {
        Random random = new Random();
        for(int i = decors.size() - 1; i >0; i--){
            int j = random.nextInt(i);
            swap(pokers, i, j);
        }
        return decors;
    }
    public String toString(){
        return "pokers" + pokers ;
    }
}

测试类:

package dome;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        Pokers pokers = new Pokers();
        System.out.println("买牌");
        pokers.buyPoker();
        System.out.println(pokers);
        System.out.println("洗牌");
        pokers.shuffle(pokers.pokers);
        System.out.println(pokers);
        System.out.println("发牌中...");
        //创建三个人
        ArrayList<ArrayList<Poker>> person = new ArrayList<>();
        ArrayList<Poker> person1 = new ArrayList<Poker>();
        ArrayList<Poker> person2 = new ArrayList<Poker>();
        ArrayList<Poker> person3 = new ArrayList<Poker>();
        person.add(person1);
        person.add(person2);
        person.add(person3);
        //发牌给三个人,每人五张牌
        for(int i = 0; i < 5; i++){
            for(int j = 0; j < 3; j++){
            person.get(j).add(pokers.pokers.remove(0));
            }
        }
        System.out.println("揭牌:");
        System.out.println("第一个人" + person1);
        System.out.println("第二个人" + person2);
        System.out.println("第三个人" + person3);
        System.out.println("牌堆剩余牌:" + pokers);
    }
}

在这里插入图片描述

4. 杨辉三角

import java.util.ArrayList;

public class Test {
    public static ArrayList<ArrayList<Integer>> creat (int c1){
        ArrayList<ArrayList<Integer>> yanghui = new ArrayList<>();
        ArrayList<Integer> first1 = new ArrayList();
        first1.add(1);
        yanghui.add(first1);
        System.out.println(first1);
        for (int j = 1; j < c1; j++){
            ArrayList<Integer> second = new ArrayList<>();
            second.add(1);
            for(int i = 1; i < j; i++){
                second.add(i, yanghui.get(j - 1).get(i) + yanghui.get(j - 1).get(i - 1));
            }
            second.add(1);
            yanghui.add(second);
            System.out.println(second);
        }

        return yanghui;
    }
    public static void main(String args[]){
        creat(5);
    }
}

写这个算法时存在的问题是:在第一个for循环内没有新建一个顺序表,而是在原有顺序表上进行操作,这样是不行的,因为由于使用的是同一个顺序表,所以在操作顺序表中的第i个顺序表时第i-1个顺序表也会发生变化.

在这里插入图片描述

With Order @!147
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法分析--线性表实现
04-01
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素构成的序列，元素之间存在一对一的顺序关系。线性表在实际应用中非常广泛，例如数据库中的记录、数组、队列、栈等都是其具体实例。在本资料中...
大话数据结构用Java实现3-01
12-21
在本文中，我们将深入探讨如何使用Java实现线性表的抽象数据类型，并专注于一个...随着Java知识的深入和对数据结构的进一步理解，可以考虑优化这个实现，例如使用接口进行设计，或者采用更高效的方法来合并两个线性表。
数据结构(Java版)线性表1(顺序表).ppt
11-15
线性表是数据结构中最基本也是最重要的一种数据结构形式，顺序表是一种使用顺序结构存储数据的线性表，Java 类库中的顺序表 java.util.ArrayList 类实现了顺序表的功能，可以使用它来完成学生成绩管理程序。
线性表实现源码-java
01-22
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在Java中实现线性表，通常会涉及到两种常见的存储方式：顺序存储和链式存储。 一、顺序存储结构 1. 数组实现：...
数据结构实验2 线性表.doc
06-20
（1） 理解线性表的逻辑结构、两种存储结构和数据操作； （2） 应用顺序表的基本算法实现集合A=AUB算法，应用顺序表的基本算法实现两有序顺序表的归并算法； （3） 掌握单链表的遍历、插入和删除等操作算法，实现...
计数，桶与基数排序
m0_68142120的博客
07-19 823
要进行 i(最高位的位数) 趟排序 ， 每趟排序需要将元素分派到k个桶，所以每趟排序的时间复杂度为O(n+k) 走i趟时间复杂度就为O(i(n+k)) 但桶的个数通常是固定的，执行的躺数一般又较小，所以基数排序的。如果待排序的元素数量很大，这可能会占用较多的内存空间。再次遍历待排序数组，对于数组中的每个元素，将其值减去最小值（为了使得计数数组的下标从0开始），并将计数数组中对应下标的值加1。如果待排序数组中的元素是负数，或者元素的取值范围较大，计数排序可能不适用，因为它需要额外的空间来存储计数数组。
数组算法--基本查找
2303_78660417的博客
07-20 390
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1084
可以参考以下视频。
数据结构---二叉树
weixin_47808575的博客
07-22 167
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 747
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 209
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
【数据结构】堆的实现以及建堆算法和堆排序
2301_81670477的博客
07-19 997
哈喽，各位小伙伴大家好！上期给大家讲了树，二叉树以及堆。今天带着大家实现堆这个数据结构，以及堆排序。话不多说，咱们进入正题！向大厂冲锋！
插入和选择排序
c23856的博客
07-20 443
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1110
24暑假刷题day15打卡 二叉树进阶
数据结构之细说链表
m0_73634434的博客
07-17 1085
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
数据结构~~顺序表
最新发布
TU^的博客
07-22 600
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
数据结构(5.2_3)——二叉树的存储结构
m0_65240792的博客
07-19 292
1%29%5D1。
数据结构（队列）
2401_83968713的博客
07-19 535
这么看好像两者的差别不大，但是我们在单链表结构中可以稍作改造，直接定义两个结点（头结点，尾结点）指向原链表的队头和队尾，那么在队尾入数据时就不用遍历链表，直接让尾结点->next 等于新结点，时间复杂度就变成 O(1)了。概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)⼊队列操作的时间复杂度为 O(1) ,进行出队列操作的时间复杂度为 O(n);⼊队列：进⾏插⼊操作的⼀端称为队尾。出队列：进⾏删除操作的⼀端称为队头。
数据结构和算法（刷题）- 用栈实现队列
yunshancangcang_的博客
07-19 377
出队涉及AB两栈的迁移。这是均摊时间复杂度，均摊到每次出队上就是。只用1个栈肯定不行，得用两个栈。思考：入队的时间复杂度显然是。思路：一个栈A，一个栈B。
头歌java数据结构-线性表的设计与实现
09-29
在Java中，我们还可以利用已有的数据结构类库来简化线性表的设计和实现。例如，Java提供了ArrayList和LinkedList两个类，分别基于数组和链表实现了线性表的功能，并提供了丰富的方法来操作线性表。我们可以直接使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

With Order @!147

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值