1 单链表

`node_1 -> node_2 -> node_3 -> node_4`

``` class Node:
def __init__(self, val=None, nxt=None):
self.value = val
self.next = nxt

def __str__(self):
return str(self.value)

"""
node_1 -> node_2 -> node_3 -> node_4
"""
def __init__(self, iterable=()):
if iterable:
self.init(iterable)

def __str__(self):
def _traversal(self):
while node and node.next:
yield node
node = node.next
yield node
return '->'.join(map(lambda x: str(x), _traversal(self)))

def init(self, iterable=()):
# Note: use empty tuple rather than list to init iterable
if not iterable:
return
for i in iterable[1:]:              # add all node
node.next = Node(i)
node = node.next

def show(self):
print(self)

@property
def length(self):
return 0
i = 1
while node.next:
node = node.next    # node pointer move to next
i += 1
return i

@property
def is_empty(self):

def clear(self):
self.__init__()

def append(self, item):
self.insert(item, self.length)

def find(self, item):
while node.next and node.value != item:
node = node.next
if node.value == item:
return node
return None

def find_previous(self, item):
while node.next and node.next.value != item:
node = node.next
if node.next and node.next.value == item:
return node
return None

def delete(self, item):
'''
node_1 -- X --> node_2 -----> node_3
\                    /
\                  /
------------------
'''
prev = self.find_previous(item)
if prev:
prev.next = prev.next.next

def insert(self, item, index):
'''
----> node_2 ---
/                \
/                  \
node_1 -------  X  ---------> node_3

'''
if abs(index) > self.length:
return
if index < 0:
self.insert(item, self.length+index+1)
return
elif index == 0:
return
i = 0
while i < index-1:
node = node.next
i += 1
n = node.next
node.next = Node(item, n)

def test(li):
li.show()

li.init([1, 2, 3, 4, 5, 6, 'xd', 8, 9])
li.show()

print('\nInsert element:')
li.insert('xxd', -3)
li.show()

print('\nAppend element:')
li.append('')
li.show()

e = 'xd'
print('\nFind element:')
x = li.find(e)
print(x.value if x else x)
print('\nFind previous element:')
x = li.find_previous(e)
print(x.value if x else x)

print('\nDelete element:')
li.delete('xd')
li.show()

print('\nFind element not exist:')
x = li.find(e)
print(x.value if x else x)

li.insert('cc', 0)
li.show()

li.clear()
li.show()

print('\nCurrent length: %s' % li.length)
print('\nIs empty: %s' % li.is_empty)

if __name__ == '__main__':

``` class Node:
def __init__(self, val=None, nxt=None):
self.value = val
self.next = nxt

def __str__(self):
return str(self.value)```

``` class LinkedList:
"""
node_1 -> node_2 -> node_3 -> node_4
"""
def __init__(self, iterable=()):
if iterable:
self.init(iterable)```

```     def __str__(self):
def _traversal(self):
while node and node.next:
yield node
node = node.next
yield node
return '->'.join(map(lambda x: str(x), _traversal(self)))```

```     def init(self, iterable=()):
# Note: use empty tuple rather than list to init iterable
if not iterable:
return
for i in iterable[1:]:              # add all node
node.next = Node(i)
node = node.next```

```     def show(self):
print(self)```

```     @property
def length(self):
return 0
i = 1
while node.next:
node = node.next    # node pointer move to next
i += 1
return i```

```     @property
def is_empty(self):

```     def clear(self):
self.__init__()

```     def append(self, item):
self.insert(item, self.length)```

1. 查找是依据元素的值进行查找，返回找到的第一个结点；
2. 这里的查找方法如果遇到有环链表将无法自行检测退出

```     def find(self, item):
while node.next and node.value != item:
node = node.next
if node.value == item:
return node
return None```

find_previous与find类似，返回查找结点的前一个结点。

```     def find_previous(self, item):
while node.next and node.next.value != item:
node = node.next
if node.next and node.next.value == item:
return node
return None```

delete方法用于删除结点，基本思路在于，找到需要删除结点node_2的前一个结点node_1，将前一个结点node_1的next指针指向删除结点的下一个结点node_3，从而惰性删除了这个结点。

```     def delete(self, item):
'''
node_1 -- X --> node_2 -----> node_3
\                    /
\                  /
------------------
'''
prev = self.find_previous(item)
if prev:
prev.next = prev.next.next```

insert方法用于向链表中插入一个结点，

```     def insert(self, item, index):
'''
----> node_2 ---
/                \
/                  \
node_1 -------  X  ---------> node_3

'''
if abs(index) > self.length:
return
if index < 0:
self.insert(item, self.length+index+1)
return
elif index == 0:
return
i = 0
while i < index-1:
node = node.next
i += 1
n = node.next
node.next = Node(item, n)```

``` def test(li):
li.show()```

```Show linked list:
None```

```     print('\nInit linked list:')
li.init([1, 2, 3, 4, 5, 6, 'xd', 8, 9])
li.show()```

```Init linked list:
1->2->3->4->5->6->xd->8->9```

```     print('\nInsert element:')
li.insert('xxd', -3)
li.show()```

```Insert element:
1->2->3->4->5->6->xd->xxd->8->9```

```     print('\nAppend element:')
li.append('')
li.show()```

```Append element:
1->2->3->4->5->6->xd->xxd->8->9->10```

```     e = 'xd'
print('\nFind element:')
x = li.find(e)
print(x.value if x else x)
print('\nFind previous element:')
x = li.find_previous(e)
print(x.value if x else x)```

```Find element:
xd

Find previous element:
6```

```     print('\nDelete element:')
li.delete('xd')
li.show()```

```Delete element:
1->2->3->4->5->6->xxd->8->9->10```

```     print('\nFind element not exist:')
x = li.find(e)
print(x.value if x else x)```

```Find element not exist:
None```

```     print('\nInsert element to header:')
li.insert('cc', 0)
li.show()```

```Insert element to header:
cc->1->2->3->4->5->6->xxd->8->9->10```

```     print('\nClear linked list:')
li.clear()
li.show()

print('\nCurrent length: %s' % li.length)
print('\nIs empty: %s' % li.is_empty)```

```Clear linked list:
None

Current length: 0

Is empty: True```

2 带表头单链表

```Linked list with dummy header node:
Header -> node_1 -> node_2 -> node_3```

``` from linked_list import Node, LinkedList, test

"""
Header -> node_1 -> node_2 -> node_3
"""
def __init__(self, iterable=()):
if iterable:
self.init(iterable)

def init(self, iterable=()):
if not iterable:
return
for i in iterable:
node.next = Node(i)
node = node.next

@property
def is_empty(self):
# if self.length == 1:
#     return True
# return False

def insert(self, item, index):
if index == 0:
return

if __name__ == '__main__':

__init__方法：

init方法：

is_empty方法：

insert方法：

```Show linked list:

Insert element:

Append element:

Find element:
xd

Find previous element:
6

Delete element:

Find element not exist:
None

Current length: 1

Is empty: True```

## Python与数据结构[0] -> 链表/LinkedList[0] -> 单链表与带表头单链表的 Python 实现的更多相关文章

1. Python与数据结构[1] -&gt; 栈/Stack[0] -&gt; 链表栈与数组栈的 Python 实现

栈 / Stack 目录 链表栈 数组栈 栈是一种基本的线性数据结构(先入后出FILO),在 C 语言中有链表和数组两种实现方式,下面用 Python 对这两种栈进行实现. 1 链表栈 链表栈是以单链 ...

2. Python与数据结构[2] -&gt; 队列/Queue[0] -&gt; 数组队列的 Python 实现

队列 / Queue 数组队列 数组队列是队列基于数组的一种实现,其实现类似于数组栈,是一种FIFO的线性数据结构. Queue: <--| 1 | 2 | 3 | 4 | 5 |<-- ...

3. [H5表单]html5自带表单验证体验优化及提示气泡修改

慕课网之前录制的视频,js/jquery各种宽高的理解和应用,最近终于上线了.还有一个html5左侧导航没有上线!最近慕课网系列课程让我录制一个html5表单验证的课程.今天就稍微说一下表单验证!另外 ...

4. Python与数据结构[4] -&gt; 散列表[0] -&gt; 散列表与散列函数的 Python 实现

散列表 / Hash Table 散列表与散列函数 散列表是一种将关键字映射到特定数组位置的一种数据结构,而将关键字映射到0至TableSize-1过程的函数,即为散列函数. Hash Table: ...

5. Python与数据结构[3] -&gt; 树/Tree[0] -&gt; 二叉树及遍历二叉树的 Python 实现

二叉树 / Binary Tree 二叉树是树结构的一种,但二叉树的每一个节点都最多只能有两个子节点. Binary Tree: 00 |_____ | | 00 00 |__ |__ | | | | ...

6. Python与数据结构[4] -&gt; 散列表[2] -&gt; 开放定址法与再散列的 Python 实现

开放定址散列法和再散列 目录 开放定址法 再散列 代码实现 1 开放定址散列法 前面利用分离链接法解决了散列表插入冲突的问题,而除了分离链接法外,还可以使用开放定址法来解决散列表的冲突问题. 开放定 ...

7. Python与数据结构[4] -&gt; 散列表[1] -&gt; 分离链接法的 Python 实现

分离链接法 / Separate Chain Hashing 前面完成了一个基本散列表的实现,但是还存在一个问题,当散列表插入元素冲突时,散列表将返回异常,这一问题的解决方式之一为使用链表进行元素的存 ...

8. Python与数据结构[0] -&gt; 链表/LinkedList[1] -&gt; 双链表与循环双链表的 Python 实现

双链表 / Doubly Linked List 目录 双链表 循环双链表 1 双链表 双链表和单链表的不同之处在于,双链表需要多增加一个域(C语言),即在Python中需要多增加一个属性,用于存储指 ...

9. Python与数据结构[0] -&gt; 链表/LinkedList[2] -&gt; 链表有环与链表相交判断的 Python 实现

链表有环与链表相交判断的 Python 实现 目录 有环链表 相交链表 1 有环链表 判断链表是否有环可以参考链接, 有环链表主要包括以下几个问题(C语言描述): 判断环是否存在: 可以使用追赶方法, ...

## 随机推荐

1. php学习笔记

2. Software Project Management hw1

I just want to say something about my java project that I did last year. Our task is to finish a lin ...

3. redhat6.4上build storm 0.9.0.1

1.安装mvn 2.下载源代码 3.build mvn package 过程中出现问题,clojars.org 访问不了.通过私服映射clojars.org并在pom.xml中将dependency的 ...

4. 【HDOJ】1258 Sum It Up

典型的深搜,剪枝的时候需要跳过曾经搜索过的相同的数目,既满足nums[i]=nums[i-1]&&visit[i-1]==0,visit[i-1]==0可以说明该点已经测试过. #in ...

5. 安装.Net Standard 2.0, Impressive

此版本的.NET Standard现在支持大约33K的API,与.NET Standard 1.x支持的14K API相比.好的是大部分API来自.NET Framework.这使得生活更容易将代码移 ...

6. Django框架----中间件

我们已经会了给视图函数加装饰器来判断是用户是否登录,把没有登录的用户请求跳转到登录页面.我们通过给几个特定视图函数加装饰器实现了这个需求.但是以后添加的视图函数可能也需要加上装饰器,这样是不是稍微有点 ...

7. 强化学习策略梯度方法之: REINFORCE 算法（从原理到代码实现）

强化学习策略梯度方法之: REINFORCE 算法 (从原理到代码实现) 2018-04-01  15:15:42   最近在看policy gradient algorithm, 其中一种比较经典的 ...

8. 浅析JSONP

什么是JSONP? JSONP是JSON with Padding的略称.它是一个非官方的协议,它允许在服务器端集成Script tags返回至客户端,通过javascript callback的形式 ...

9. 《软件工程和Python》PYTHON效能分析和Django

资料汇总网站:http://www.yzhiliao.com/my/course/55 一..作业下面两个题目任选一题: (1)运用jieba库分词(或者你喜欢的其他库),并把代码发到git上去(不发 ...

10. JDK1.7新特性(3):java语言动态性之脚本语言API

简要描述:其实在jdk1.6中就引入了支持脚本语言的API.这使得java能够很轻松的调用其他脚本语言.具体API的使用参考下面的代码: package com.rampage.jdk7.chapte ...