表结构

最新推荐文章于 2023-11-17 15:21:08 发布
最新推荐文章于 2023-11-17 15:21:08 发布
阅读量629 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30095631/article/details/103858986
版权

抽象数据类型

    抽象数据类型(abstract data type,ADT)，表示带有一些操作的对象集合。这是一种数学抽象。对于操作的具体实现，ADT不做任何解释。比如表、集合、图都有各自的ADT,对于图ADT，可以有增加、删除、包含这样的操作，又或者有取并集，取交集，查找这样的操作，至于有哪些操作，具体如何实现则不关心。

表ADT

    将形如 A 0 , A 1 , A 2 , A 3 , … … , A N − 1 A_0,A_1,A_2,A_3,……,A_{N-1} A0​,A1​,A2​,A3​,……,AN−1​,N个对象线性结合称为表。大小为N，如果大小为0，我们称之为空表。java中我们熟知有两种表ArrayList和LinkedList，他们都是表ADT的具体实现。

数组表

    ArrayList即为数组表。它是由简单的固定大小的数组构成我们都知道数组是需要内存连续的，当数组的大小不足够时，需要重新扩容，一般会按照数组长度new一个新的数组，然后将原先数组中的对象进行拷贝。数组表进行中间插入时，需要将后面的对象通通向后移动一位，同样删除时有需要被删除对象之后的对象通通向前移动一位，所以数组表的插入和删除的性能比较差，最坏的情况下为 O ( N ) O(N) O(N)。而访问数组表则性能就好，如果已知对象在表中的位置，那访问该对象则是常数时间 O ( 1 ) O(1) O(1)。

链表

    LinkedList即为链表。为了避免数组表这种高开销的插入与删除，我们需要在不连续的内存中进行存储。链表通过每一个对象保存一个对下一个对象的引用实现连续对象在不连续内存上存储：
链表
链表在插入和删除操作上优于数组表，他不需要将插入点以后的对象整体移动， 只需要修改插入点前后的引用即可，但是查询上性能较低，如果已经对象在表中中的位置，需要依次遍历链表，获取到其中的值，这是由于内存上的不连续，造成无法通过内存地址的偏移量直接获取到指定的对象。
    上面这种只记录记录后驱节点引用的链表称为单向链表，如果一个节点同时记录前驱和后驱节点的引用，这种链表称为双向链表:
双向链表
由于同时存在前后驱节点的引用，所以增加和删除时增加了常数级的时间消耗，但是方便了查询操作，让链表可进可退，单向链表只能前进不能后退。我们java中的LinkedList是双向链表。

Iterator

    Iterator迭代器是java中提供的一个接口：

public interface Iterator<E> {
    E next();
    boolean hasNext();
    default void remove()
}

其中包含next、hasNext、remove三个方法，next获取表中的下一个对象；hasNext判断下一个对象是否存在；remove用于删除当前对象，如果remove执行过之后不能重复执行：

Iterator iterator = list.iterator();
iterator.next();
iterator.remove();
iterator.remove();

Exception in thread “main” java.lang.IllegalStateException
at java.util.ArrayList$Itr.remove(ArrayList.java:872)
at com.huifu.test.TestYuHao.main(TestYuHao.java:30)

第二次执行时会抛出异常，直到iterator再次执行next以后才能再执行remove。大家熟知的java的for循环有两种：for(E e:list){}和for(int i=0;i<list.size();i++)，第一种写法本质就是利用的iterator实现,在ArrayList中由于get方法可以利用内存偏移量直接获取到对象，时间消耗为常数，两种循环性能差距不大：

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 1000000; i++) {
            list.add(i);
        }
        long startTime = System.currentTimeMillis();
        for (Integer integer : list) {
            System.out.println(integer);
        }
        long endTime = System.currentTimeMillis();

        long startTime2 = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("time1="+(endTime-startTime));
        System.out.println("time1="+(endTime2-startTime2));
    }

time1=9402
time2=9792

但是如果是LinkedList就大不一样，LinkedList每一次调用get方法，时间消耗都是线性时间，再加上外部一层循环，整体时间消耗为 O ( N 2 ) O(N^2) O(N2),而基于iterator的第一种循环方式，时间消耗为 O ( N ) O(N) O(N)：

    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(i);
        }
        long startTime = System.currentTimeMillis();
        for (Integer integer : list) {
            System.out.println(integer);
        }
        long endTime = System.currentTimeMillis();

        long startTime2 = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("time1="+(endTime-startTime));
        System.out.println("time2="+(endTime2-startTime2));
    }

time1=1891
time2=7834

本来也想用一百万量级，但是发现第二种循环所需要的时间超出了我等待的容忍程度了，所以改成了十万级，可以看到第二种循环耗时近八秒，而迭代器耗时不到两秒。需要注意的是，iterator在使用过程中是不允许修改表的结构的：

    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        for (int i = 0; i < 1000000; i++) {
            list.add(i);
        }
        new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ((LinkedList<Integer>) list).remove(0);
        }).start();
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

Exception in thread “main” java.util.ConcurrentModificationException
at java.util.LinkedList$ListItr.checkForComodification(LinkedList.java:966)
at java.util.LinkedList$ListItr.next(LinkedList.java:888)
at com.huifu.test.TestYuHao.main(TestYuHao.java:21)

当迭代器使用过程中，表结构发生变化，会抛出异常。原因是为了避免如下两种场景：当迭代器准备将某一项作为下一项时，刚好这一项被删除了，或者新的一项被插入到了两项之间。而如果你使用第二种循环方式，你可以随意修改表的结构。

手写ArrayList

package com.huifu.test.datastructor;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyArrayList<AnyType> {

    private static final int DEFAULT_CAPACITY = 10;

    private int theSize;

    private AnyType[] theItems;

    public MyArrayList() {
        clear();
    }


    public void clear() {
        theSize = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    /**
     * 使数组长度和存储对象的数量一致
     */
    public void trimToSize() {
        ensureCapacity(size());
    }

    /**
     * 扩容
     *
     * @param newCapacity
     */
    public void ensureCapacity(int newCapacity) {
        if (newCapacity < theSize) {
            return;
        }
        AnyType[] old = theItems;
        theItems = (AnyType[]) new Object[newCapacity];
        for (int i = 0; i < size(); i++) {
            theItems[i] = old[i];
        }
    }

    /**
     * 判断是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return size() == 0;
    }


    /**
     * 获取大小
     *
     * @return
     */
    public int size() {
        return theSize;
    }

    /**
     * 获取对象
     *
     * @param idx
     * @return
     */
    public AnyType get(int idx) {
        if (idx < 0 || idx >= size()) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return theItems[idx];
    }

    /**
     * 末尾追加对象
     *
     * @param obj
     */
    public void add(AnyType obj) {
        add(obj, size());
    }

    /**
     * 指定位置添加对象
     *
     * @param obj
     * @param idx
     */
    public void add(AnyType obj, int idx) {
        if (size() == theItems.length) {
            ensureCapacity(size() * 2 + 1);
        }
        for (int i = size(); i > idx; i--) {
            theItems[i] = theItems[i - 1];
        }
        theItems[idx] = obj;
        theSize++;
    }


    /**
     * 修改指定位置的对象
     *
     * @param newVal
     * @param idx
     * @return
     */
    public AnyType set(AnyType newVal, int idx) {
        if (idx < 0 || idx >= size()) {
            throw new ArrayIndexOutOfBoundsException();
        }
        AnyType old = theItems[idx];
        theItems[idx] = newVal;
        return old;
    }


    /**
     * 删除指定对象
     *
     * @param idx
     * @return
     */
    public AnyType remove(int idx) {
        AnyType removeObj = theItems[idx];
        for (int i = idx; i < size() - 1; i++) {
            theItems[i] = theItems[i + 1];
        }
        theSize--;
        return removeObj;
    }

    public static void main(String[] args) {
        new MyArrayList<String>();
    }


    public Iterator<AnyType> iterator() {
        return new MyArrayListIterator<>();
    }

    private class MyArrayListIterator<AnyType> implements Iterator<AnyType> {

        private int current = 0;

        @Override
        public boolean hasNext() {
            return current < size();
        }

        @Override
        public AnyType next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return (AnyType) theItems[current++];
        }

        @Override
        public void remove() {
            MyArrayList.this.remove(--current);
        }
    }
}

MyArrayList中为了实现迭代器iterator，引入了内部类机制。所谓内部类是嵌套类的一种，嵌套类是在一个类中再写一个类，嵌套类分为静态嵌套类,形如：

class A{

    static class B{

    }

}

和非静态嵌套类又叫内部类：

class A{
    class B{

    }
}

两者在代码上只有一个static的区别，但是内部类是可以直接使用外部内中的属性、方法的，即使是私有属性和私有方法，而静态类嵌套类只能够访问外部类的静态属性和方法，内部类还是java实现多继承的一种方式。这里要使用内部类，而不能使用嵌套静态类的原因就是因为MyArrayListIterator这个内部类可以访问MyArrayList中的私有对象和私有方法。当然，也可以通过修改MyArrayList中的属性和方法的可见性，但是一定程度上违背了面向对象编程：让数据尽可能隐蔽的原则。

手写LinkedList

package com.huifu.test.datastructor;

import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyLinkedList<AnyType> {

    private int theSize;
    private int modCount = 0;
    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;


    public AnyType remove(int idx) {
        return remove(getNode(idx));
    }


    private AnyType remove(Node<AnyType> p) {
        p.prev.next = p.next;
        p.next.prev = p.prev;

        theSize--;
        modCount++;

        return p.data;
    }


    /**
     * 在末尾追加
     *
     * @param data
     */
    public void add(AnyType data) {
        add(size(), data);
    }


    /**
     * 修改指定位置的值
     *
     * @param idx
     * @param x
     * @return
     */
    public AnyType set(int idx, AnyType x) {
        Node<AnyType> node = getNode(idx);
        AnyType old = node.data;
        node.data = x;
        return old;
    }


    public AnyType get(int idx) {
        return getNode(idx).data;
    }


    /**
     * 在指定为插入
     *
     * @param idx
     * @param data
     */
    public void add(int idx, AnyType data) {
        addBefore(getNode(idx), data);
    }

    /**
     * 判断是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return size() == 0;
    }


    /**
     * 获取节点
     *
     * @param idx
     * @return
     */
    public Node<AnyType> getNode(int idx) {
        Node<AnyType> p;
        if (idx < 0 || idx > size()) {
            throw new IndexOutOfBoundsException();
        }
        if (idx < size() / 2) {
            p = beginMarker.next;
            for (int i = 0; i < idx; i++) {
                p = p.next;
            }
        } else {
            p = endMarker.prev;
            for (int i = size(); i > idx; i--) {
                p = p.prev;
            }
        }
        return p;
    }


    /**
     * 在前面添加节点
     *
     * @param p
     * @param x
     */
    public void addBefore(Node<AnyType> p, AnyType x) {
        Node<AnyType> newNode = new Node<>(x, p.prev, p);
        p.prev.next = newNode;
        p.prev = newNode;
        theSize++;
        modCount++;
    }


    /**
     * 获取长度
     *
     * @return
     */
    public int size() {
        return theSize;
    }

    /**
     * 清空链表
     */
    public void clear() {
        beginMarker = new Node<AnyType>(null, null, null);
        endMarker = new Node<AnyType>(null, null, null);
        beginMarker.next = endMarker;

        theSize = 0;
        modCount++;
    }


    public Iterator<AnyType> iterator() {
        return new MyLinkedListIterator();
    }


    private class MyLinkedListIterator implements Iterator<AnyType> {

        private Node<AnyType> current =  beginMarker.next;
        private int exceptedModCount = modCount;
        private boolean okToRemove = false;

        @Override
        public boolean hasNext() {
            return current != endMarker;
        }

        @Override
        public AnyType next() {
            if (modCount != exceptedModCount) {
                throw new ConcurrentModificationException();
            }
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            AnyType nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }


        @Override
        public void remove() {
            if (modCount != exceptedModCount) {
                throw new ConcurrentModificationException();
            }
            if (!okToRemove) {
                throw new IllegalStateException();
            }
            MyLinkedList.this.remove(current.prev);
        }
    }


    private static class Node<AnyType> {

        public Node(AnyType data, Node<AnyType> prev, Node<AnyType> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }

        private AnyType data;
        private Node<AnyType> prev;
        private Node<AnyType> next;

    }


}
泰勒今天不想展开
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据库架构设计——表结构设计
庄小焱
01-15 2万+
摘要 如何打造出一个能支撑海量的并发访问的分布式 MySQL 架构，本系列博文将从一下多个方面来分析有关MYSQL系统的架构设计相关原理。实际的业务为案例分析，分析实际业务中表使用的字段类型是如何选型，在介绍MySQL 中表的设计，比如表结构设计、访问设计、物理存储设计。通过模块一解决你表结构设计的痛点问题，让你打好架构设计最为基础的工作。 一、MySQL架构设计原理 1.1 表结构设计 实际的业务为案例分析，分析实际业务中表使用的字段类型是如何选型，在介绍MySQL 中表的设计，比如表结构设计、访
你还不会表结构设计？三分钟内教你如何做好表结构设计
weixin_71690375的博客
05-29 2913
如何做好表结构设计？大家关心的问题阳哥必须整理出来，希望对大家有帮助。这篇文章介绍了设计数据库表结构应该考虑的4个方面，还有优雅设计的6个原则，举了一个例子分享了我的设计思路，为了提高性能我们也要从多方面考虑缓存问题。首先，一定要先搞清楚业务需求。比如我的例子中，如果不需要灵活设置，完全可以写到配置文件中，并不需要单独设计外键。主表中直接保存各种筛选标签名称（注意维护的问题，要考虑到数据一致性）数据库表结构设计一定考虑数据量和并发量，我的例子中如果数据量小，可以适当做冗余设计，降低业务复杂度。
1.表格结构与表结构数据
qq_56735429的博客
05-12 1598
数据分析——表结构与表格结构
MySQL 基础表结构
最新发布
m0_70492807的博客
11-17 1363
数据库（Database）是按照数据结构来组织、存储和管理数据的仓库。每个数据库都有一个或多个不同的 API 用于创建，访问，管理，搜索和复制所保存的数据。我们使用关系型数据库管理系统（RDBMS）来存储和管理大数据量。
数据库表结构及索引设计
热门推荐
xjk201的博客
12-20 2万+
数据库表设计 良好的表结构设计是高性能的基石，应该根据系统将要执行的业务查询来设计，这往往需要权衡各种因素。糟糕的表结构设计，会浪费大量的开发时间，严重延误项目开发周期，让人痛苦万分，而且直接影响到数据库的性能，并需要花费大量不必要的优化时间，效果往往还不怎么样。 在数据库表设计上有个很重要的设计准则，称为范式设计。 范式设计 什么是范式？ 范式来自英文Normal Form，简称NF。MySQL是关系型数据库，但是要想设计—个好的关系，必须使关系满足一定的约束条件，此约束已经形成了规范，分成
中联his表结构
08-13
中联HIS表结构,表结构就是定义一个表的字段、类型、主键、外键、索引，这些基本的属性组成了数据库的表结构。
emr系统表结构.doc
05-13
在设计EMR系统时，数据库表结构是至关重要的组成部分，它决定了数据的组织方式、查询效率以及系统的功能完整性。根据提供的标题和描述，我们可以探讨以下几个关键的表结构及其重要字段： 1. **用户管理表**： - ...
压缩表结构
03-17
压缩表 - 副本.sql 压缩表结构！！
JDE完整表结构说明
07-27
JDE核心的业务表之间的关系，可以通过这些关系，深入的了解JDE的业务运作，比如，采购业务涉及到的表与财务表，与物料主数据等表的关系，超值，值得下载
导出数据库表结构
05-15
在IT领域，数据库是存储和管理数据的核心工具，而数据库表结构则是数据库设计的基础。"导出数据库表结构"是一项常见的任务，对于数据库管理和开发人员来说至关重要。这通常涉及到获取表的元数据，如字段名、数据类型...
数据库表结构
06-23
Access数据库表结构打印程序
qq说说表结构设计demo
03-19
如何做一个类似ＱＱ说说体系的表结构，原文分析地址：http://blog.csdn.net/wgyscsf/article/details/50930383
E9表结构
09-08
泛微E9是一款基于Java技术构建的企业级协同办公系统，其表结构是系统数据库设计的核心组成部分，对于系统的稳定运行和高效数据处理起着至关重要的作用。在深入理解E9表结构之前，我们首先需要了解一些基础的数据库...
表结构模板，可以统计表结构
04-22
表结构模板，可以清晰知道表结构
泛微Ecology 9 最新数据库表结构
01-06
在系统运行过程中，数据存储是至关重要的环节，而数据库表结构设计则是保证数据有效管理和快速检索的基础。本文将深入探讨泛微Ecology 9的最新数据库表结构及其相关知识点。 1. **数据库表结构概述** - 数据库表...
三、Flowable基础表结构
qq_44901906的博客
05-12 1842
1.表结构讲解 工作流程的相关操作都是操作存储在对应的表结构中，为了能更好的弄清楚Flowable的实现原理和细节，我们有必要先弄清楚Flowable的相关表结构及其作用。在Flowable中的表结构在初始化的时候会创建五类表结构，具体如下： ACT_RE ：'RE'表示 repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 ACT_RU：'RU'表示 runtime。 这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。 Flowable只在流..
数据库一 —— 数据表结构
xzafljazz的博客
09-11 1193
一、数据表的关联关系1、一对一关联关系(One To One)(1)在A表中能够找到唯一的对应关系；同时在B表中的一条数据，在A表中也能够找到一条与之对应的数据，那么A表和B表就呈现了一对一关联关系。(2)解决一对一关联关系的方案是分别在对方的数据表中创建一个字段，用于存储对方表的主键。2、多对一关联关系(Many To One)(1)在A表中的一条数据，则B表中能够找到唯一的对应关系；在B表中的一套数据，在A表中能够找到多条对应关系，那么站在A表的角度，A表和B表就形成了多对一关联关系。
表结构及索引设计
qq_56754651的博客
08-11 463
MySQL表及索引高效设计
数据库表结构设计方法及原则
学Java，找哪吒
12-01 1万+
在目前的企业信息系统中，数据库还是最佳的数据存储方式，虽然已经有很多的书籍在指导我们进行数据库设计，但应该那种方式是设计数据库的表结构的最好方法、设计时应遵从什么样的原则、四个范式如何能够用一种方式达到顺畅的应用等是我一直在思考和总结的问题，下文是我针对这几个问题根据自己的设计经历准备总结的一篇文章的提纲，欢迎大家一块进行探讨，集思广益。其中提到了领域建模的概念，但未作详细解释，希望以后能够有时间我们针对这个命题进行深入探讨。 1)不应该针对整个系统进行数据库设计，而应该根据系统架构中的组件划...
Hyperion_Planning_Tables_Metadata.pdf
12-03
"Hyperion Planning Tables Metadata.pdf 是一份由 Dave Farnsworth 创作的文档，旨在帮助Oracle/Hyperion Planning的技术人员理解Planning表结构。文档包含非官方资料、作者的知识以及实验经验的综合，但强调不能将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值