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
具有合並和分割的功能