数据结构 线性表以及Java代码实现

最新推荐文章于 2024-04-03 16:16:19 发布
最新推荐文章于 2024-04-03 16:16:19 发布
阅读量1k 收藏 4
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 线性表 链表 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Thousa_Ho/article/details/75138490
版权

1. 线性表

线性表是最基本、最简单、也是最常用的一种数据结构。在线性表中数据元素之间的关系是线性，数据元素可以看成是排列在一条线上或一个环上。
线性表分为静态线性表和动态线性表，常见的有顺序表(静态的)、单向链表(动态的)和双向链表(动态的)。

2. 顺序表

这里写图片描述

/**
 * List
 * 线性表接口
 * （1）计算表的长度n。
 * （2）线性表是否为空
 * （3）将元素添加到线性表的末尾
 * （4）获取第i个元素，0≤i < n。
 * （5）清除线性表
 * （6）返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1。
 * （7）返回列表中最后一次出现指定元素的索引，如果列表不包含此元素，则返回 -1。
 * （8）将新元素插入第i个位置，0≤i < n，使原来的第i，i+1，…，n–1个元素变为第i+1，i+2，…，n个元素。
 * （9）更改第i个元素
 * （10）删除第i个元素，0≤i < n，使原来的第i+1，i+2，…，n–1个元素变为第i，i+1，…，n–2个元素
 * Created by heqianqian on 2017/7/13.
 */
public interface List<T> {

    /**
     * 计算表的长度
     */
    int getLength();

    /**
     * 判断表是否为空
     */
    boolean isEmpty();

    /**
     * 将元素添加到线性表的末尾
     */
    boolean add(T entity);

    /**
     * 获取第index个元素
     */
    T get(int index);

    /**
     * 清除线性表
     */
    void clear();

    /**
     * 返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1。
     */
    int indexOf(T entity);

    /**
     * 返回列表中最后一次出现指定元素的索引，如果列表不包含此元素，则返回 -1。
     */
    int lastIndexOf(T entity);

    /**
     * 将新元素插入第index个位置，0≤index< n
     */
    boolean insert(T entity,int index);

    /**
     * 更改第index个元素
     */
    boolean update(T entity,int index);

    /**
     * 删除第index个元素
     */
    boolean delete(int index);

}

/**
 * ArrayList
 * 线性表的实现
 * Created by heqianqian on 2017/7/13.
 */
public class ArrayList<T> implements List<T> {

    private T[] t;
    private int size = 0;//当前可以插入元素的位置
    private int maxLen;
    private static final int LIST_LENGTH = 10;

    @SuppressWarnings("unchecked")
    public ArrayList() {
        maxLen = LIST_LENGTH;
        t = (T[]) new Object[maxLen];
    }

    @SuppressWarnings("unchecked")
    public ArrayList(int length) {
        maxLen = length;
        t = (T[]) new Object[maxLen];
    }

    @Override
    public int getLength() {
        return size;
    }

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

    @Override
    public boolean add(T entity) {
        if (size == maxLen) {//数组已满
            expand();//扩充数组大小
        }
        //添加元素 元素个数+1
        t[size++] = entity;
        return true;
    }

    @Override
    public T get(int index) {
       calIndex(index);
        return t[index];
    }

    @Override
    public void clear() {
        size = 0;
    }

    @Override
    public int indexOf(T entity) {
        for (int i = 0; i < size; i++) {
            if (t[i].equals(entity)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public int lastIndexOf(T entity) {
        for (int i = size - 1; i >= 0; i--) {
            if (t[i].equals(entity)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean insert(T entity, int index) {
        calIndex(index);
        if (size > maxLen) {
            expand();//扩充数组大小
        }
        //index-size-1元素后移一位
        for (int i = size; i > index; i--) {
            t[i] = t[i - 1];
        }
        t[index] = entity;
        size++;
        return true;
    }

    @Override
    public boolean update(T entity, int index) {
        return insert(entity, index);//TODO
    }

    @Override
    public boolean delete(int index) {
        calIndex(index);
        for (int i = index; i < size - 2; i++) {
            t[i] = t[i + 1];
            System.out.println(this);
        }
        size--;
        return true;
    }

    /**
     * 扩充数组大小
     * 按照原大小扩大一倍
     */
    @SuppressWarnings("unchecked")
    private void expand() {
        T[] t1 = (T[]) new Object[maxLen * 2];
        System.arraycopy(t, 0, t1, 0, size);
        t = t1;
    }

    /**
     * 判断数组下标是否正确
     */
    private void calIndex(int index) {
        if (index < 0) {
            throw new IllegalArgumentException("非法数组下标");
        }
        if (index > size) {
            throw new ArrayIndexOutOfBoundsException("数组下标越界");
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size - 1; i++) {
            sb.append(t[i]).append(",");
        }
        sb.append(t[size - 1]).append("]");
        return sb.toString();
    }
}

2.单向循环链表

这里写图片描述

/**
 * 单向循环列表
 * Created by heqianqian on 2017/7/13.
 */
public class Node<T> {

    /**
     * 尾指针
     */
    public Node next;

    /**
     * 数据域
     */
    public T data;

    @SuppressWarnings("unchecked")
    public Node() {
        data = (T) new Object();
        next = null;
    }

    public Node(T data) {
        this.data = data;
        next = null;
    }

    @Override
    public String toString() {
        return data.toString();
    }
}
/**
 * LinkedList
 * 单向循环列表
 * Created by heqianqian on 2017/7/13.
 */
public class LinkedList<T> implements List<T> {

    /**
     * 头指针
     */
    private Node<T> head;

    /**
     * 指向链表尾部 便于遍历
     */
    private Node<T> current;

    /**
     * 当前链表的大小
     */
    private int size = 0;

    @SuppressWarnings("unchecked")
    public LinkedList() {
        head = new Node<T>();
        current = new Node<T>();
        //当前指向头指针
        head = current;
    }

    @Override
    public int getLength() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return head.next == null;
    }

    @Override
    @SuppressWarnings("unchecked")
    public boolean add(T entity) {
        //要插入的节点
        Node<T> node = new Node<T>(entity);
        current.next = node;
        current = node;
        size++;
        return true;
    }

    @Override
    @SuppressWarnings("unchecked")
    public T get(int index) {
        calIndex(index);
        return (T) getNode(index).data;
    }

    @Override
    public void clear() {
        size = 0;
        current = head;
        head.next = null;
    }

    @Override
    public int indexOf(T entity) {
        Node node = head;
        int index = -1;
        while (node.next != null && !node.data.equals(entity)) {
            node = node.next;
            index++;
        }
        if (index == size - 1) {
            return -1;
        }
        return index;
    }



    @Override
    public int lastIndexOf(T entity) {
        return 0;
    }

    @Override
    @SuppressWarnings("unchecked")
    public boolean insert(T entity, int index) {
        calIndex(index);
        Node node = getNode(index);
        Node newNode = new Node(entity);
        newNode.next = node.next;
        node.next = newNode;//current指针 不变
        size++;
        return true;
    }

    @Override
    public boolean update(T entity, int index) {
        return insert(entity, index);
    }

    @Override
    public boolean delete(int index) {
        calIndex(index);
        Node node = head.next;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        node.next = node.next.next;
        return false;
    }

    /**
     * 判断数组下标是否正确
     */
    private void calIndex(int index) {
        if (index < 0) {
            throw new IllegalArgumentException("非法数组下标");
        }
        if (index > size) {
            throw new ArrayIndexOutOfBoundsException("数组下标越界");
        }
    }

    /**
     * 获取第index个节点
     */
    private Node getNode(int index) {
        Node n = head;
        for (int i = 0; i < index; i++) {
            n = n.next;
        }
        return n;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node node = head.next;
        while (node != null) {
            sb.append(node.toString()).append(",");
            node = node.next;
        }
        sb.append("]");
        return sb.toString();
    }
}

3.双向循环链表

这里写图片描述

/**
 * DLNode
 * Created by heqianqian on 2017/7/14.
 */
public class DLNode<T> {

    public T data;

    public DLNode<T> prio;

    public DLNode<T> next;

    public DLNode() {
    }

    public DLNode(T data) {
        this.data = data;
        prio = null;
        next = null;
    }

    @Override
    public String toString() {
        return data.toString();
    }
}
/**
 * DoubleLinkedList
 * Created by heqianqian on 2017/7/14.
 */
public class DoubleLinkedList<T> implements List<T> {

    private DLNode<T> head;
    private DLNode<T> current;
    private int size;

    public DoubleLinkedList() {
        head = new DLNode<T>();
        head.next = head;
        head.prio = head;
        current = head;
        size = 0;
    }

    @Override
    public int getLength() {
        return size;
    }

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

    @Override
    public boolean add(T entity) {
        DLNode<T> node = new DLNode<T>(entity);
        node.next = current.next;
        node.prio = current;
        current.next = node;
        current = node;
        size++;
        return true;
    }

    @Override
    public T get(int index) {
        calIndex(index);
        return getIndex(index).data;
    }

    @Override
    public void clear() {
        size = 0;
        head.next = head;
        head.prio = head;
        current = head;
    }

    @Override
    public int indexOf(T entity) {
        DLNode<T> temp = head.next;
        int index = 0;
        while (temp.next != head && !temp.data.equals(entity)) {
            temp = temp.next;
            index++;
        }
        if (index >= size - 1) {
            return -1;
        }
        return index;
    }

    @Override
    public int lastIndexOf(T entity) {
        DLNode<T> node = head.prio;
        int index = size;
        while (node.prio != head && !node.data.equals(entity)) {
            node = node.prio;
            index--;
        }
        if (index >= size - 1) {
            return -1;
        }
        return index;
    }

    @Override
    public boolean insert(T entity, int index) {
        calIndex(index);
        DLNode<T> node = new DLNode<T>(entity);
        DLNode<T> temp = getIndex(index - 1);
        node.next = temp.next;
        node.prio = temp;
        temp.next = node;
        size++;
        return true;
    }

    @Override
    public boolean update(T entity, int index) {
        return insert(entity, index);
    }

    @Override
    public boolean delete(int index) {
        calIndex(index);
        DLNode<T> temp = getIndex(index - 1);
        temp.next.next.prio = temp;
        temp.next = temp.next.next;
        size--;
        return true;
    }

    /**
     * 判断数组下标是否正确
     */
    private void calIndex(int index) {
        if (index < 0) {
            throw new IllegalArgumentException("非法数组下标");
        }
        if (index > size) {
            throw new ArrayIndexOutOfBoundsException("数组下标越界");
        }
    }

    /**
     * 获得第index个节点
     */
    private DLNode<T> getIndex(int index) {
        DLNode<T> temp = head.next;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        DLNode<T> temp = head.next;
        for (int i = 0; i < size - 1; i++) {
            sb.append(temp.data.toString()).append(",");
            temp = temp.next;
        }
        sb.append(temp.data.toString());
        sb.append("]");
        return sb.toString();
    }
}
heqianqiann
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表不带头结点C语言详细代码实现
qq_42824207的博客
10-14 477
//单链表不带头结点 #include<stdio.h> #include<stdlib.h> typedef struct LNode{ int data; struct LNode *next; }LNode, * LinkList; LinkList initList(LinkList list){ list=NULL; return list; } //插数据（第一个位置）（指定位置） LinkList insertFirst(LinkList list.
大话数据结构-Java代码实现-线性表
peach2580的博客
01-18 389
大话数据结构-Java代码实现-线性表
数据结构(Java版)-线性表的实现与应用完整版.doc
10-01
数据结构(Java版)-线性表的实现与应用完整版.doc
线性表java实现
qq_41044209的博客
06-24 1234
通过数组实现，查询直接根据索引（index）查询，效率比较高；增删的效率比较低，因为需要大量的移动元素的位置，一旦创建，长度固定，当长度等于数组长度时，如果想要再插入数据就需要扩容处理。...
C语言数据结构--线性表常用操作代码合集
最新发布
m0_70744482的博客
04-03 444
数据结构线性表常用代码
数据结构——线性表代码总结
Acc222222的博客
07-29 2748
1.线性表结构定义 typedef struct { int a[100];//或定义MaxSize int length; }SqList; 其中length记录线性表长度，a是数据域。 2.根据位置i获取相应位置数据元素的内容
数据结构代码实现之线性表
礼乐的博客
03-11 1220
算法思想：遍历寻找最小值并记住位置，结束之后删除替代操作即可。//定义单链表节点 ElemType data;//数据域 struct LNode * next;//指针域 } LNode , * LinkList;
Java数据结构-线性表的设计与实现
m0_52846268的博客
11-28 1807
线性表： 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 顺序表的实现之增删改查功能 代码实现： public class MyArrayList { private int[] elements;//元素 private int size;//List中当前的元素个数 public MyArrayList() { this(1);//List默认大小为1
数据结构-线性表-Java代码实现
03-20
关于线性表的Java实现代码 有顺序表，带头结点的单链表的实现代码，顺序表里包含插入，删除，求数据元素个数，取数据元素，判断非空否，以及顺序表中删除第一个出现的数据元素x,以及把顺序表中所有等于x的数据元素...
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验内容 （1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表...
java线性表的存储结构及其代码实现
08-29
Java 线性表的存储结构及其代码实现 Java 线性表是一种基本的数据结构，它的存储结构...Java 线性表的存储结构和代码实现是非常重要的数据结构和算法知识点。掌握这些知识点可以帮助开发者更好地设计和实现软件系统。
java实现线性表
12-19
压缩包中有两个.java文件，一个是接口一个是具体实现，使用java代码实现了线性表
顺序线性表的JAVA实现代码
05-03
顺序线性表的JAVA实现代码，希望对学习数据结构的同学们有所帮助！
数据结构之线性表（附代码）
千寻瀑
04-22 1万+
白话+图解 数据结构 之 线性表线性表思维导图:线性表定义（逻辑结构）：线性表的基本操作原型（严蔚敏版）：顺序表1、顺序表思维导图:2.顺序表的逻辑结构：3、顺序表基本操作的功能实现：1.线性表的静态定义：2.线性表的动态定义：3. 线性表的静态初始化：4. 线性表的动态初始化：5. 线性表的插入：6. 线性表的删除：7. 线性表的按位查找：8. 线性表的按值查找：4.顺序表的特点和优点：链表：1...
Java数据结构-线性表的设计与实现(头歌平台，详细注释)
qwertf123的博客
09-18 1480
Java数据结构-线性表的设计与实现
Java数据结构-线性表
qq_51938362的博客
10-16 1517
Java线性表、链表
数据结构之线性表（代码，完整版）
起个名字真难的博客
07-07 4325
线性表顺序表（动态存储）链表（不带头结点）链表（带头结点）双链表静态链表 顺序表（动态存储） #include<stdlib.h> #include<stdio.h> #include<iostream> using namespace std; #define InitSize 10 //定义最大长度 //静态分配 //typedef struct { // int data[InitList]; // int length; //}SqlList;
数据结构学习1——线性表定义以及代码
m0_53552112的博客
06-29 1411
数据结构的线性表总代码——串联一章
线性表的实现（C语言版）——详细代码
热门推荐
m0_63285686的博客
01-09 1万+
基于C语言实现的线性表（顺序表），在Devc++上进行了顺序表的增删改查基本操作的实现（附详细代码），本文介绍一下自己动手过程中的一些心得和这些代码的内容。提示：以下是本篇文章正文内容，下面案例可供参考#include //malloc()、free()和exit()函数在这个头文件之中int *data;//存放存储空间首地址的指针变量int length;//线性表当前的元素个数//线性表最大能存储的元素个数}Sqlist;
线性表的顺序存储结构的java代码
03-02
以下是一个简单的线性表顺序存储结构的Java代码示例： ```java public class ArrayList { private int[] data; // 存储数据的数组 private int size; // 线性表的大小 // 构造函数，初始化线性表 public ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值