1. list和linkedlist的区别 python
list就是一个静态数组。
LinkedList 是基于链表实现的，所以它的插入和删除快，查询和修改慢。
2. 为 LinkedList 添加类似 Python 自带列表实现 list 中的 append, pop, insert 方法
写了个insert
definsert(self,index,item):
previous=None
current=self.head
count=0
temp=Node(item)
ifindex>self.size():
print"outindex"
elifindex==0:
temp.setNext(current)
self.head=temp
else:
whileindex:
index-=1
previous=current
current=current.getNext()
previous.setNext(temp)
temp.setNext(current)
3. python编程中实现linkedlist(链表）报错是因为什么，怎么解决
楼主你好！
看你的代码存在很多问题，一个个来说明
1）首先你代码的报错源于你想用list来展开你的SLinkedList类，在python中，除非内置的可迭代对象外，其他都需要实现__iter__()函数，才能用list来进行展开。注意：判断一个对象是否可迭代，请使用isinstance(obj, Iterable)来判断obj是不是可以迭代，Iterable需要从collections中导入
2）插入的方法存在严重问题，按楼主的方法插入的话，因为头节点始终在变，所以当你需要遍历链表的时候就会找不到头节点；
3）pop的方法实现也有问题，因为是单向链，所以无法从末节点开始删除，只能删除头节点
4）top方法的意图未知
其他：
下面列举了一下我修改后的方案，做了一些锦上添花的操作，每个基本操作都会返回链表对象，这样就可以使用链式操作来写代码；迭代函数使用yield来实现，避免展开时占用不必要的内存。
另：我的展开时直接取链表中各个节点的元素，加了一些关键注释在代码中；
#-*-coding:utf-8-*-
classNode:
def__init__(self):
'''
elm:节点元素
nxt:下个节点指针
'''
self.elm,self.nxt=None,None
classSLinkedList:
def__init__(self):
'''
head:链表头
end_point:链表尾
'''
self.head=None
self.end_point=None
defpush(self,x):
p=Node()
p.elm=x
ifself.headisNone:
self.head=p
self.end_point=p
returnself
self.end_point.nxt=p
self.end_point=p
returnself
defpop(self):
'''因为实现的是一个单链表，所以只能从头开始删除节点'''
ifself.head.nxtisNone:
return
self.head=self.head.nxt
returnself
def__iter__(self):
temp_node=self.head
whiletemp_nodeisnotNone:
yieldtemp_node.elm
temp_node=temp_node.nxt
if__name__=='__main__':
'''增加1,2,5三个元素，并删除一个头节点'''
mylinklist=SLinkedList().push(1).push(2).push(5).pop()
print(list(mylinklist))
其实python这个语言使用链表有些画蛇添足，但是如果拿来当作需求练手也无妨。
望采纳，谢谢！
4. Python中如何实现基本的数据结构
要学的，python只是继承了list,dict,set等常用的数据结构。一般情况只要将几种内置对象组合就可以。如果你要实现复杂的数据结构还是要自己实现。
5. python五维的list怎么表示
List是一个接口，不能实例化，需要实例化一个ArrayList或者LinkedList
List al = new ArrayList();
//使用add（）方法添加元素
al.add("a");
al.add("b");
al.add("c");
al.add("d");
//使用Iterator迭代器遍历出集合的元素并打印
for(Iterator i = al.iterator();i.hasNext(); ){
String str = (String) i.next();
System.out.println(str);
}
6. 用Python实现合并两个排序的列表，但一直报错，请问怎么修改啊
你所定义的listnodeclass和python自带的listtype是不同的东西，不能通用，必须先转换
其他小错我直接帮你改掉了
下面是改好可以运行的代码：
classListNode(object):
def__init__(self,val):
self.val=val
self.next=None
def__repr__(self):
returnstr(self.val)
defLinkedList(pythonlist):
l=ListNode(pythonlist[0])
c=l
foriinrange(1,len(pythonlist)):
l.next=ListNode(pythonlist[i])
l=l.next
returnc
defPythonList(ListNode):
l=[]
whileListNode!=None:
l.append(ListNode.val)
ListNode=ListNode.next
returnl
classSolution(object):
defmergeTwoLists(self,l1,l2):
ifl1isNone:
returnl2
ifl2isNone:
returnl1
mmyhead=ListNode(0)
mmyhead.next=None
p=mmyhead
:
ifl1.val<l2.val:
p.next=l1
l1=l1.next
else:
p.next=l2
l2=l2.next
p=p.next
ifl1isnotNone:
p.next=l1
else:
p.next=l2
returnmmyhead.next
l1=LinkedList([1,3,5,7])
l2=LinkedList([2,4,6,8])
sol=Solution()
print(PythonList(sol.mergeTwoLists(l1,l2)))
（LinkedList(pythonlist)方法把一个传统的pythonlist转换成你用的首位相衔的listnode形式，PythonList(ListNode)则是转换回来）
同时，linkedlist的数据类型在c里面比较常用，python里面一般用不着这么麻烦
希望对你有帮助
7. python的双向链表
这里有一个：
https://github.com/rgsoda/pypy-llist/
8. python可以编写自己的链表类吗
你如果一定要模拟C建立树形结构的方式，可以不必特意制定left和right的类型，仅在需要的时候给其赋上LinkedList的类型就行了。
如：
>>> class LinkedList():
def __init__(self,default_value=""):
self.left=0 #比如0表示left节点为空
self.right=0
self.value=default_value
return
>>> root = LinkedList()
>>> left = LinkedList()
>>> right = LinkedList()
>>> root.left = left
>>> root.right = right
>>> root.left
<__main__.LinkedList object at 0x00F964B0>
你自己写的那个class有不少错误，比如value,left,right这样写，属于类值，类似C++中的静态值，是所有LinkedList类和类实例共享的，你的__init__缺少self。
9. python 单向链表问题
不会。
实际上，SingleLinkedList只存储了链表的表头节点的位置。
每次调用add函数，相当于新建了一个节点，
调用setNext将其下一节点指向现在链表的表头，
然后将新建的节点位置作为新的表头位置保存在链表里面。
要得到链表的所有节点必须从表头节点开始一个一个往下跳转，一直跳转到下一节点位置为None，则表示查询完毕。
10. python 算法 时间合并问题
和伪代码的上贴一致，只是由“新日期为准”，改成“新输入为准”，更符合原命题。
感觉这题涉及混流或矢量加减的技巧。这种技巧也是我该练习的。
java 8代码，不够纯，但新特点基本用到了。
importjava.io.FileInputStream;
importjava.nio.CharBuffer;
importjava.nio.channels.FileChannel;
importjava.nio.channels.FileChannel.MapMode;
importjava.nio.charset.Charset;
importjava.time.LocalDate;
importjava.util.LinkedList;
importjava.util.List;
importjava.util.Map;
importjava.util.regex.Matcher;
importjava.util.regex.Pattern;
importjava.util.stream.Collectors;
importjava.util.stream.Stream;
publicclassTest{
{
publicLocalDatestart,end;
publicintprice;
@OverridepublicRecordclone(){
try{return(Record)super.clone();
}catch(CloneNotSupportedExceptione){
e.printStackTrace();returnnull;
}
}
publicStringtoString(){
returnstart.toString()+"~"+end.toString()+":"+price;
}
}
publicstaticvoidmain(String[]args)throwsException{
FileChannelfc=newFileInputStream("data.txt").getChannel();
CharBufferbuf=Charset.forName("GBK").decode(fc.map(MapMode.READ_ONLY,0,fc.size()));
Matcherm=Pattern.compile("(\d+-\d+-\d+)~(\d+-\d+-\d+)\s+(\d+)").matcher(buf);
List<Record>list=newLinkedList<Record>();
//Stream<Record>s=Stream.empty();
while(m.find()){
System.out.println(m.group());
Recordrec=newRecord();
rec.start=LocalDate.parse(m.group(1));
rec.end=LocalDate.parse(m.group(2));
rec.price=Integer.parseUnsignedInt(m.group(3));
if(list.size()==0)list.add(rec);
else{
Map<Integer,List<Record>>map=list.parallelStream().collect(Collectors.groupingBy(
(e)->{
intss=rec.start.compareTo(e.start),se=rec.start.compareTo(e.end),
es=rec.end.compareTo(e.start),ee=rec.end.compareTo(e.end);
returnnewInteger(
(ss<=0&&es>=0&&ee<0)?1://1只往尾部缩小e的情况
(ss>0&&se<0&&ee<0)?2://2分割e为首、尾两份的情况
(ss>0&&se<0&&ee>=0)?3://3往首部缩小e的情况
0//互不影响的情况
);
}
));
//System.out.println("map:"+map);
List<Record>type_tail=map.get(1),type_middle=map.get(2),
type_head=map.get(3),type_rest=map.get(0);
if(type_tail!=null&&type_middle!=null&&type_head!=null&&
type_tail.isEmpty()&&type_middle.isEmpty()&&
type_head.isEmpty())list.add(rec);
else{
list=type_tail==null?newLinkedList<>():
type_tail.parallelStream().map((e)->{
if(rec.price==e.price){
rec.end=e.end;//价格相等时，rec取代e
returnnull;
}
e.start=rec.end;
returne;}).filter(e->e!=null).collect(Collectors.toList());
if(type_middle!=null)list.addAll(type_middle.parallelStream().flatMap((Recorde)->{
if(rec.price==e.price){
rec.start=e.start;
rec.end=e.end;//价格相等时，rec取代e
returnnull;
}
Recordh=e.clone();
h.end=rec.start;e.start=rec.end;
returnStream.of(h,e);
}).filter(e->e!=null).collect(Collectors.toList()));
if(type_head!=null)list.addAll(
type_head.parallelStream().map((e)->{
if(rec.price==e.price){
rec.start=e.start;//价格相等时，rec取代e
returnnull;
}
e.end=rec.start;returne;
}).filter(e->e!=null).collect(Collectors.toList()));
if(type_rest!=null)list.addAll(type_rest);
list.add(rec);
}
//System.out.println("list:"+list);
}
}
System.out.println("按后输入数据覆盖：");
list.stream().sorted((a,b)->{
ints=a.start.compareTo(b.start);
returns==0?a.end.compareTo(b.end):s;
}).forEachOrdered((r)->System.out.println(r));
}
}
2013-08-01~2013-08-31300
2013-08-25~2013-09-30300
2014-08-01~2014-12-31300
2014-10-01~2014-10-07500
按后输入数据覆盖：
2013-08-01~2013-09-30:300
2014-08-01~2014-10-01:300
2014-10-01~2014-10-07:500
2014-10-07~2014-12-31:300
具有合并和分割的功能