数据结构-线性表

最新推荐文章于 2024-09-11 20:39:26 发布
最新推荐文章于 2024-09-11 20:39:26 发布
阅读量178 收藏
点赞数
分类专栏： javase 数据结构 文章标签： 数据结构 java 线性表 linkedlist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wz1226864411/article/details/77018234
版权

所谓线性表就是具有一维线性的存储结构，一般有两种存储方式：顺序存储和链式存储。数组就是一种顺序的存储结构，ArrayList就是一种顺序表的实现类。那么来讲一下链式存储的链表。LinkedList则是采用链表实现的容器。
链表又分为单链表和双链表。

单链表

这里写图片描述
An称为An+1的前驱节点，A0称为头节点。单链表只有一个指向后面节点的指针。
结构形式：

java代码
private class Node<E>{
        E item;
        Node<E> next;
        Node(E item,Node<E> next){
            this.item = item;
            this.next = next;
        }
}

这个只是一个链表的结构类，我们需要一个容器来实现这个单链表的具体操作。

package com.creat.mylist;


/**
 * Created by WHZ on 2017/8/10 0010.
 */
public class MySingleList<E>{

    private Node<E> first;
    private int size;

    private class Node<E>{
        E item;
        Node<E> next;

        Node(E item,Node<E> next){
            this.item = item;
            this.next = next;
        }
    }
    public int size() {
        return size;
    }

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

    public boolean contains(Object o) {
        if(o == null){
            for(Node<E> x = first; x != null; x = x.next){
                if(x.item == null){
                    return true;
                }
            }
        }else {
            for(Node<E> x = first; x != null; x = x.next){
                if(o.equals(x.item)){
                    return true;
                }
            }
        }
        return false;
    }

    public boolean add(E e) {
        Node<E> node = new Node<E>(e,null);
        if(first == null){
            first = node;
        }else {
            Node<E> x = null;
            for(x = first; x.next != null; x = x.next)
                ;
            x.next = node;
        }
        size++;
        return true;
    }

    public boolean remove(Object o) {
        if(first != null){
            if( o == null){
                Node<E> temp = null;
                for(Node<E> x = first; x != null; x = x.next){
                    if(x.item == null){
                        return removeNode(x, temp);
                    }
                    temp = x;
                }
            }else {
                Node<E> temp = null;
                for(Node<E> x = first; x != null; x = x.next){
                    if(o.equals(x.item)){
                        return removeNode(x, temp);
                    }
                    temp = x;
                }
            }
        }
        return false;
    }

    private boolean removeNode(Node<E> x, Node<E> temp){
        if(x == first){
            first = x.next;
            size--;
            return true;
        }else {
            temp.next = x.next;
            size--;
            return true;
        }
    }

    public void clear() {
        first = null;
        size = 0;
    }

    public E get(int index) {
        if(first != null && size > index && index >= 0){
             Node<E> x = first;
             for(int i = 0; i < index; i++){
                 x = x.next;
             }
             return x.item;
        }else {
            throw new IndexOutOfBoundsException("越界");
        }
    }

    public E set(int index, E element) {
        if(first != null && size > index && index >= 0){
            Node<E> x = first;
            for(int i = 0; i < index; i++){
                x = x.next;
            }
            x.item = element;
            return x.item;
        }else {
            throw new IndexOutOfBoundsException("越界");
        }
    }

    public void add(int index, E element) {
        if(first != null && size > index ){
            Node<E> x = first;
            Node<E> temp = null;
            for(int i = 0; i < index; i++){
                temp = x;
                x = x.next;
            }
            Node<E> newNode = new Node<E>(element,x);
            temp.next = newNode;
            size++;
        }else if(first == null && index == 0){
            first = new Node<E>(element,null);
            size++;
        }else {
            throw new IndexOutOfBoundsException("越界");
        }
    }


    public int indexOf(Object o) {
        if(first != null){
            if( o == null){
                int index = 0;
                for(Node<E> x = first; x != null; x = x.next){
                    if(x.item == null){
                        return index;
                    }
                    index++;
                }
            }else {
                int index = 0;
                for(Node<E> x = first; x != null; x = x.next){
                    if(o.equals(x.item)){
                        return index;
                    }
                    index++;
                }
            }
        }
        return -1;
    }

}

测试结果

package com.creat;

import com.creat.mylist.MySingleList;
import java.io.*;

public class App {

    public static void main(String[] args ) throws IOException {
        MySingleList<Integer> list = new MySingleList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println("是否包含3:"+list.contains(3));
        System.out.println("3的索引值:"+list.indexOf(3));
        System.out.println("索引1上的数："+list.get(1));
        list.add(1,4);
        for(int i = 0; i < list.size(); i++){
            System.out.print("第"+i+"个数："+list.get(i)+" ;");
        }
        System.out.println();
        list.set(1,6);
        for(int i = 0; i < list.size(); i++){
            System.out.print("第"+i+"个数："+list.get(i)+" ;");
        }
        System.out.println();
        System.out.println("是否为空："+list.isEmpty());
        System.out.println("链表大小："+list.size());
        list.clear();
        System.out.println("是否为空："+list.isEmpty());
        System.out.println("链表大小："+list.size());
        for(int i = 0; i < list.size(); i++){
            System.out.print("第"+i+"个数："+list.get(i)+" ;");
        }
    }

}

是否包含3:true
3的索引值:2
索引1上的数：2
第0个数：1 ;第1个数：4 ;第2个数：2 ;第3个数：3 ;
第0个数：1 ;第1个数：6 ;第2个数：2 ;第3个数：3 ;
是否为空：false
链表大小：4
是否为空：true
链表大小：0

双链表

单链表只拥有头节点，当我们需要增加或者修改尾部的节点时，往往需要遍历整个链表，这样花费了很多时间，所以产生了双链表，拥有头节点和尾节点，每个节点拥有指向前驱节点的指针和后驱节点的指针。java中的LinkedList正是采用了双链表来实现。
这里写图片描述
链表结构：

private class Node<E>{
        Node<E> prev;
        E item;
        Node<E> next;

        Node(Node<E> prev, E item, Node<E> next){
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }

简单的容器类：

package com.creat.mylist;

/**
 * Created by WHZ on 2017/8/10 0010.
 */
public class MyLinkedList<E> {

    private Node<E> first;
    private Node<E> last;
    private int size;

    private class Node<E>{
        Node<E> prev;
        E item;
        Node<E> next;

        Node(Node<E> prev, E item, Node<E> next){
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }
    public int size() {
        return size;
    }

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

    public boolean contains(Object o) {
        if(first != null){
            if(o == null){
                for(Node<E> x = first; x != null; x = x.next){
                    if(x.item == null){
                        return true;
                    }
                }
            }else {
                for(Node<E> x = first; x != null; x = x.next){
                    if(o.equals(x.item)){
                        return true;
                    }
                }
            }
        }
        return false;
    }


    public boolean add(E e) {
        Node<E> newNode = new Node<E>(last, e, null);
        if(last == null){
            first = newNode;
        }else {
            last.next = newNode;
        }
        last = newNode;
        size++;
        return false;
    }

    public boolean remove(Object o) {
        if(first != null){
            if(o == null){
                for(Node<E> x = first; x != null; x = x.next){
                    if(x.item == null){
                        if(x == first){
                            x.next.prev = null;
                            first = x.next;
                        }else if(x == last){
                            x.prev.next = null;
                            last = x.prev;
                        }else {
                            x.next.prev = x.prev;
                            x.prev.next = x.next;
                        }
                        size--;
                        return true;
                    }
                }
            }else {
                for(Node<E> x = first; x != null; x = x.next){
                    if(o.equals(x.item)){
                        if(x == first){
                            x.next.prev = null;
                            first = x.next;
                        }else if(x == last){
                            x.prev.next = null;
                            last = x.prev;
                        }else {
                            x.next.prev = x.prev;
                            x.prev.next = x.next;
                        }
                        size--;
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public void clear() {
        first = null;
        last = null;
        size = 0;
    }

    public E get(int index) {
        if(first != null && size > index && index >= 0){
            if(size/2 > index){
                Node<E> temp = first;
                for(int i = 0; i < index; i++){
                    temp = temp.next;
                }
                return temp.item;
            }else {
                Node<E> temp = last;
                for(int i = size-index; i > 1; i--){
                    temp = temp.prev;
                }
                return temp.item;
            }
        }else{
            throw new IndexOutOfBoundsException("越界");
        }
    }

    public E set(int index, E element) {
        if(first != null && size > index && index >= 0){
            if(size/2 > index){
                Node<E> temp = first;
                for(int i = 0; i < index; i++){
                    temp = temp.next;
                }
                temp.item = element;
                return temp.item;
            }else {
                Node<E> temp = last;
                for(int i = size-index; i > 1; i--){
                    temp = temp.prev;
                }
                temp.item = element;
                return temp.item;
            }
        }else{
            throw new IndexOutOfBoundsException("越界");
        }
    }

    public void add(int index, E element) {
        if(first != null && size > index && index >= 0){
            if(size/2 > index){
                Node<E> x = first;
                for(int i = 0; i < index; i++){
                    x = x.next;
                }
                Node<E> newNode = new Node<E>(x.prev, element, x);
                if(x == first){
                    x.prev = newNode;
                   first = newNode;
                }else {
                    x.prev.next = newNode;
                    x.prev = newNode;
                }
            }else {
                Node<E> x = last;
                for(int i = size-index; i > 1; i--){
                    x = x.prev;
                }
                Node<E> newNode = new Node<E>(x.prev, element, x);
                if(x == first){
                    x.prev = newNode;
                    first = newNode;
                }else {
                    x.prev.next = newNode;
                    x.prev = newNode;
                }
            }
            size++;
        }else{
            throw new IndexOutOfBoundsException("越界");
        }
    }

    public int indexOf(Object o) {
        int index = 0;
        for(Node<E> x = first; x != null; x = x.next){
            if(o == null){
                if(x.item == null){
                    return index;
                }
            }else {
                if(o.equals(x.item)){
                    return index;
                }
            }
            index++;
        }
        return -1;
    }


}

测试结果：

package com.creat.mylist;

/**
 * Created by WHZ on 2017/8/10 0010.
 */
public class MyLinkedClient {

    public static void main(String[] args){
        MyLinkedList<String> linkedList = new MyLinkedList<String>();
        linkedList.add("whz");
        linkedList.add("zdd");
        linkedList.add("haiyoushui");
        for(int i = 0; i < linkedList.size(); i++){
            System.out.println("第"+i+"个是："+linkedList.get(i));
        }
        System.out.println(linkedList.size());
        linkedList.add(1,"没谁了");
        for(int i = 0; i < linkedList.size(); i++){
            System.out.println("第"+i+"个是："+linkedList.get(i));
        }
        System.out.println("没谁了存在不："+linkedList.contains("没谁了"));
        System.out.println("没谁存在不："+linkedList.contains("没谁"));
        System.out.println("zdd在第几个："+linkedList.indexOf("zdd"));
        linkedList.remove("whz");
        linkedList.remove("haiyoushui");
        for(int i = 0; i < linkedList.size(); i++){
            System.out.println("第"+i+"个是："+linkedList.get(i));
        }
        linkedList.set(0,"whz");
        for(int i = 0; i < linkedList.size(); i++){
            System.out.println("第"+i+"个是："+linkedList.get(i));
        }
        linkedList.clear();
        System.out.println("是否为空："+linkedList.isEmpty());
        for(int i = 0; i < linkedList.size(); i++){
            System.out.println("第"+i+"个是："+linkedList.get(i));
        }
    }
}
第0个是：whz
第1个是：zdd
第2个是：haiyoushui
3
第0个是：whz
第1个是：没谁了
第2个是：zdd
第3个是：haiyoushui
没谁了存在不：true
没谁存在不：false
zdd在第几个：2
第0个是：没谁了
第1个是：zdd
第0个是：whz
第1个是：zdd
是否为空：true

总结：基于数组实现的集合在查找方面速度较快，数组是固定大小，所以在插入，删除方面速度较慢，插入时需要以后该位置之后的所有元素。基于链表实现的集合在插入，删除方面有很大的优势，在查找方面略疏于数组。

corefuture
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
2.C-数据结构-线性表-线性表源码
09-07
2.C-数据结构-线性表-线性表源码
数据结构-线性表-思维导图+小结
学习记录
11-12 2287
数据结构-线性表-思维导图+习题小结
数据结构 -线性表
weixin_59725429的博客
11-06 1409
线性表 定义：线性表（linear list）是具有相同特性的数据元素的一个有限序列。线性表的逻辑表示为：( a1，a2，…，ai，ai+1，…，an ) ai（1≤i≤n）表示第i（i表示逻辑位序）个元素。前驱与后继：线性表中相邻的数据元素ai-1和ai之间存在序偶关系(ai-1, ai)，即ai-1是ai的前驱， ai是ai-1的后继；a1 无前驱，an无后继，其它每个元素有且仅有一个前驱和一个后继。线性表长度：线性表中元素的个数。线性表L=（a1,a2,a3……
数据结构 - 线性表（C语言版）
weixin_41733225的博客
07-11 1818
主要讲述顺序表和单链表的基础操作
2.C-数据结构-线性表-链表源码
09-07
2.C-数据结构-线性表-顺序表源码
2.C-数据结构-线性表-顺序表源码
08-30
2.C-数据结构-线性表-顺序表源码
数据结构-线性表的链式存储
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
【初阶数据结构】详解栈和队列（来自知识星空的一抹流光）
tianxiawushanu的博客
09-06 1228
本文主要讲解了栈和队列这两种数据结构。它们的概念，以及代码的实现均在本文形成呈现，干货满满！！！
14_L3缓存友好的数据结构
刘炫320的博客
09-11 459
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
数据结构（邓俊辉）学习笔记】排序 7——希尔排序：Shell 序列 + 输入敏感性
weixin_44399845的博客
09-08 1037
希尔排序：Shell 序列 + 输入敏感性
【数据结构】——1.1树
qq_43507078的博客
09-07 1056
树，二叉树
【数据结构】排序算法系列——希尔排序（附源码+图解）
Skrrapper的博客
09-07 993
希尔排序实际上是个相当复杂的排序算法，这主要是跟它的步长序列gap到底该如何取、后续应该减小有关。时，数组已经接近有序的了，就整体而言，最后一次整体的插入排序就可以大大提高效率——我们从插入排序的时间复杂度分析也可以看出，可以看到每次减小gap的规律是将原先的gap/2，但事实上这只是其中一种处理方法，并不说明这是最优解。，使得平均情况下的时间复杂度能够在O(n^1.3)左右，而不好的选择则可能导致接近最坏情况的性能。中，我们会将整体数据一分为多份，进行散布式的插入排序，这时候每一个子序列之间的间隙就是。
2.C_数据结构_线性表
Fresh_man111的博客
09-07 1093
线性表就是若干数据的一个线性序列。数学表达式：L：表名a0~an-1：数据元素n：表长，n>0是为非空表二元描述形式：D：数据元素D用 ai 表示，这个 i 范围是0~n-1R：关系用R表示，这个关系是，表示ai为ai+1的直接前驱，ai+1为ai的直接后继。：这符号称为有序对，xxx1是xxx2的直接前驱，xxx2是xxx1的直接后继。 xxx1和xxx2可以为一个或多个。
21_动态规划与数据结构结合
刘炫320的博客
09-11 389
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
从头开始嵌入式第三十八天（数据结构 双向链表）
最新发布
qq_64792908的博客
09-11 414
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 325
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
数据结构——(java版）Map与Set
2301_77993957的博客
09-11 539
哈希表是一种数据结构，其实现思想是基于通过数据的关键码与所存地址两者之间构建映射关系，能够一次直接从表中得到想要搜索的元素。数据的关键码与所存地址之间的关系由哈希函数实现，规则为：设定适合的哈希函数之后，输入的关键码通过哈希函数的计算得出所存的地址。由此构造出来的结构称为哈希表。哈希表相对于二叉搜索树以及其他查询方式，不需要与多个关键码比较，这极大提升了查询的效率。
数据结构-线性表详解
"沈阳工程学院信息工程系的数据结构课件，主要涵盖了线性表的概念、表示及实现" 在计算机科学中，数据结构是组织和管理数据的重要工具，它研究如何高效地存储、检索和操作数据。线性表是数据结构中最基础也是最常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值