52.【Java 数据结构——线性表】(一)

简介: 52.【Java 数据结构——线性表】

1.什么是线性表?

线性表是最基本、最简单、也是最常用的一种数据结构。线性表(linear list)是数据结构的一种,一个线性表是n个具有相同特性的数据元素的有限序列

线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的(注意,这句话只适用大部分线性表,而不是全部。比如,循环链表逻辑层次上也是一种线性表(存储层次上属于链式存储,但是把最后一个数据元素的尾指针指向了首位结点)。

2.线性表的定义:

线性表(linear list)是数据结构的一种,一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号,其具体含义在不同的情况下一般不同。(直接前驱和直接后继)

3.线性表图解:

有限:数据元素是有限个的

序列:小朋友排队是有顺序的.

4.线性表的长度:

线性表的元素个数n就是线性表的长度: 当n=0时,那么就是空表.i称为序列!

线性表的长度不等于数组的长度,通常数组的长度大于等于线性表的长度:

5.线性表的顺序储存结构:

5.1定义:

顺序储存结构:是指的时一段地址连续的储存单元依次存储线性表的数据元素.

5.2顺序储存结构的插入元素:

注意事项:

阐述:

表长+1并不是说数组的长度+1,而是指的时数据元素+1

方法:

public static int[] InsertNumber(int []nums,int idex,int number){
        if(nums.length==5){    //假设数组的最大为5个,假如说表的长度等于5,返回null
            return null;
        }
        if(idex==nums.length-1){  //假如说插入元素的下表在线性表中的最后一个,那么就执行下面这样的循环
            nums[idex]=number;    //插入
            return nums;
        }
        if(idex<nums.length-1){   //假如说插入元素的下表不是线性表的最后一个,那么就执行一下程序
            for(int k=nums.length-1;k>idex;k--){
                nums[k]=nums[k-1];   //插入元素后的所有元素后退
            }
            nums[idex ]=number;   //插入
            return nums;
        }
        return null;
    }
}

主函数:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
public class hello {
    public static void main(String []avgs) {
        int []nums=new int[4];
        nums[0]=1;  //线性表
        nums[1]=2;  //线性表
        nums[2]=3;  //线性表
        int []arr=InsertNumber(nums,0 ,5);  //数组 插入坐标 插入元素
        for(int i=0;i<arr.length;i++){    //打印输出
            System.out.println(arr[i]);
        }
    }

5.3线性表的顺序结构的删除元素:

删除算法的思路:

(1)如果删除位置不合理,抛出异常;(2)取出删除元素;

(3)从删除元素位置开始遍历至到最后一个元素位置,分别将它们都向前移动一个位置;

(4)表长减1。

方法:

public static int[] InsertNumber(int []nums,int idex){
        if(nums.length==0){    //假设线性表为0
            return null;
        }
        if(idex>nums.length){  //假如说删除的数据大于线性表长度
            return null;
        }
        if(idex<nums.length){
            for(int k=idex;k<nums.length-1;k++)  //中间条件目的是为了防止线性表超限
            {
                nums[k]=nums[k+1];
            }
            return nums;
        }
        return null;
    }
}

主函数:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
public class hello {
    public static void main(String []avgs) {
        int []nums=new int[4];
        nums[0]=1;  //线性表
        nums[1]=2;  //线性表
        nums[2]=3;  //线性表
        int []arr=InsertNumber(nums,1 );  //数组 插入坐标 插入元素
        for(int i=0;i<arr.length;i++){    //打印输出
            System.out.println(arr[i]);
        }
    }

*切记哈,删除和插入的是线性表=====并不是数组*

5.4线性表顺序储存结构的优缺点

6.顺序存储结构的全部用法:(ArrayList)

判断是否清空

public boolean isEmpty(){
        return N==0;
    }

线性表的长度`

public int getLength(){
        return N;
    }

索引所在的值

public T getNumber(int i){
        return elem[i];
    }

在线性表中插入元素

public void Insert(T t){
        elem[N++]=t;
    }

在指定索引i处增加t

public void add(int idex,T t){
            for(int i=N;i>idex;i--){
                elem[i]=elem[i-1];
            }
            N++;
            elem[idex]=t;
        }
}

删除指定索引i的值,并返回删除索引的值

public T remove(int i){
        T count=elem[i];
        for(int idex=i;idex<N-1;idex++){
            elem[idex]=elem[idex+1];
        }
        //元素个数-1
        N--;
        return count;
    }

查找元素T,在链表中出现的第一个位置

public int Find(T t){
        for(int i=0;i<N;i++){
            if(elem[i].equals(t)){
                return i;
            }
        }
        return -1;
    }

数组的扩容

public void resize(int size){
        T [] newelem=(T[]) new Object[size];
        for(int i=0;i<N;i++){
            newelem[i]=elem[i];  //老数组赋值给新数组
        }
        elem=newelem;   //新数组赋值给老数组
    }

`类方法展示:

public class SquenceList <T>{
    private T[]elem;  //定义一个数据类型为T的数组
   //代表线性表中存放的元素个数
    private int N;
    public SquenceList(int capacity){ //构造方法
        //初始化数组
        this.elem=(T[])new Object[capacity];
        this.N=0;
    }
    //实现对数组的扩容处理
    public void resize(int size){
        T [] newelem=(T[]) new Object[size];
        for(int i=0;i<N;i++){
            newelem[i]=elem[i];  //老数组赋值给新数组
        }
        elem=newelem;   //新数组赋值给老数组
    }
    //清空线性表
    public void clear(){
        N=0;
    }
    //判断线性表是否为空
    public boolean isEmpty(){
        return N==0;
    }
    //求线性表的长度
    public int getLength(){
        return N;
    }
    //获取索引所在的值:
    public T getNumber(int i){
        return elem[i];
    }
    //向线性表中插入元素
    public void Insert(T t){
        elem[N++]=t;
    }
    //在指定索引i处增加t
   public void add(int idex,T t){
            for(int i=N;i>idex;i--){
                elem[i]=elem[i-1];
            }
            N++;
            elem[idex]=t;
        }
    //删除指定索引i的值,并返回删除索引的值
    public T remove(int i){
        T count=elem[i];
        for(int idex=i;idex<N-1;idex++){
            elem[idex]=elem[idex+1];
        }
        //元素个数-1
        N--;
        return count;
    }
    //查找元素T,在链表中出现的第一个位置
    public int Find(T t){
        for(int i=0;i<N;i++){
            if(elem[i].equals(t)){
                return i;
            }
        }
        return -1;
    }
}


相关文章
|
2月前
|
存储 人工智能 算法
【数据结构-算法】:数据结构和算法的一些个人总结(Java实现)
【数据结构-算法】:数据结构和算法的一些个人总结(Java实现)
56 0
|
2月前
|
存储 算法 Java
Java数据结构与算法-java数据结构与算法(二)
Java数据结构与算法-java数据结构与算法
99 1
|
5天前
|
存储 安全 Java
Java程序员必须掌握的数据结构:HashMap
HashMap底层原理实现是每个Java Boy必须掌握的基本技能,HashMap也是业务开发每天都需要遇到的好伙伴。如此基础且核心的底层数据结构,JDK也给其赋予了线程安全的功能,我们来看看~
20 1
Java程序员必须掌握的数据结构:HashMap
|
5天前
|
存储 安全 Java
Java并发编程中的高效数据结构:ConcurrentHashMap解析
【4月更文挑战第25天】在多线程环境下,高效的数据访问和管理是至关重要的。Java提供了多种并发集合来处理这种情境,其中ConcurrentHashMap是最广泛使用的一个。本文将深入分析ConcurrentHashMap的内部工作原理、性能特点以及它如何在保证线程安全的同时提供高并发性,最后将展示其在实际开发中的应用示例。
|
11天前
|
存储 供应链 Java
《Java 简易速速上手小册》第3章:Java 数据结构(2024 最新版)
《Java 简易速速上手小册》第3章:Java 数据结构(2024 最新版)
8 1
|
18天前
|
Java API
编码的奇迹:Java 21引入有序集合,数据结构再进化
编码的奇迹:Java 21引入有序集合,数据结构再进化
16 0
|
2月前
|
存储 C语言
【数据结构】线性表的链式存储结构
【数据结构】线性表的链式存储结构
18 0
|
2月前
|
XML 存储 算法
Java数据结构与算法-java数据结构与算法(五)
Java数据结构与算法-java数据结构与算法
49 0
|
2月前
|
存储 设计模式 算法
【C/C++ 数据结构 线性表】深入理解与实现栈:从基础到应用的全面探索
【C/C++ 数据结构 线性表】深入理解与实现栈:从基础到应用的全面探索
53 0
|
2月前
|
缓存 安全 Java
Java并发编程中的高效数据结构 - ConcurrentHashMap
本文将深入探讨Java并发编程中的一种高效数据结构 - ConcurrentHashMap。我们将详细介绍ConcurrentHashMap的基本原理,包括其设计思路、实现方式以及如何在多线程环境下提供高效的并发访问。同时,我们还将通过实例代码演示如何使用ConcurrentHashMap来优化并发程序的性能。