数据结构基础（一）线性表

最新推荐文章于 2022-10-28 21:26:28 发布
最新推荐文章于 2022-10-28 21:26:28 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z55887/article/details/50365338
版权

大学快要结束了，打算抓紧最后一段时间回顾下数据结构的知识，今天是第一篇，希望自己能够坚持完。

  1. 定义
    线性表是n个数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。
  2. 分类
    • 顺序表：即用数组实现的线性表。逻辑上相邻的元素物理地址也相邻，访问容易，插入和删除元素麻烦
    • 链表：用指针连接元素，逻辑上相邻的元素物理地址不一定相邻。访问麻烦，插入和删除容易。
      又可分为：
      • 线性链表：除终节点外，每个节点都有指向下一个元素的指针
      • 循环链表：最后一个节点指向头节点
      • 双向链表：每个节点都有指向前个节点和后个节点的指针
  3. Demo

顺序表Demo

//模仿ArrayList的顺序表
public class Arraylist {
    private Object[] elementDate=null;
    private int capacity;
    private int current;
    //默认初始化容器大小为5
    public Arraylist(){
        this.current=0;
        this.capacity=5;
        this.elementDate=new Object[capacity];
    }
    //按所给容量初始化容器
    public Arraylist(int capacity){
        this.current=0;
        this.capacity=capacity;
        this.elementDate=new Object[capacity];
    }
    //获得指定索引的元素
    public Object get(int index) {
        if(index>=0&&index<capacity)
            return elementDate[index];
        return null;
    }
    //添加元素
    public void add(Object element) {
        //每次插入都要检查容器大小
        ensureCapacity();
        elementDate[current++]=element;
    }
    //在指定下标插入元素
    public void add(int index,Object element) {
        //每次插入都要检查容器大小
        ensureCapacity();
        //确定下标合法
        if(index>current||index<0)
            throw new IndexOutOfBoundsException();

        for (int i = current; i >index; i--) {
            elementDate[i]=elementDate[i-1];
        }
        elementDate[index]=element;
        current++;
    }
    //删除指定位置的元素
    public void delete(int index) {
        if(index>=current||index<0)
             throw new IndexOutOfBoundsException();
//      //也可直接使用函数复制数组
//      int length=current-index;
//      System.arraycopy(elementDate, index+1, elementDate, index, length);
        for (int i = index; i < current-1; i++) {
            elementDate[i]=elementDate[i+1];
        }
        elementDate[--current]=null;
    }
    //确保增加元素后的容器不会溢出
    public void ensureCapacity() {
        if(current+1>=capacity){
            capacity+=5;
            Object[] newElementDate=new Object[capacity];
//          elementDate=Arrays.copyOf(elementDate, capacity); //也直接使用函数
            for (int i = 0; i < elementDate.length; i++) {
                newElementDate[i]=elementDate[i];
            }
            elementDate=newElementDate;
        }
    }
    //遍历出容器内的元素
    public void dolist() {
        for (int i = 0; i < current; i++) {
            System.out.print(elementDate[i]+" ");
        }
        System.out.println("["+capacity+"]");
    }

    public static void main(String[] args) {
        Arraylist list=new Arraylist();
        System.out.println("添加4个元素");
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.dolist();
        System.out.println("插入一个元素");
        list.add(1, 1.5);
        list.dolist();
        System.out.println("删除一个元素");
        list.delete(1);
        list.dolist();
        System.out.println("获取指定4位置元素");
        System.out.println(list.get(4));
        System.out.println("再加几个元素测试溢出");
        list.add(5);
        list.add(6);
        list.dolist();
    }
}/*output
添加4个元素
1 2 3 4 [5]
插入一个元素
1 1.5 2 3 4 [10]
删除一个元素
1 2 3 4 [10]
获取指定4位置元素
null
再加几个元素测试溢出
1 2 3 4 5 6 [10]**/

单链表Demo

//模仿LinkedList的单链表
public class Linkedlist {
    // 链表的第一个节点
    private Node first;
    // 链表的最后一个节点
    private Node last;
    // 链表的长度
    private int size = 0;

    /**
     * 链表节点
     */
    private static class Node {
        // Node pre; //若为双向链表加上，实际LinkedList就是双向链表结构
        Object item;
        Node next;

        public Node(Object item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    /**
     * 空构造，第一次添加元素时才初始化first,last
     */
    public Linkedlist() {
        // TODO Auto-generated constructor stub
    }

    /**
     * 添加一个元素
     * 
     * @param element
     */
    public void add(Object element) {
        Node newNode = new Node(element, null);
        Node l = last;
        last = newNode;
        // 如果此时为空链表，则初始化first,last
        if (first == null)
            first = last;
        else
            l.next = newNode;

        size++;
    }

    /**
     * 增加元素到指定的下标位置
     * 
     * @param index
     * @param element
     */
    public void add(int index, Object element) {
        // 检验索引是否正确
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException();
        // 判断是否插在last节点后
        if (index == size) {
            add(element);
        }
        // 判断是否插在first节点上
        else if (index == 0) {
            Node newNode = new Node(element, first);
            first = newNode;
            size++;
        } else {
            Node preNode = getNode(index - 1);
            Node nextNode = preNode.next;
            Node newNode = new Node(element, nextNode);
            preNode.next = newNode;
            size++;
        }
    }

    /**
     * 删除指定索引处的节点元素
     * 
     * @param index
     */
    public void delete(int index) {
        // 检验索引是否正确
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException();

        // 判断是否删除first节点
        if (index == 0) {
            first = first.next;
        } else {
            Node preNode = getNode(index - 1);
            Node delNode = preNode.next;
            Node nextNode = delNode.next;
            preNode.next = nextNode;
            // 判断是否删除last节点
            if (index == size-1) 
                last=preNode;
            // 方便垃圾回收机制回收
            delNode.item = null;
            delNode.next = null;
        }
        size--;
    }

    /**
     * 获取指定下标的节点
     * 
     * @param index
     * @return
     */
    public Node getNode(int index) {
        // 检验索引是否正确
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException();
        // 从头节点开始寻找，如果为双向链表，可以判断index挨头和尾哪边近，然后从哪边开始查找
        Node node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    public Object get(int index) {
        return getNode(index).item;
    }

    /**
     * 遍历输出所有节点元素
     */
    public void dolist() {
        Node node = first;
        for (int i = 0; i < size; i++) {
            System.out.print(node.item + " ");
            node = node.next;
        }
        System.out.println("[" + size + "]");
    }

    public static void main(String[] args) {
        Linkedlist list = new Linkedlist();
        System.out.println("添加4个元素");
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.dolist();
        System.out.println("插入一个元素");
        list.add(4, 1.5);
        list.dolist();
        System.out.println("删除一个元素");
        list.delete(0);
        list.dolist();
        System.out.println("获取指定3位置元素");
        System.out.println(list.get(3));
    }
}/*output
添加4个元素
1 2 3 4 [4]
插入一个元素
1 2 3 4 1.5 [5]
删除一个元素
2 3 4 1.5 [4]
获取指定3位置元素
1.5**/

双向链表和双向循环链表就不举例了，只是在单链表的基础上Node加了一些改动。实际上java的LinkedList里面采用的就说双向链表。

大树先生
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构基础练习(线性表)
06-03
本文档是对数据结构c语言（线性表）复习使用的一个题库，帮助大家复习。
【数据结构与算法】初入数据结构中的线性表(Linear table)及Java代码实现
长路漫漫的歇脚处
05-29 963
初入数据结构中的线性表(Linear table)及Java代码实现 线性表的概念 什么是线性表？ 前趋和后继 数据元素、数据项、记录和文件 线性表的特点 线性表的分类 顺序表的概念 什么是顺序表？ 顺序表的特点 顺序表的代码实现 链表的概念 什么是链表 链表的特点 链表的代码实现 线性表的概念 什么是线性表？ 线性表： 线性表就是数据结构中最简单的存储结构，可以理...
数据结构笔记（二）：线性表的抽象和代码实现
晓风残月淡的博客
08-04 430
ADT List {数据对象：{ai|ai∈ElemSet,i=1,2,...,n,n≥0}数据关系：{|ai-1,ai∈D,i=2,...,n}基本操作：操作结果：构造一个空的线性表L初始条件：线性表已存在操作结果：销毁线性表L初始条件：线性表L操作结果：将L重置为空表初始条件：线性表L已存在操作结果：若L为空表，则返回true，否则返回false初始条件：线性表L已存在操作结果：返回L中数据元素个数初始条件：线性表L已存在。..............................
数据结构基础 线性表
PFzcnds8310__的博客
03-28 214
线性表概念线性表的顺序存储结构及实现 概念 线性表是n(n>=0)个具有相同类型的数据元素的有限序列。 线性表的顺序存储结构及实现 线性表的顺序存储结构称为 顺序表。顺序表是用一段地址连续的存储单元依次存储线性表的数据元素。通常用一维数组来实现顺序表。 实现： SeqList.h // // Created by 野尽 on 2020/3/28. // #ifndef SEQLIST_CL...
数据结构基础--线性表
RXY24601的博客
10-28 720
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑结构是通过链表中的指针链接实现的。（3）循环、非循环（是否能通过链表的尾结点直接访问到链表的第一个结点）（2）带头、不带头（在链表开头是否有一个不存放数据的头结点）（1）单向、双向（是否支持向前访问）三、带头双向循环链表。
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
超清晰-数据结构之线性表
热门推荐
MClink的博客
05-25 3万+
鸟哥说，坚持学习基础才能有出人头地的一天。不能只专注于练武功了，内功也得练。 本篇文章是讲数据结构的第一篇，跟着书好好再过一篇基础。 一、线性表 线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。 对于非空的线性表或者线性结构的特点： （1）存在唯一的一个被称作“第一个”的数据元素； （2）...
1.线性表
安全苦行僧
08-23 134
主要考查知识点 1、线性表， 2、树和二叉树 3、图 4、排序算法 6、hash 6、查找算法 基本数据结构 线性表 按存储结构分类分为两类，顺序表以及链表 顺序表在内存中按顺序存储 链表是离散的，单独的一个个点，即物理上是离散的，但是逻辑上是一个整体 链表的类别： 单链表:单向的，有两个域，前面的叫数据域，后面的叫指针域，存放的是指针，用于指...
线性表——数组描述(Qt5.1测试代码 for windows)
weixin_34082695的博客
04-09 124
2019独角兽企业重金招聘Python工程师标准>>> ...
数据结构:线性表
qt187904的博客
05-19 128
#include<iostream> using namespace std; #define MAXSIZE 5 #define OK 1 #define TRUE 1 #define FALSE 0 #define ERROR 0 //状态信息 typedef int Status; //存储返回信息 typedef int ElemType; //线性表结构体定义 struct SqList{ int data[MAXSIZE];//data数组 i
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最基本的一个。线性表按存储结构分，可 分为顺序表和链表，它们各有特色。本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是...
数据结构学习--线性表及其应用--链表
06-25
本程序的主要目的在于帮助同学熟练掌握线性表的基本操作在链式存储结构上的...通过本实验， 对链表基本操作及其组合应用的演练，加深对链表存储方法及其基本操作的理解，为以后进 一步学习更复杂的数据结构打下基础。
数据结构线性表代码
11-06
纯版c语言实现的数据结构代码，里面多以指针为基础编写代码
java基础数据结构-线性表
12-26
java基础笔记数据结构-线性表，详细描述了线性表的原理及其实现方式，基础数据结构。
数据结构基础（五）图以及DFS、BFS
大树的学习之路
03-09 2047
概念定义图是一种较线性表和树更为复杂的数据结构
数据结构基础（三）广义表
大树的学习之路
01-02 940
java实现广义表
数据结构基础（四）树和二叉树
大树的学习之路
01-24 897
前言树型结构是一类特别重要的非线性结构，其中以树和二叉树最为常用。定义 树： 树是n个结点的有限集。在任何一个非空树中，（1）有且仅有一个特定的称为根的结点；（2）当n>1时，其余节点可分为m个互不相交的有限集，每一个集合又是一颗树，并且称为根的子树 二叉树： 特点为每个结点至多只有两棵子树，并且，二叉树的子树有左右之分，其次序不能任意颠倒。 常用术语节点的度：结点拥有的子树个数称为结点的度。例
数据结构与算法线性表
最新发布
09-07
线性表是最基本的数据结构之一，在实际程序中被广泛应用，并且常被用作更复杂数据结构的实现基础。线性表可以使用不同的实现方式，其中一种常见的实现方式是顺序表。顺序表使用一段物理地址连续的存储单元依次存储...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值