javascript

java

python

c#

android

node.js

reactjs

c++

php

html

jquery

css

git

.net

ios

ruby-on-rails

sql

c

string

ruby

CodeGo.net>创建一个非常简单的链表

我试图创建一个链表只是为了查看是否可以,但是我很难理解它。 有没有人有使用C#非常简单地实现链接列表的示例? 到目前为止,我发现的所有示例都过头了。

trans by 2019-11-08T17:13:34Z

java-ArrayList与LinkedList

我在此之前的一篇帖子中写道:

对于LinkedList

  • 得到的是O(n)
  • 加为O(1)
  • 删除为O(n)
  • Iterator.remove为O(1)

对于ArrayList

  • 得到的是O(1)
  • add为O(1)摊销,但O(n)为最差情况,因为必须调整数组大小并复制
  • 删除为O(n)

因此,通过观察这一点,我得出的结论是,如果我只需要对集合中的序列进行插入(例如5000000个元素),则ArrayList的性能将超过Linkedlist

如果我只需要通过迭代来从集合中获取元素,即不抓住中间的元素,那么ArrayList仍然会比ArrayList更好。

现在,要验证我的上述两个语句,我编写了以下示例程序…但令我惊讶的是,我的上述语句被证明是错误的。

在这两种情况下,ArrayList都超过了Linkedlist。 从Collection中添加和获取它们所花的时间少于LinkedList。 我在做错什么吗,或者关于LinkedListArrayList的初始声明不适用于大小为5000000的集合?

我提到过大小,因为如果将元素数量减少到50000,则LinkedList的性能会更好,初始语句也适用。

long nano1 = System.nanoTime();

List<Integer> arr = new ArrayList();
for(int i = 0; i < 5000000; ++i) {
    arr.add(i);
}
System.out.println( (System.nanoTime() - nano1) );

for(int j : arr) {
    ;
}
System.out.println( (System.nanoTime() - nano1) );

long nano2 = System.nanoTime();

List<Integer> arrL = new LinkedList();
for(int i = 0; i < 5000000; ++i) {
    arrL.add(i);
}
System.out.println( (System.nanoTime() - nano2) );

for(int j : arrL) {
    ;
}
System.out.println( (System.nanoTime() - nano2) );
trans by 2019-10-04T09:31:58Z

algorithm - 检查两个链表是否合并。 如果是的话,在哪里?

这个问题可能已经过时了,但我想不出答案。

比方说,有两个不同长度的列表,在某一点合并; 我们怎么知道合并点在哪里?

条件:

  1. 我们不知道长度
  2. 我们应该只解析每个列表一次。

Example of two merged linked lists.

trans by 2019-09-18T06:25:43Z

big o - 为什么插入链表O(1)的中间?

根据关于链表的维基百科文章,在链表中间插入被认为是O(1)。 我认为这将是O(n)。 您是否需要找到可能接近列表末尾的节点?

此分析是否不考虑节点操作的发现(虽然它是必需的)并且只是插入本身?

编辑:

链接列表与数组相比有几个优点。 在列表的特定点处插入元素是恒定时间操作,而在数组中插入可能需要移动一半或更多元素。

上述陈述对我来说有点误导。 如果我错了,请纠正我,但我认为结论应该是:

阵列:

  • 找到插入/删除点O(1)
  • 执行插入/删除O(n)

链接列表:

  • 找到插入/删除点O(n)
  • 执行插入/删除O(1)

我认为你唯一一次不必找到位置就是你保留了某种指针(如某些情况下的头部和尾部)。 因此,我们不能断然说链接列表总是超过插入/删除选项的数组。

trans by 2019-09-14T14:35:20Z

数据结构 - 以递归方式反转Java中的链表

我一直在为一个类的Java项目工作。 它是链表的实现(此处称为private ListNode reverse(ListNode current),包含名为ListNode的简单节点)。 问题在于,所有事情都必须通过递归算法来完成。 我能做的一切都很好,没有一种方法:public AddressList reverse()

ListNode:

public class ListNode{
  public String data;
  public ListNode next;
}

现在我的private ListNode reverse(ListNode current)函数只调用一个辅助函数,该函数接受一个允许递归的参数。

public AddressList reverse(){
  return new AddressList(this.reverse(this.head));
}

我的帮助函数具有private ListNode reverse(ListNode current)的签名。

目前,我使用堆栈迭代地工作,但这不是规范要求的。 我在C中找到了一个递归反转的算法,并手工将其转换为Java代码,但是它有效,但我对此并不了解。

编辑:没关系,我在此期间弄清楚了。

private AddressList reverse(ListNode current, AddressList reversedList){
  if(current == null) 
      return reversedList;
  reversedList.addToFront(current.getData());
  return this.reverse(current.getNext(), reversedList);
}

虽然我在这里,有没有人看到这条路线有任何问题?

trans by 2019-07-26T16:23:05Z

语言无关 - 链接列表在什么情况下有用?

大多数时候,我看到人们尝试使用链接列表,在我看来,这似乎是一个糟糕(或非常差)的选择。 也许有必要探讨链表是否是数据结构的良好选择的情况。

理想情况下,答案将阐述用于选择数据结构的标准,以及哪些数据结构在特定情况下可能最有效。

编辑:我必须说,我不仅对数字,而且对答案的质量印象深刻。 我只能接受一个,但如果有一些更好的东西不存在,那么还有两三个我不得不说会值得接受。 只有一对(特别是我最终接受的那个)指出了链表提供了真正优势的情况。 我确实认为Steve Jessop不仅要提出一个,而且要提出三个不同的答案,值得一提,我发现这些答案令人印象深刻。 当然,即使它只是作为评论发布而不是答案,我认为Neil的博客条目也值得一读 - 不仅信息丰富,而且非常有趣。

trans by 2019-07-24T15:06:53Z

c - 如何仅使用两个指针来反转单链表?

我想知道是否存在一些逻辑来仅使用两个指针来反转链表。

以下用于使用三个指针(即p,q,r)反转单个链表:

struct node
{
    int data;
    struct node *link;
};

void reverse()
{
    struct node *p = first,
                *q = NULL,
                *r;
    while (p != NULL)
    {
        r = q;
        q = p;
        p = p->link;
        q->link = r;
    }
    q = first;
}

还有其他替代方法来反转链表吗? 在时间复杂度方面,逆转单链表的最佳逻辑是什么?

trans by 2019-07-12T22:19:06Z

算法 - 二叉树与链接列表与哈希表

我正在为我正在进行的项目构建一个符号表。 我想知道人们对可用于存储和创建符号表的各种方法的优点和缺点的看法。

我做了很多搜索,最常推荐的是二叉树或链表或哈希表。 以上所有优点和缺点是什么? (在c ++中工作)

trans by 2019-06-06T11:17:26Z

algorithm - 检查两个链表是否合并。 如果是的话,在哪里?

这个问题可能已经过时了,但我想不出答案。

比如,有两个不同长度的列表,在某一点合并; 我们怎么知道合并点在哪里?

条件:

  1. 我们不知道长度
  2. 我们应该只解析每个列表一次。

Example of two merged linked lists.

trans by 2019-04-26T15:40:28Z

big o - 为什么插入链表O(1)的中间?

根据关于链表的维基百科文章,在链表中间插入被认为是O(1)。 我认为这将是O(n)。 您是否需要找到可能接近列表末尾的节点?

此分析是否不考虑节点操作的发现(虽然它是必需的)并且只是插入本身?

编辑:

链接列表与数组相比有几个优点。 在列表的特定点处插入元素是恒定时间操作,而在数组中插入可能需要移动一半或更多元素。

上述陈述对我来说有点误导。 如果我错了,请纠正我,但我认为结论应该是:

阵列:

  • 找到插入/删除点O(1)
  • 执行插入/删除O(n)

链接列表:

  • 找到插入/删除点O(n)
  • 执行插入/删除O(1)

我认为你唯一一次不必找到位置就是你保留了某种指针(如某些情况下的头部和尾部)。 因此,我们不能断然说链接列表总是超过插入/删除选项的数组。

trans by 2019-04-19T18:26:23Z

Python链接列表

在python中使用链表最简单的方法是什么? 在方案中,链接列表仅由'(1 2 3 4 5)定义.Python的列表,[1, 2, 3, 4, 5]和元组,(1, 2, 3, 4, 5),实际上不是链表,链表有一些很好的属性,如常量时间连接,并且能够引用 它们各自的一部分。 让它们一成不变,它们真的很容易合作!

trans by 2019-04-19T04:38:57Z

数据结构 - 数组与链表

为什么有人想在阵列上使用链表?

毫无疑问,对链接列表进行编码比使用数组要多一些工作,人们可能想知道什么是合理的额外工作。

我认为在链表中插入新元素是微不足道的,但它是数组中的一项重要工作。 使用链表存储一组数据与将其存储在数组中是否还有其他优点?

这个问题不是这个问题的重复,因为另一个问题是具体询问特定的Java类,而这个问题与一般数据结构有关。

trans by 2019-03-30T14:25:25Z

c ++ - 为什么std :: list :: reverse有O(n)复杂度?

为什么C ++标准库中std::list类的反向函数具有线性运行时? 我认为对于双向链表,反向函数应该是O(1)。

反转双向链表应该只涉及切换头指针和尾指针。

trans by 2019-03-28T16:14:31Z

c# - 我应该何时使用列表与链接列表

什么时候使用List vs LinkedList更好?

trans by 2019-01-28T02:27:24Z

java - 如何检测链表中的循环?

假设您在Java中有一个链表结构。 它由节点组成:

class Node {
    Node next;
    // some user data
}

每个节点都指向下一个节点,最后一个节点除外。 假设列表有可能包含一个循环 - 即最终节点而不是具有空值,则引用列表中之前的节点之一。

什么是最好的写作方式

boolean hasLoop(Node first)

如果给定节点是带循环的列表中的第一个,则返回true,否则返回false? 你怎么写,这需要一个恒定的空间和合理的时间?

这是一个循环列表的图片:

alt text

trans by 2019-01-25T18:50:11Z

何时在Java中使用LinkedList over ArrayList?

我一直只是一个人使用:

List<String> names = new ArrayList<>();

我使用接口作为可移植性的类型名称,因此当我问这些问题时,我可以重新编写代码。

何时应该使用ArrayList而不是ArrayList,反之亦然?

trans by 2018-12-20T21:43:29Z

1 共1页