Python中表到串转换的时间和空间复杂度
在Python中，表到串转换的时间复杂度为O(n)，其中n是表的长度。这是因为在转换过程中，需要遍历整个表并将每个元素连接起来形成一个串。
空间复杂度取决于转换后的串的长度，即O(m)，其中m是串的长度。这是因为需要创建一个新的串来存储转换后的结果。
在Python中，可以使用join()方法来实现表到串的转换。该方法将表中的元素连接成一个串，并可以指定连接符号。以下是一个示例代码：
table = ['Hello', 'World', '!']
delimiter = ' '
string = delimiter.join(table)
print(string)输出结果为：
Hello World !在这个例子中，表中的元素被连接成一个以空格为分隔符的串。
对于表到串转换的应用场景，常见的情况包括将列表中的元素连接成一个字符串，以便进行文件写入、网络传输等操作。
腾讯云提供了多种与Python开发相关的产品和服务，例如云服务器、云数据库、云函数等。具体推荐的产品和产品介绍链接地址可以根据具体需求和使用场景进行选择。
相关·内容
1回答
反向字符串时间和空间复杂度
、、、、
我编写了不同的python代码来反转给定的字符串。但是，无法计算出其中哪一个是有效的。有人能指出使用时间和空间复杂性的这些算法的区别吗？
def reverse_1(s):
result = ""
for i in s :
result = i + result
return result
def reverse_2(s):
return s[::-1]
有，但我找不到时间和空间的复杂性。我想知道s[::-1]将占用多少空间？
浏览 1提问于2018-07-14得票数 4
回答已采纳
Python中的xrange()、random.randint(1,100)和sort()函数的时间和空间复杂度是多少？
import random
a = [random.randint(1,100) for i in xrange(1000000)]
print a
a.sort()
print a
浏览 4提问于2015-06-06得票数 1
回答已采纳
我是一个初级开发人员，仍然不是很熟悉大O。
这是我的leetcode问题的解决方案，我不确定这个解决方案的时间和空间复杂度是多少。
String s = "";
String t = "";
int back = 0;
for (int i = S.length() - 1; i >= 0; i--) {
if (S.charAt(i) == '#') {
back++;
continue;
}
if (back
浏览 3提问于2019-11-28得票数 0
1回答
我试图确定我创建的这个算法的时间和空间复杂性，以查找Python中数组的所有排列。时间复杂度O(sum_{k=1}^N P(n，k))，其中P(n，k)是k因子的置换吗？
class Solution:
def permute(self, vals):
answer = [vals]
def backtrack(i, curr_arr):
if i >= len(vals):
return
curr_val = curr_arr[i]
for j
浏览 14提问于2021-12-18得票数 0
def square(n):
def same_number(n):
if n == 0 :
return 0
else :
return 1 + same_numer(n - 1)
return n * same_number(n)
据我所知，same_number的时间复杂度和空间复杂度都是O(n)。然而，被称为same_number的square的时间和空间复杂度是什么呢？它只有1，还是你必须考虑到same_number？
浏览 0提问于2018-02-03得票数 0
1回答
将n转换为其英文单词表示，其中0 <= n <1 000 000 000
Python解决方案：
class Solution:
def helper(self, n):
ones = ['', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine']
teens = ['Ten',
浏览 0提问于2020-11-09得票数 0
1回答
时间/空间复杂性
、、、、
准备考试。我认为时间复杂度是O(n^2)，空间复杂度是O(1)。请帮帮忙，我说的对吗？ public static String lastSubstring(String s) {
int start=0;
int end = start+1;
int len =0;
while (end + len < s.length()) {
if (s.charAt(start + len) == s.charAt(end + len)) {
len++;
} else if (s.c
浏览 19提问于2020-11-02得票数 0
2回答
我想验证我关于JavaScript中有效回文函数的两个不同实现的时间和空间复杂性的假设。
在第一个实现中，我们使用一个助手函数，只传递指针。
const isPalindrome = str => {
return isPalindromeHelper(str, 0, str.length - 1);
}
const isPalindromeHelper = (str, start, end) => {
if (end - start < 1) return true;
return str[start] === str[end] && isP
浏览 6提问于2022-05-13得票数 1
回答已采纳
2回答
我试图理解以下代码的空间复杂性。代码将字符串从"aabbbb“压缩到"a2b4”。问题5，第一章，破解编码面试版本5(2013年)，代码取自
public static String compressBetter(String str) {
int size = countCompression(str);
if (size >= str.length()) {
return str;
}
StringBuffer mystr = new StringBuffer();
char last = str.charAt
浏览 0提问于2018-03-06得票数 0
回答已采纳
请原谅，因为我对空间复杂性和时间复杂性都不是很熟悉。
我的问题是，
想象一下，在Java语言中有一段代码，它将读取一个.csv文件，然后将每一行打印到.txt中作为输出。
据我所知，时间复杂度在一定程度上取决于行数。空间复杂度是在运行时需要多少空间。(如果这是错误的，请向我简要介绍)
如上所述，如果我编写代码，将input.csv中的所有行一次性转换为某种数据结构，然后使用相同的数据结构将整个代码打印到output.txt中，会不会得到更差的空间复杂度，但更好的时间复杂度？此外，如果我逐行阅读，并在同一个循环中将它们打印到output.txt上，会不会带来更好的空间复杂度，但更差的时间复杂度？
浏览 7提问于2021-05-02得票数 1
有人能举例说明我们如何计算这两种遍历方法的时间和空间复杂度吗？
另外，深度优先遍历的递归解决方案如何影响时间和空间复杂度？
浏览 1提问于2012-03-24得票数 76
回答已采纳
1回答
我不擅长确定时间复杂性和记忆复杂性，如果有人能帮我解决问题，我会很感激的。
我有一种算法，可以从缓存中返回数据或获取数据，如果数据不在缓存中，我不确定它的时间和内存复杂性。
我想弄明白什么?
它的时间和记忆的复杂性是什么以及为什么。
在发布问题之前我做了什么?
我读过，，和更多的链接。
到目前为止我做了什么?
正如我从我读过的所有文章和问题中了解到的，我所有的循环操作都是线性的。我有3个循环，所以它是N+N+N复杂性，我们可以把它写成N。我认为getData的复杂性是O(n)。空间复杂性更复杂，因为我理解它通常等于简单数据结构的时间复杂性，所以我认为空间复杂性也是N，但是我有cache对象(哈
浏览 0提问于2018-10-04得票数 0
回答已采纳
3回答
在Python中，如果将一个列表转换为一个集合，那么运行时间和空间复杂性是什么？
Example:
data = [1,2,3,4,5,5,5,5,6]
# this turns list to set and overwrites the list
data = set(data)
print data
# output will be (1,2,3,4,5,6)
浏览 3提问于2016-08-17得票数 5
回答已采纳
3回答
我正在学习不同的排序算法及其时间/空间复杂度，并看到冒泡排序和插入排序等算法的空间复杂度为O(1)。
这让我感到奇怪，因为最低的空间复杂度肯定是O(n) (例如，存储数据集所需的内存，仅此而已)？
浏览 1提问于2017-05-10得票数 7
回答已采纳
这不是获取Fibonacci序列号的最有效方法，但我正在学习Big，并希望确认和解释下面代码的空间和时间效率。代码是用Python编写的，因此我使用一个列表并将其附加到其中，然后返回最后一个值。
追加方法需要O(1)时间，如图中所示的，但是我做了几乎n次的操作，所以我会得到时间复杂度的O(n)吗？
关于空间复杂性，我是否应该考虑作为使用的空间，因为如果输入的数字大于函数堆栈开始时的大小，列表就必须移到别处？
此中的代码用于递归方法。
def getFib(position):
if position == 0:
return 0
if position == 1:
re
浏览 0提问于2018-04-14得票数 0
回答已采纳
2回答
输入:正整数列表，其中一个条目恰好出现一次，而所有其他条目恰好发生两次(例如，1、3、2、5、3、4、1、2、4)
输出:唯一条目(在上面的示例中为5)
下面的算法应该是O(m)时间和O(1)空间，其中m是列表的大小。
def get_unique(intlist):
unique_val = 0
for int in intlist:
unique_val ^= int
return unique_val
我的分析是:给定一个长度为m的列表，输入列表中将有(m+1)/2唯一正整数，因此列表中最小的最大整数将是(m+1)/2，如果我们假设这种最佳情况，那
浏览 4提问于2016-06-12得票数 2
回答已采纳
我在O(n)时间和空间复杂度上实现了panagram程序。我希望我的程序在O(n)时间复杂度和O(1)空间复杂度。
我的步骤是：
将字符串转换为字符数组。
将所有字符添加到树集(以避免重复)
如果树集的大小为26，我将打印为panagram。
有没有优化的方法将我的空间复杂度降低到O(1)？
浏览 0提问于2016-01-24得票数 2
1回答
对于一个算法的平均时间复杂度，您使用了什么符号？在我看来，正确的方法是使用大θ来引用一组结果(即使特定的尝试可能不同)。例如，平均数组搜索将是n+1(Θ)/2。
是这样的吗？
对平均搜索时间的解释是/2:在n个第一个整数的访问时间和为n(n+1)/2的情况下，大量随机访问数组的平均时间为(n (n+1)/2 )/n =(n+1)/2，在这种情况下，我认为Θ(n+1)/2将是平均访问时间。这(对我来说)很有意义，但由于我对渐近符号(以及一般的编程)还不熟悉，我想知道这是否是一种常见的做法。
我之所以问这个问题，是因为我很困惑地发现，在像http://bigocheatsheet.com这样的页面
浏览 0提问于2013-05-11得票数 1
回答已采纳
1回答
这个回文算法的时间和空间复杂度？
、、、、
有人能告诉我这个算法的时间和空间复杂度吗？基本上，函数接受一个字符串，如果它是回文(与向前相同)，则该函数必须返回true；如果不是，则返回false。
我认为这是O(n)，但如果我错了，请纠正我。
function isPalindrome(string) {
var reversing = string.split("").reverse().join("")
return string === reversing
}
浏览 1提问于2020-09-25得票数 0
我试图了解是否有任何替代蛮力算法(或轻微的改进/最坏的性能比幼稚的蛮力算法)仍然将导致O(N^2)的时间复杂性和O(1)辅助空间。
这是我的蛮力伪码：
procedure distinct(Input: array)
for i=0 to i < length of array
for j=i+1 to j < length of array
if array[i] ==
浏览 1提问于2016-03-07得票数 1
回答已采纳
有没有什么资源可以知道JavaScript中原生定义的数组和字符串方法的时间复杂度？当我使用它们来求解算法时，我必须进行猜测工作，但我想确定这些函数的时间复杂度是多少？
浏览 0提问于2019-01-30得票数 4
要求
目前，我们有一个包含一万多个关键字或句子的列表(数字是N)。
输入是长字符串，长度是L。
问:检查字符串中是否包含给定列表中的关键字或句子。
这个问题可以用上的word过滤器来描述，但是我在那个页面上没有找到任何算法。解决这个问题的最简单的方法是迭代所有的关键字或句子，每次检查长文本是否包含这样的子字符串。由于我们有很多关键词，同时考虑到长的文本，性能也很差。它使用O(NL)时间
似乎更好的解决方案应该在O(L)中完成。有人能给点建议吗？
浏览 4提问于2012-11-22得票数 2
回答已采纳
2回答
我需要找到f3在时间和空间上的复杂性。我认为g具有log(n)的空间复杂性，因此对于时间复杂性，我不太确定如何找到f3的时间和空间复杂性，因为对g的调用位于for推荐的内部，这是否意味着每次都会调用g来检查g(i) < n
int g(int n)
{
if (n <= 1)
return 1;
return g(n / 2) + 1;
}
int f3(int n)
{
int counter = 0;
for (int i = 0; g(i) < n; ++i)
++counter;
return
浏览 1提问于2020-08-15得票数 1
1回答
递归随机树结构的时空复杂度
、、、、
我试图找到一个很好的例子来理解递归映射随机树时的时间和空间复杂性(用Big符号表示)。
我找到了二叉树的例子，但我不确定这种情况是否适用于我的情况。
假设我们有一棵节点树。这些节点中的每一个都可以有随机数量的子节点。
ParentNode[ChildNode1.1[ChildNode2.1,ChildNode2.2], ChildNode1.2[ChildNode2.3]]
我的任务是将ParentNode复制到一个新的CopyNode中，并包含所有的子级。为此，我的职能是：
CopyNode = getChildNode(ParentNode)
Node getChildNode(Node
浏览 1提问于2020-11-27得票数 0
回答已采纳
2回答
BFS搜索最短路径的性能
、、、、
图中有一个最多可达、10000节点的，每个节点可以有最多4个相邻的节点。图为无权，无向，任务是查找从节点A到节点B的最短路径。路径长度是路径中访问的节点数。BFS算法能否在小于1秒的和使用小于64 of的内存中找到该路径？
最初的问题是网格(高达100*100)和可以访问的地方，开始的地方，结束的地方，和不能访问的地方。我的第一个猜测是将其简化为使用BFS搜索在未加权图中找到最短路径。但是，我不确定用大图解决方案的速度和内存使用情况。
浏览 4提问于2013-03-10得票数 1
回答已采纳
2回答
这段代码是从破解编码采访书中得到的。
public static boolean isUniqueChars2(String str) {
boolean[] char_set = new boolean[256];
for (int i = 0; i < str.length(); i++) {
int val = str.charAt(i);
if (char_set[val]) return false;
char_set[val] = true;
}
return true;
}
提交人提到，
时间
浏览 0提问于2013-02-20得票数 6
我对算法很陌生，我有一些问题。假设我有一个排序算法，在O(n^2)处排序数据，运行时间复杂度。例如，这可能是选择排序。现在，假设不是使用选择排序，而是使用了一个HashTable，它将运行时间减少到O(n)。
额外的空间复杂度对运行时间分析有影响吗？
在说明答案时如何定义这两者之间的关系？
还是完全不同？
任何帮助都将不胜感激。
浏览 1提问于2012-08-04得票数 1
回答已采纳
我的代码： import math
n=int(input('Enter the number'))
b=list(range(2,n+1))
for i in range(2,int(math.sqrt(n))+1):
for j in b:
if j!=i and j%i==0:
b[b.index(j)]=0
b={i for i in b if not i==0}
c={i for i in b if n%i==False}
print(b)
print(c) 这一次，我以自己的方式实现了筛子。为什么它不适用于数字为6
浏览 19提问于2020-08-28得票数 1
def count(substring, string):
"""
>>> count("bc","abcabcabc")
3
"""
counter = 0
for i in range(len(string) - len(substring) + 1):
counter += string.startswith(substring, i)
return counter 这是一个函数，用于计算基本字符串中的子字符串的重复
浏览 54提问于2019-01-31得票数 0
回答已采纳
2回答
假设我们从一个文本文件开始，比如：
a 00
b 01
c 10
d 11
00000001011011
该算法将是一个典型的算法，您使用前缀来构建霍夫曼树，在遍历树时读取编码的比特，直到到达叶子，然后返回该叶子处的字符。
有人能解释一下我如何确定运行时间和空间复杂度吗？
浏览 0提问于2013-12-02得票数 4
回答已采纳
我想知道在JavaScript中这种快速排序实现的时间和空间复杂性是什么。它有比理想的时间和空间复杂度更快的排序还是相同的？(理想的快速排序在最坏的情况下有TC O(n^2)和SC O(log n) )
function quickSort(arr)
{
if(arr.length == 1)
return arr
let pivot = arr[arr.length-1];
let left = [], right= [];
for(let i=0; i<arr.length-1; i++)
arr[i] &l
浏览 4提问于2022-10-26得票数 -2
回答已采纳
3回答
鉴于以下方法：
public String toString()
{
if (_head == null)
return "";
String S="";
WordNode currentNode = _head;
while (currentNode != null)
{
S+=currentNode.getWord()+" ";
currentNode = currentNode.getNext();
}
return S;
}
时间和空
浏览 1提问于2015-06-23得票数 1
回答已采纳
1回答
问题陈述：给出了一个非空字符串s和一个包含非空单词列表的字典wordDict，在s中添加空格以构造一个句子，其中每个单词都是一个有效的字典单词。返回所有这些可能的句子。
注意：
词典中的同一个词可以在分词中重复使用几次。你可以假设字典中不包含重复的单词。
示例测试用例：
Input:
s = "catsanddog"
wordDict = ["cat", "cats", "and", "sand", "dog"]
Output:
[
"cats and dog",
"ca
浏览 1提问于2020-05-23得票数 0
1回答
我正在阅读“破解编码访问”一书，并遇到了一个问题：“编写一个程序，按升序排列堆栈。您可以使用额外的堆栈来保存项，但不能将元素复制到任何其他数据结构中(例如数组)。堆栈支持以下操作: push、pop、peek、isEmpty。”
这本书用O(n^2)时间复杂度和O(n)空间给出了一个答案。
然而，我发现使用快速排序方法在O(n log n)时间复杂度中提供了一个答案。
我想知道的是空间复杂性O(n^2)？因为对该方法的每次调用都涉及初始化另外两个堆栈，以及另外两个递归调用。
我对太空的复杂性还有点动摇。我不确定这是否是O(n^2)空间，每个递归调用产生的新堆栈都小于一个级别上的堆栈。
如果有人
浏览 1提问于2014-02-24得票数 0
回答已采纳
有人能解释一下下面的旋转字符串代码片段的时间和空间复杂性吗？
举这个例子的书上说
复杂性分析
时间复杂度: O(N^2)，其中N是A的长度。
空间复杂度: O(N)，建筑A+A使用的空间。
但我不明白。有谁能解释一下吗？
示例1:输入:A= 'abcde'，B= 'cdeab‘输出: true
示例2:输入:A= 'abcde'，B= 'abced‘输出: false
public class RotateString {
public static void main(String[] args) {
System.out.printl
浏览 3提问于2018-12-03得票数 0
1回答
我想了解以下方法的空间复杂性。我自己尝试了最简单的方法。时间复杂度为O(n)。无法确定空间复杂度是O(1)还是O(n)，因为我在每次迭代中重新分配一个(字符串)。
public boolean anagram2(String a, String b) {
if (a.length() != b.length()) {
return false;
}
for (int i = 0; i < a.length(); i++) {
if (a.contains("" + b
浏览 0提问于2019-08-24得票数 2
1回答
在下面的例子中，SCNSphere的法线似乎随着摄像机的旋转而改变，这似乎不对，这表明我误解了一些基本的东西。
在场景中，放置圆柱体以突出x、y和z轴(分别为红色、绿色和蓝色)和单位半径的球体以及以下定制的片段着色器修饰符：
_output.color.rgb = _surface.normal;
位于(0, 0, 10)位置的照相机(即沿z轴)呈现如下内容：
这看上去是对的，因为在x、y和z轴上向外突出的法线分别是红色、绿色和蓝色，并且在整个过程中都有预期的梯度。但是，如果我们将摄像机旋转以定位(10, 0, 0) (即沿x轴)，这就是呈现的场景：
这意味着法线已经发生了
浏览 11提问于2021-04-06得票数 0
回答已采纳
1回答
我的算法如下所示。它对服务器进行远程调用，并获取结果、处理结果，然后再次将远程调用发送到系统。你能告诉我这个算法的时间和空间复杂度是多少吗？
Get search keyword from user
ϕ := getInfoFromConceptNet(keyword) // makes remote call
e := expandConcepts(ϕ)
expConcepts := {} // adds to an array
for each ec in e // first loop
expConcepts.add(ec) // adds to array
α= expandConce
浏览 0提问于2012-08-18得票数 1
回答已采纳
3回答
给定两个大小为m的整数A和B的数组，取值范围为-n，n。我想要一个算法来计算A和B中有多少个公共值，如果一个值重复一次，例如: A={2,2,14,3}和B={1,2,14,14,5}，算法应该返回2。问题是我需要在O(m)时间内完成这个任务。
我的尝试是创建一个大小为2n的C数组。并将A和B的所有值加n，并计算A的值: C[Ai]=1，需要O(m)时间，O(1)时间来创建数组。然后回顾B，数一数我在C中遇到了多少个1。
到目前为止，这听起来不错，但是我一开始就不知道C中有什么，而且可能已经有一个1，这会错误地增加计数器，初始化C需要O(n)时间。
有什么想法吗？先谢了。
编辑:我得到
浏览 0提问于2019-08-25得票数 0
3回答
在以下两个案例中，我对时间和空间复杂性有疑问。
区块报价
案例I:
递推:阶乘计算。
int fact(int n)
{
if(n==0)
return 1;
else
return (n*fact(n-1));
}
这里为什么时间复杂度变成2*n，空间复杂度与n成正比。
和
Case II:
迭代：-
int fact(int n)
{
int i, result = 1;
if(n==0)
result = 1;
else
{
for(1=1;i<=n;i++)
浏览 5提问于2012-05-21得票数 0
回答已采纳
1回答
当涉及到计算理论时，我是一个全新的人，我被要求描述python函数的计算成本(作为n的函数)是多少。我对如何做到这一点有点困惑。
我是否要插入不同的输入，然后计算算法运行时间之间的差异？如果我这么做了，我怎么把它描述成n的函数呢？
很抱歉，如果这是一个非常初级的问题，我对这个主题非常陌生，我希望得到一些进一步的解释，以及如何使用python将其应用于实际函数的一些指导。
浏览 2提问于2020-12-20得票数 0
1回答
class Solution {
public static int countBinarySubstrings(String s) {
int res = 0;
for(int i = 0; i < s.length()-1; i++) {
if(s.charAt(i) != s.charAt(i+1))
res += countValid(s, i, i+1);
}
return res;
}
public static int
浏览 10提问于2021-09-02得票数 1
我正在看下面的解决方案
function SubstringsKDistinct(str, k) {
let start = 0;
let end = 0;
let result = [];
let len = str.length;
while (start < len && end < len) {
while (end <= len) {
if (str.slice(start, end).length > 1) {
l
浏览 8提问于2022-08-19得票数 0
在“破解编码面试”一书中，第一个练习说“实现一个算法来确定一个字符串是否都具有唯一的字符(不使用额外的数据结构)”。解决方案是： public static boolean isUniqueChars(String str) {
boolean [] char_set = new boolean[256];
for (int i = 0; i < str.length(); i++) {
int val = str.charAt(i);
if (char_set[val]) return false;
char_set[v
浏览 8提问于2020-07-05得票数 1
回答已采纳
/*
Returns true is the two strings are permutations of each other.
Time Complexity; O(nlog n) -> because of the java utils array sort
Space Complexity; O(1)
*/
public boolean isPermutationOptimized(String one, String two) {
if (one.length() != two.length()) {
return
浏览 17提问于2021-10-05得票数 0
回答已采纳
2回答
我需要计算这个问题的时间和空间复杂度，有人能帮我弄清楚这是什么吗?为什么？ 我相信这个问题的时间复杂度是O(n^2)，因为有2个过滤函数。本质上，这类似于有两个for循环在数组上迭代，因为它们循环了一段时间，我们知道第一个过滤器将是O(n)，添加另一个过滤器将使其为O(n^2)？ 不确定空间的复杂性。 let arr = [1, 2, 2, 4, 4, 5, 6, 7, 7, 8, 9];
const result = arr.filter(x => arr.filter(y => y === x).length > 1)
console.log(result);
// 2
浏览 13提问于2019-03-14得票数 1
回答已采纳
我被要求解决以下低于N^2时间复杂度和O(N)空间复杂度的问题：
为下列情况编写反向字符串的程序：
输入：- "Hello“输出：-”olleH dlroW“
我已经试过很多次了，但是无论我尝试什么，我都不能想出一个比N^2更低的时间复杂度，我的代码可以在下面看到，你有什么建议，我怎么能想出一个线性时间的解呢？
注意:不允许使用内置方法。
public static String stringReverser(String str) {
if (str == null || str.isEmpty()) {
throw new IllegalA
浏览 8提问于2016-02-21得票数 3
1回答
下面是我在Java中编写的两个镜像树的方法，它们都可以正常工作。我刚刚学习了时间复杂性，我想知道哪种方法在时间复杂性和空间复杂性方面效果更好。第一个方法是我自己做的，第二个方法是我的老师给我的。这两种方法不同的主要原因是，在第一种方法中，不会创建新的树，而在第二种方法中会创建一棵新树。提前感谢！
//way 1
public static TreeNode mirrorImage (TreeNode t) {
if (t == null)
return null;
TreeNode right = t.getRight();
TreeNode lef
浏览 6提问于2018-01-06得票数 0
1回答
均匀代价搜索及其时空复杂性
、、、、
作为编程任务的一部分，我用Python3编写了一个函数ucs(G,v)，它搜索具有加权边的有向图G。随机选取G中的三个节点作为目标节点，该函数的任务是应用均匀代价搜索(即最便宜的第一次搜索)从给定的节点v到目标节点中的一个寻找最便宜的路径。
我有两个问题：
实施是否正确？我怀疑，当同一节点的多条路径被推入优先级队列时，将进行冗余检查。
我怎样才能确定时间和空间的复杂性？
我感谢任何建议，特别是关于第二个问题的建议。我在网上任何地方都找不到UCS的复杂性。
以下是我的实现：
def ucs(G, v):
visited = set() #
浏览 0提问于2017-05-23得票数 2
回答已采纳
1回答
我有下面的代码，我试图得到时间复杂度。
seen = set()
a=[4,4,4,3,3,2,1,1,1,5,5]
result = []
for item in a:
if item not in seen:
seen.add(item)
result.append(item)
print (result)
据我所知，当我访问列表时，该操作的时间复杂度将是O(n)。与if块一样，每次我查找集合时，都会花费另一个O(n)。那么，总体时间复杂度是O(n^2)吗？set.add()是否也增加了复杂性？
另外，由于空间的复杂性，它是O(n)吗？因为集合的大小
浏览 18提问于2017-03-10得票数 2
回答已采纳
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM
腾讯云开发者
