顺序表的增删查改_Java语言编写

最新推荐文章于 2022-08-03 10:46:58 发布
最新推荐文章于 2022-08-03 10:46:58 发布
阅读量120 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44772874/article/details/97006576
版权

顺序表的增删查改

增（重点）：
在这里插入图片描述
注意：值要避免被覆盖

在增的过程中，需考虑数组容量(array.length)与已有数据个数(size)的关系：

  1. 数组容量够用,即 size<array.length
  2. 数组容量不够用，则需要扩容
    int newCapacity = array.length * 2；
    <1>.int [] newArray = new int [newCapacity]；
    <2>.for (int i=0；i < size；i++ ){
    newArray [i] = array [i]；
    }
    <3>.this.array = newArray；
    <4>.原来的数组对象，没有引用指向，编程垃圾
    扩容的空间越小，空间浪费越小；
    扩容的空间越大，需要扩容的频率越少。
	// 保证容量够用，否则进行扩容
    private void ensureCapacity() {
        if (size < array.length) {
            return;
        }

        int newCapacity = array.length * 2;
        int[] newArray = new int[newCapacity];
        for (int i = 0; i < size; i++) {
            newArray[i] = array[i];
        }
        array = newArray;
    }

	// 增
    public void pushBack(int element) {      //尾插
        ensureCapacity();
        array[size++] = element;
    }

    public void pushFront(int element) {      //头插
        ensureCapacity();
        for (int i = size; i >= 1; i--) {
            array[i]=array[i-1];
        }
        array[0]=element;
        size++;
    }

    public void insert(int index, int element) {  //中间插入
        if(index<0 || index>size){
            System.out.println("下标错误");
            return;
        }

        ensureCapacity();

        for (int i = size-1; i >= 1; i++) {
            array[i+1]=array[i];
        }
        array[index]=element;
        size++;
    }

删（重点）：
在这里插入图片描述
注意：在删前，要先判断顺序表是否为空表

    public void popBack() {           //尾删
        if(size<=0){
            System.out.println("顺序表为空");
            return;
        }
        array[--size]=0;
    }

    public void popFront() {          //头删
        if(size<=0){
            System.out.println("顺序表为空");
            return;
        }

        for (int i = 0; i < size-1; i++) {
            array[i]=array[i+1];
        }
        array[--size]=0;
    }

    public void earse(int index) {    //中间删除
        if(size<=0){
            System.out.println("顺序表为空");
            return;
        }
        if(index<0 || index>=size){
            System.out.println("下标错误");
            return;
        }
        for (int i = index+1; i < size; i++) {
            array[i-1]=array[i];
        }
        array[--size]=0;
    }

查：
循环查找，当数组里面的值与element相等时，返回此时的下标

	public int indexOf(int element) {
        for (int i = 0; i < array.length; i++) {
            if(array[i]==element){
                return i;
            }
        }
        return -1;
    }

    public int get(int index) {
        if (index < 0 || index >= size) {
            System.err.println("下标错误");
            return -1;
        }
        return array[index];
    }

改：
找到需要修改的数组下标，将给定的值赋给当前位置

	public void set(int index, int element) {
        if (index < 0 || index >= size) {
            System.err.println("下标错误");
            return;
        }
        array[index]=element;
    }

代码运行截图：
在这里插入图片描述

public class MyArrayList {
    private int[] array;
    private int size;

    public MyArrayList() {
        // 申请空间
        array=new int[2];
        // 初始化数据个数
        size=0;
    }

    // 保证容量够用，否则进行扩容
    private void ensureCapacity() {
        if(array.length>size){
            return;
        }

        int newCapacity=array.length*2;
        int[] newArray=new int[newCapacity];
        for (int i = 0; i < size; i++) {
            newArray[i]=array[i];
        }
        array=newArray;
    }

    // 增
    public void pushBack(int element) {      //尾插
        ensureCapacity();
        array[size++] = element;
    }

    public void pushFront(int element) {      //头插
        ensureCapacity();
        for (int i = size; i >= 1; i--) {
            array[i]=array[i-1];
        }
        array[0]=element;
        size++;
    }

    public void insert(int index, int element) {  //中间插入
        if(index<0 || index>size){
            System.out.println("下标错误");
            return;
        }

        ensureCapacity();

        for (int i = size-1; i >= index; i++) {
            array[i+1]=array[i];
        }
        array[index]=element;
        size++;
    }

    // 删
    public void popBack() {           //尾删
        if(size<=0){
            System.out.println("顺序表为空");
            return;
        }
        array[--size]=0;
    }

    public void popFront() {          //头删
        if(size<=0){
            System.out.println("顺序表为空");
            return;
        }

        for (int i = 0; i < size-1; i++) {
            array[i]=array[i+1];
        }
        array[--size]=0;
    }

    public void earse(int index) {    //中间删除
        if(size<=0){
            System.out.println("顺序表为空");
            return;
        }
        if(index<0 || index>=size){
            System.out.println("下标错误");
            return;
        }
        for (int i = index+1; i < size; i++) {
            array[i-1]=array[i];
        }
        array[--size]=0;
    }

    // 打印
    public void print() {
        System.out.println("打印顺序表: 当前容量: " + array.length);
        for (int i = 0; i < size; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    //查
    // 返回 element 在顺序表中的下标，如果出现多次，返回第一次出现的下标
    public int indexOf(int element) {
        for (int i = 0; i < array.length; i++) {
            if(array[i]==element){
                return i;
            }
        }
        return -1;
    }

    public int get(int index) {
        if (index < 0 || index >= size) {
            System.err.println("下标错误");
            return -1;
        }
        return array[index];
    }

    //改
    public void set(int index, int element) {
        if (index < 0 || index >= size) {
            System.err.println("下标错误");
            return;
        }
        array[index]=element;
    }

    // 删除掉某一个元素，如果出现多次，删除第一次出现的
    public void remove(int element) {
        int index = indexOf(element);
        if (index != -1) {
            earse(index);
        }
    }

    public int size() {
        return size;
    }

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

    //删除掉某一个元素，如果出现多次，删除全部
    public void removeAll(int element) {
		/* 时间:O(n^2)	时间：O(1)
		int index;
		while ((index = indexOf(element)) != -1) {
			earse(index);
		}
		*/

		/* 时间: O(n)	空间: O(n)
		int[] newArray = new int[array.length];
		int j = 0;
		for (int i = 0; i < size; i++) {
			if (array[i] != element) {
				newArray[j++] = array[i];
			}
		}
		array = newArray;
		size = j;
		*/

        // 时间：O(n)	空间：O(1)
        int j=0;
        for (int i = 0; i < size; i++) {
            if(array[i]!=element){
                array[j++]=array[i];
            }
        }
        size=j;
    }

    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.print();
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);
        list.print();	// 1 2 3
        list.pushFront(10);
        list.pushFront(20);
        list.pushFront(30);
        list.print();	// 30 20 10 1 2 3
        list.insert(3, 100);
        list.print();	// 30 20 10 100 1 2 3
        list.insert(20, 200);	// 报错

        list.earse(2);
        list.earse(2);
        list.print();	// 30 20 1 2 3
        list.popFront();
        list.popFront();
        list.popFront();
        list.print();	// 2 3
        list.popBack();
        list.popBack();
        list.print();	// 空的
        list.popBack();	// 报错
    }
}
盈盈️
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
学生信息管理系统（实现增删改查操作）Java+Servlet+HTML+CSS+数据库
12-09
数据库部分：创建表、增删改查语句的书写等。 前端部分：HTML、CSS、jQuery、JavaScript等。 编码顺序 添加项目需要使用的各种jar包 HTML 页面表单的编写 Apache方法的DBUtils编写 实体类的数据初始化（添加私有...
【数据结构】顺序表(SeqList)（增、删、查、改）详解
Elena's Blog
07-27 3039
在数据结构中，如果要访问或者修改数据结构中的数据不要直接访问，而是应该去调用它的函数来访问和修改，这样会更加规范和安全，也更方便检查出是否出现了越界等错误情况。数组越界是不一定报错的，系统对越界的检查是设岗检查。越界读（读了不属于自己的数据），一般是检查不出来的，往往并不会造成内存奔溃。越界写（缓冲区溢出）如果是修改到标志位才会被检查出来，会造成数据破坏，严重会造成内存奔溃。（系统在数组末尾后设的有标志位，越界写时，恰好修改到标志位了，就会被检查出来）
剖析：顺序表的增删改查
qq_52777887的博客
02-26 925
目录 前言： 一，什么是顺序表 1.1顺序表的两种形式 1.2动态顺序表 二，顺序表增删改查的接口实现 2.1结构体空间表示顺序表 2.2顺序表的初始化 2.2malloc新增空间 2.3增加元素 2.4删除元素 2.5查找元素 2.6指定位置元素的插入和删除 2.6.1指定位置元素的插入 2.6.2指定位置元素的删除 前言： 小伙伴们大家好，今天小编为大家带来的是关于顺序表的内容，因为我们知道顺序表其实在一些方面运用还是比较多的。虽然对于链表等结构来说，顺序表依旧.
【数据结构】顺序表的增删查改 (C语言实现)
在平淡的日子里寻找存在的价值
08-03 3656
用C语言实现的对顺序表的增删查改操作以及相关OJ题练习。
c语言用顺序表实现学生信息的添加、插入、删除、查找功能
qq_54467680的博客
10-31 8741
#include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX 20 typedef struct{ int no; //8位学号 char name[20]; //姓名 float score; //成绩 }Student; typedef struct{ Student *elem; ...
顺序表的增删查改（数据结构）
Marksky的博客
05-10 1638
顺序表的增删查改
Java+Servlet+HTML+CSS+数据库，实现的图书管理系统，完整的实现了增删改查的操作及页面之间跳转
12-23
数据库部分：创建表、增删改查语句的书写等。 前端部分：HTML、CSS、jQuery、JavaScript等。 编码顺序 添加项目需要使用的各种jar包 HTML 页面表单的编写 Apache方法的DBUtils编写 实体类的数据初始化（添加私有...
sms_java_
10-03
通过JDBC，我们可以编写SQL语句来执行增删查改操作。在学生管理系统中，可以创建一个数据库表来存储学生信息，并通过Java程序进行数据库操作。 七、Swing或JavaFX图形用户界面 为了提供友好的用户交互，学生管理...
基于Java Web的在线问卷调查系统.zip
02-16
3. **JDBC**：Java Database Connectivity，用于连接数据库，处理数据的增删查改。 4. **JSTL/EL**：JavaServer Pages Standard Tag Library和Expression Language，简化JSP页面的编程，提高可读性。 5. **Tomcat...
data_structure:数据结构问题
05-02
自定义数据结构通常涉及定义类或接口，实现特定的操作方法，如增删查改。熟练掌握这些数据结构及其操作方法对于编写高效、灵活的代码至关重要。 接下来，我们转向JAR文件。JAR文件是一种归档格式，用于将多个Java类...
顺序表和链表对文件的增删改查
10-27
顺序表和链表对文件的增删改查.数据库内的存储数据的数据类型之一。
顺序表的增删改查，顺序表
10-10
本程序的顺序表是利用数组实现的，能对数组元素进行增删改查的基本操作
顺序表实现学生学号姓名成绩的增删查改
12-25
实习二、线性表（顺序存储）及其应用（分四个实验） 实习目的：掌握顺序表的建立及基本操作。 问题：建立一个顺序表，表中元素为学生，每个学生信息包含姓名、学号和成绩三部分，对该表实现：① 输出、② 插入、③ 删除、④ 查找功能，并计算出平均成绩和总成绩
顺序表实现增删查改
weixin_41249411的博客
10-12 1403
本文摘要： 1.顺序表的概念 2.顺序表结构的定义 3.动态顺序表的操作实现   顺序表的概念 顺序表是一种数据结构，是数据的存储方式。 顺序表是改善了数组的缺点，相对增加了灵活性，使用户能够实现增删查改的操作。 顺序表分为静态顺序表和动态顺序表。                            顺序表的定义 //静态顺序表 #define N 100 typede...
学生管理系统，实现学生的增删改查
热门推荐
几多清喜
10-09 1万+
先建立一个学生类：package com.inherit; public class Student { String name; String studentId; String gender; int grade; public Student(String name,String studentId,String gender,int grade){
顺序表增、删、改、插代码实现和时间复杂度
weixin_45667236的博客
01-10 6319
顺序表基本操作的时间复杂度： 1. 新增元素： O(N) （尾插是O(1),不考虑扩容的情况） 2. 查找元素： O(N) 3. 根据下标获取/修改元素：O(1) 4. 删除元素：O(N) 5. 清除所有元素：O(1) 顺序表最主要的特点支持随机访问能力（可以高效的按照下标来操作） 尾插的时候效率也比较高（但可能会触发扩容，如果扩容了，开销就比较大了） 顺序表增删改查的代码 public cla...
C++实现顺序表基本函数以及增删查改
zhuohaiyy的博客
07-27 1333
下面的代码是我们用C++实现的顺序表，其中头插头删，尾插尾删函数可以复用Insert函数，和Erase函数。#include<iostream> #include<windows.h> #include<assert.h> using namespace std; typedef int DataType;class SeqList { public: SeqList() :
学生成绩管理系统顺序表实现
博客
11-19 1万+
#include<stdio.h> #include<stdlib.h> #define listSize 100//学生信息结构体 typedef struct { long num;//学号 char name[10];//姓名 int score;//成绩 }STUDENT;//顺序表结构体 typedef struct { STUDENT stu[l
基于JAVA的厨艺交流平台（Vue.js+SpringBoot+MySQL）
最新发布
08-01
基于Vue.js和SpringBoot的厨艺交流平台是一个功能丰富的在线社区，旨在为烹饪爱好者提供一个分享和学习烹饪技巧的平台。该平台分为管理后台和用户网页端，支持管理员和普通用户两种角色。管理后台提供对菜谱分类、菜谱信息、食材信息、商品信息和美食日志模块的全面管理功能，包括添加、编辑、删除和查询等操作。用户网页端则为用户提供了一个友好的界面，可以浏览和搜索各种菜谱，查看食材和商品信息，发表自己的美食日志，与其他用户互动交流。整个平台采用现代化的前端技术和后端框架，保证了良好的用户体验和高效的数据处理能力。 演示录屏：https://www.bilibili.com/video/BV1uz42197zu 配套教程：https://www.bilibili.com/video/BV1pW4y1P7GR
顺序表增删查改的时间自由度
04-04
顺序表的增、删、查、改操作的时间复杂度取决于数据规模和操作的位置。 增操作：在顺序表的末尾进行插入操作的...因此，顺序表的增删查改操作的时间自由度相对较低，操作的时间复杂度取决于具体的操作位置和数据规模。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值