精华内容
下载资源
问答
  • 单链表的优缺点_链表优缺点

    千次阅读 2020-09-15 00:11:54
    单链表的优缺点Here you will learn about advantages and ... 在这里,您将了解链表优缺点。 It is a data structure in which elements are linked using pointers. A node represents an element in link...

    单链表的优缺点

    Here you will learn about advantages and disadvantages of linked list.

    在这里,您将了解链表的优缺点。

    It is a data structure in which elements are linked using pointers. A node represents an element in linked list which have some data and a pointer pointing to next node. Its structure looks like as shown in below image.

    它是一种数据结构,其中的元素使用指针链接。 一个节点代表链表中的一个元素,该元素具有一些数据和一个指向下一个节点的指针。 其结构如下图所示。

    Advantages and Disadvantages of Linked List

    There are various merits and demerits of linked list that I have shared below.

    我在下面分享了链表的各种优缺点。

    链表的优缺点 (Advantages and Disadvantages of Linked List)

    链表的优点 (Advantages of Linked List)

    Dynamic Data Structure

    动态数据结构

    Linked list is a dynamic data structure so it can grow and shrink at runtime by allocating and deallocating memeory. So there is no need to give initial size of linked list.

    链表是一个动态数据结构,因此它可以在运行时通过分配和取消分配内存来增长和收缩。 因此,无需给出链表的初始大小。

    Insertion and Deletion

    插入和删除

    Insertion and deletion of nodes are really easier. Unlike array here we don’t have to shift elements after insertion or deletion of an element. In linked list we just have to update the address present in next pointer of a node.

    节点的插入和删除确实非常容易。 与数组不同,在插入或删除元素后,我们不必移动元素。 在链表中,我们只需要更新节点的下一个指针中存在的地址即可。

    No Memory Wastage

    没有记忆浪费

    As size of linked list can increase or decrease at run time so there is no memory wastage. In case of array there is lot of memory wastage, like if we declare an array of size 10 and store only 6 elements in it then space of 4 elements are wasted. There is no such problem in linked list as memory is allocated only when required.

    由于链表的大小可以在运行时增加或减小,因此不会浪费内存。 在数组的情况下,会浪费大量内存,例如,如果我们声明一个大小为10的数组并在其中仅存储6个元素,那么就会浪费4个元素的空间。 链表中没有这种问题,因为仅在需要时才分配内存。

    Implementation

    实作

    Data structures such as stack and queues can be easily implemented using linked list.

    使用链接列表可以轻松实现诸如堆栈和队列之类的数据结构。

    链表的缺点 (Disadvantages of Linked List)

    Memory Usage

    内存使用情况

    More memory is required to store elements in linked list as compared to array. Because in linked list each node contains a pointer and it requires extra memory for itself.

    与数组相比,在链表中存储元素需要更多的内存。 因为在链表中,每个节点都包含一个指针,并且它本身需要额外的内存。

    Traversal

    遍历

    Elements or nodes traversal is difficult in linked list. We can not randomly access any element as we do in array by index. For example if we want to access a node at position n then we have to traverse all the nodes before it. So, time required to access a node is large.

    在链表中很难遍历元素或节点。 我们不能像按索引在数组中那样随机访问任何元素。 例如,如果我们要访问位置n处的节点,则必须遍历它之前的所有节点。 因此,访问节点所需的时间很大。

    Reverse Traversing

    反向遍历

    In linked list reverse traversing is really difficult. In case of doubly linked list its easier but extra memory is required for back pointer hence wastage of memory.

    在链表中,反向遍历确实很困难。 在双链表的情况下,它比较容易,但是向后指针需要额外的内存,因此浪费了内存。

    影片教学 (Video Tutorial)

    翻译自: https://www.thecrazyprogrammer.com/2016/11/advantages-disadvantages-linked-list.html

    单链表的优缺点

    展开全文
  • 数据结构优缺点

    2021-03-09 15:03:22
    数据结构优缺点 数组(Array):快速访问数据,很少插入和删除元素,就应该用数组。 优点:查询快,通过索引直接查找;有序添加,添加速度快,允许重 复; 缺点:在中间部位添加、删除比较复杂,...

    数据结构的优缺点

    • 数组(Array):快速访问数据,很少插入和删除元素,就应该用数组。

      • 优点:查询快,通过索引直接查找;有序添加,添加速度快,允许重 复;

      • 缺点:在中间部位添加、删除比较复杂,大小固定,只能存储一种类型的数据;

    • 链表(LinkedList):经常插入和删除元素,就应该用链表

      • 优点:有序添加、增删改速度快,对于链表数据结构,增加和删除只要修改元素中 的指针就可以了;

      • 缺点:查询慢,如果要访问链表中一个元素,就需要从第一个元素开始查找;

    • 栈(Stack):

      • 优点:提供后进先出的存储方式,添加速度快,允许重复;

      • 缺点:只能在一头操作数据,存取其他项很慢;

    • 队列(Queue):

      • 优点:提供先进先出的存储方式,添加速度快,允许重复;

      • 缺点:只能在一头添加,另一头获取,存取其他项很慢;

    • 哈希(Hash):特点:散列表,不允许重复;

      • 优点:如果关键字已知则存取速度极快;

      • 缺点:如果不知道关键字则存取很慢,对存储空间使用不充分;

    展开全文
  • 1:顺序优缺点:List 优点:顺序表示用地址连续的存储单元顺序存储线性表中的各个元素,逻辑上相领的数据元素在物理位置上也相领,因此,在顺序中查找任何一个位置上的数据元素非常方便; 缺点:在顺序中...

    1:顺序表的优缺点:List

    优点:顺序表示用地址连续的存储单元顺序存储线性表中的各个元素,逻辑上相领的数据元素在物理位置上也相领,因此,在顺序表中查找任何一个位置上的数据元素非常方便;

    缺点:在顺序表中插入及删除时需要通过移动数据元素来实现,影响了运行的效率;

     

    2:线性表的另外一种存储结构---链式存储LinkList

    优点:对链表进行插入和删除时不需要去移动数据元素,效率比较高

    缺点:失去了对线性表可随机存储的优点

     

    顺序表实现接口

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 线性表
    {
        interface IList<T>
        {
            int GetLength();
            void Clear();
            bool IsEmpty();
            void Add(T item);
            void Insert(T item, int index);
            void Delete(int index);
            T this[int index] { get; }
            T GetEle(int index);
            int Locate(T value);
        }
    }
    

    顺序表实现方法:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 线性表
    {
        class MyList<T>:IList<T>
        {
            public T[] data;
    
            private int count;
    
            public MyList(int size) {
                data = new T[size];
                count = 0;
            }
    
            public MyList():this(10) 
            {
            
            }
    
            public int GetLength()
            {
                return count;
            }
    
            public void Clear()
            {
                count = 0;
            }
    
            public bool IsEmpty()
            {
                return count == 0;
            }
    
            public void Add(T item)
            {
                if (count == data.Length)
                {
                    Console.WriteLine("当前顺序表已存满,不允许在存入");
                }
                else {
                    data[count] = item;
                    count++;
                }
            }
    
            public void Insert(T item, int index)
            {
                if (index >= 0 && index <= count - 1)
                {
                    for (int i = count - 1; i >= index; i--)
                    {
                        if (i + 1 >= data.Length)
                        {
    
                        }
                        else
                        {
                            data[i + 1] = data[i];
                        }
                    }
                    data[index] = item;
                    if (count == data.Length)
                    {
                        Console.WriteLine("存储满了  替换元素");
                    }
                    else {
                        count++;
                    }
                }
                else {
                    Console.WriteLine("下标越界了------------>");
                }
            }
    
            public void Delete(int index)
            {
                if (index >= 0 && index <= count - 1)
                {
                    for (int i = index; i < count; i++)
                    {
                        if (i + 1 >= count)
                        {
    
                        }
                        else
                        {
                            data[i] = data[i + 1];
                        }
                    }
                    count--;
                }
                else {
                    Console.WriteLine("下标越界了------------>");
                }
            }
    
            public T this[int index]
            {
                get
                {
                    if (index >= 0 && index <= count)
                    {
                        return data[index];
                    }
                    else
                    {
                        return default(T);
                    }
                }
            }
    
            public T GetEle(int index)
            {
                if (index >= 0 && index <= count -1 )
                {
                    return data[index];
                }
                else { 
                  return default(T);
                }
            }
    
            public int Locate(T value)
            {
                for (int i = 0; i < count; i++)
                {
                    if (data[i].Equals(value))
                    {
                        return i;
                    }
                }
                return -1;
            }
        }
    }
    

    单链表实现接口:

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 线性表
    {
        /// <summary>
        /// 单链表的节点
        /// </summary>
        /// <typeparam name="T"></typeparam>
        class Node<T>
        {
            private T data;//存储数据
    
            private Node<T> next;//指针   用来指向下一个元素
    
            public Node(T value) {
                data = value;
                next = null;
            }
    
            public Node(T value, Node<T> next) {
                data = value;
                this.next = next;
            }
    
            public Node(Node<T> next) {
                this.next = next;
            }
    
            public Node() { 
                data = default(T);
                next = null;
            }
    
            public T Data {
                get { return data; }
                set { data = value; }
            }
    
            public Node<T> Next {
                get { return next; }
                set { next = value; }
            }
        }
    }
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace 线性表
    {
        class LinkList<T>:IList<T>
        {
            private Node<T> head;//存储一个头节点
    
            public LinkList()
            {
                head = null;
            }
    
            public int GetLength()
            {
                if (head == null)
                {
                    return 0;
                }
                Node<T> temp = head;
                int count = 1;
                while (true) {
                    if (temp.Next != null)
                    {
                        count++;
                        temp = temp.Next;
                    }
                    else {
                        break;
                    }
                }
                return count;
            }
    
            public void Clear()
            {
                head = null;//GC 会自动回收其他指针的内存
            }
    
            public bool IsEmpty()
            {
                return head == null;
            }
    
            public void Add(T item)
            {
                Node<T> newNode = new Node<T>(item);
                //如果头节点为空,那么这个新的节点就是头节点
                if (head == null)
                {
                    head = newNode;
                }
                else {
                    Node<T> temp = head;
                    while (true) {
                        if (temp.Next != null)
                        {
                            temp = temp.Next;
                        }
                        else {
                            break;
                        }
                    }
                    //把新的节点放置尾部
                    temp.Next = newNode;
                }
            }
    
            public void Insert(T item, int index)
            {
                Node<T> newNode = new Node<T>(item);
                //插入到头结点
                if (index == 0)
                {
                    newNode.Next = head.Next;
                    head.Next = newNode;
                }
                else {
                    Node<T> temp = head;
                    for (int i = 1; i <= index-1; i++)
                    {
                        //让temp向后移动一个位置
                        temp = temp.Next;
                    }
                    Node<T> preNode = temp;
                    Node<T> currentNode = temp.Next;
                    preNode.Next = newNode;
                    newNode.Next = currentNode;
                }
            }
    
            public void Delete(int index)
            {
                if (index == 0)
                {
                    Node<T> temp = head.Next;
                    head = temp;
                    head.Next = temp.Next;
                }
                else
                {
                    Node<T> temp = head;
                    for (int i = 0; i <= index - 1; i++)
                    {
                        temp = temp.Next;
                    }
                    Node<T> preTemp = temp;
                    Node<T> curTemp = preTemp.Next;
                    Node<T> nextTemp = curTemp.Next;
                    preTemp.Next = nextTemp;
                }
            }
    
            public T this[int index]
            {
                get
                {
                    Node<T> temp = head;
                    for (int i = 1; i <= index; i++)
                    {
                        temp = temp.Next;
                    }
                    return temp.Data;
                }
            }
    
            public T GetEle(int index)
            {
                return this[index];
            }
    
            public int Locate(T value)
            {
                Node<T> temp = head;
                if (temp == null)
                {
                    return -1;
                }
                else {
                    int index = 0;
                    while (true)
                    {
                        if (temp.Data.Equals(value))
                        {
                            return index;
                        }
                        else {
                            if (temp.Next != null)
                            {
                                temp = temp.Next;
                                index++;
                            }
                            else {
                                break;
                            }
                        }
                    }
                }
                return -1;
            }
        }
    }
    

     

    展开全文
  • 如图所示: ①顺序结构: 优点:易于查询,索引快 list[n]这样的du操作...②链表结构: 优点:扩展性强,易于删除、添加 缺点:不易于查询,索引慢,list[n]这样的操作,复杂度为O(n) 二者优缺点正好是互补关系 ...

    如图所示: 

    ①顺序结构:
    优点:易于查询,索引快 list[n]这样的操作,O(1)复杂度
    缺点:扩展性弱,不易删除、添加。
    ②链表结构:
    优点:扩展性强,易于删除、添加
    缺点:不易于查询,索引慢,list[n]这样的操作,复杂度为O(n)
    二者优缺点正好是互补关系 

    展开全文
  • Java常见数据结构&优缺点。 数组 优点:查询快,如果知道索引可以快速地存取 缺点:删除慢,大小固定 有序数组 优点:比无序数组查找快 缺点:删除和插入慢,大小固定 栈 优点:提供后进先出的存取方式 缺点:存取...
  • 各类数据结构之间的优缺点对比

    千次阅读 2020-03-05 12:09:00
    数据结构包含数组、链表、二叉树、栈、哈希等等。 什么是算法 算法是对数据结构的各种处理。例如查找一条特殊的数据项或对数据进行排序。 各数据结构之间的优缺点对比 数据结构 优点 缺点 数组 插入快,...
  • 链表是一种数据结构,在内存中通过节点记录内存地址,相互链接形成一条链的存储方式,和数组一样是一种线性表,但相比数组而言,链表在内存中不需要连续的区域,只需要每个节点都能记录下下一个节点的内存地址,通过...
  • 各种数据结构优缺点

    千次阅读 2017-03-29 16:08:15
    本文说下有关数组,链表,树,队列,栈这几种数据结构优缺点。 1.数组:数组随机访问的时间复杂度为O(1),顺序访问的时间复杂度为O(n). 增删时候,最好的情况是在数组的末尾进行增删,时间复杂度是O(1),最坏的...
  • Java中数组、集合、链表、队列的数据结构优缺点和他们之间的区别 数组: 长度固定 可以存储基本类型,也可以存储引用类型 存储元素类型一致 数组可以在内存中连续存储多个元素的构造,在内存中的分配也是连续的 ...
  • Java中数组、集合、链表、队列的数据结构优缺点和他们之间的区别 数组: .长度固定 .可以存储基本类型,也可以存储引用类型 .存储元素类型一致 数组可以在内存中连续存储多个元素的构造,在内存中的分配也是连续的...
  • 独家分享:常见Java数据结构&优缺点   数组 优点:查询快,如果知道索引可以快速地存取 缺点:删除慢,大小固定 有序数组 优点:比无序数组查找快 ...
  • 顺序链表优缺点

    千次阅读 2018-04-03 12:23:23
    顺序: 他是在计算机内存中以数组形式...优缺点: 空间的开辟 顺序是需要开辟连续的空间,当需要的空间不够,而有需要插入的时候,就需要再重新开辟空间,将原先的内容拷贝到新的空间,这就开销比较大了。(...
  • 静态链表优缺点 优点: 在插入和删除操作时,只需要修改被删节点上一节点的链接地址,不需要移动元素,从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点缺点: 没有解决连续存储分配...
  • 本文,将围绕着数组和链表优缺点这一中心,来展现给初学数据结构,或者对这两种数据类型理解还不充分的初学者一个比较详尽的比较和启发。笔者水平有限,不足之处,望批评指正。  首先我们从两种数据结构在计算机...
  • 常见数据结构优缺点比较

    千次阅读 2017-12-11 11:17:08
    数据结构是对在计算机内存中的数据的一种安排,数据结构包括数组,链表,栈,二叉树,哈希等等,数据结构和技术与如何处理现实世界数据存储问题项链,现实世界数据指的是那些描述处于计算机外部的物理实体的数据。...
  • 独家分享:常见Java数据结构&优缺点   数组 优点:查询快,如果知道索引可以快速地存取 缺点:删除慢,大小固定 有序数组 优点:比无序数组查找快 缺点:删除和插入慢,大小固定 栈 ...
  • 如今数据结构多种多样,各数据结构优缺点特别容易搞混,以下特意稍作总结,以供大家和自己学习使用。 数据结构 优点 缺点 (无序)数组 插入快,若知道下标,可快速存取 查找慢、删除慢,大小固定 有序数组 ...
  • 链表是一种物理存储单元上非连续、非顺序的存储结构数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每个元素称为结点)组成,结点可以在运行时动态生成。 结点:每个结点包含两个...
  •  首先我们在面试时可能会遇到说明一下顺序链表优缺点,说说他们分别在什么场景下使用: 1.首先我们从2种结构结构上来进行分析: (1)对于顺序。不论是静态的还是动态的,他们都是连续的存储空间,在...
  • 数组链表 结构优缺点

    2018-04-22 21:57:02
    数组:内存地址连续存放 链表:内存地址不连续 优点:遍历快 增删块 缺点:增删慢 遍历慢...
  • 几种数据结构优缺点

    千次阅读 2019-01-29 23:42:23
    缺点:查找慢,删除慢,大小固定   链表: 优点:插入快,删除快 缺点:查找慢 单向链表: 双向链表:   栈: 优点:提供后进先出的存取方式 缺点:存取其他项很慢   队列: 优点:提供先进先出的存取...
  • 常见数据结构优缺点

    千次阅读 2018-12-02 22:23:53
    通用数据结构: 1.数组 分类: 无序数组,有序数组 特点: 一般针对数据量较小且数据可预知的情况,创建时指定大小,不利于扩展;在内存中预留一块连续的区域,内存空置率高利用率较低;无序数组插入较快,...
  • 常用数据结构优缺点

    千次阅读 2017-03-17 10:45:32
    2 单链表、双链表结构,LinkedList list = new LinkedList(),除了头节点,每个节点包含一个数据域一个指针域,除了头、尾节点,每个节点的指针指向下一个节点,单链表最好玩儿的也就是增加和删除节点。...
  • 数据结构链表与顺序优缺点

    千次阅读 2018-07-09 11:20:26
    1.顺序存储 原理:顺序存储是将数据元素放到一块连续的内存存储空间,存取效率高,速度快。但是不可以动态增加长度 优点:存取速度高效,通过下标来直接存储 缺点:1.插入和删除比较慢,2.不可以增长长度 ...
  • 顺序链表都是线性表(n个具有相同特性的数据元素形成的有限序列)。 顺序是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。顺序又分为...
  • 数组和链表是两种基本的数据结构,他们在内存存储上的表现不一样,所以也有各自的特点。 大致总结一下特点和区别,拿几个人一起去看电影时坐座位为例。 数组的特点 在内存中,数组是一块连续的区域。 拿上面的看...
  • 第一节 线性表顺序结构特征及优缺点 特征 时间复杂度 线性表的顺序储存结构,在存读数据时,不管是哪个位置,时间复杂度都是O(1)。而在插入或删除时,时间复杂度都是O(n)。 这就说明他比较适合元素个数比较稳定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,841
精华内容 35,936
关键字:

数据结构链表优缺点

数据结构 订阅