• bat面试题 python 单链表反转排序

单链表反转python实现

单链表的反转可以使用循环，也可以使用递归的方式

1.循环反转单链表

循环的方法中，使用pre指向前一个结点，cur指向当前结点，每次把cur->next指向pre即可。

代码：

[python] view
plain copy

class ListNode:
def __init__(self,x):
self.val=x;
self.next=None;

pre=None
while cur:
h=cur
tmp=cur.next
cur.next=pre
pre=cur
cur=tmp
return h

#测试代码
p1=ListNode(2)
#建立链表1->2->3->4->None;
p2=ListNode(3)

p3=ListNode(4)

p1.next=p2
p2.next=p3
while p:
print(p.val)
p=p.next

2.递归实现单链表反转

[python] view
plain copy

class ListNode:
def __init__(self,x):
self.val=x;
self.next=None;

return ;
else :

p1=ListNode(2);                 # 建立链表1->2->3->4->None
p2=ListNode(3);
p3=ListNode(4);
p1.next=p2;
p2.next=p3;
while p:
print p.val;
p=p.next;
单链表排序

class listNode:
def __init__(self,x):
self.val = x
self.next  = None
def createList(self,a):
if a is None:
print('no elements')
return
i=1
n=len(a)
while i<n:
t=listNode(a[i])
p.next=t
p=t
i=i+1
print("no elements")
return
else:
while it is not None:
if it.val > mid:
rit.next = it
rit = it
else:
lit.next = it
lit = it
it = it.next
lit.next, rit.next = None, None
while it.next is not None:
it = it.next

l=listNode(0)
a=[2,5,9,3,6,1,0,7,4,19]
print('sorted list:')


展开全文
def reverseList(head):
while current_node is not None:
next_node = current_node.next  # 暂存当前节点的next节点
current_node.next = pre_node   # 当前节点的next指向初始化的节点
pre_node = current_node        # 初始化的节点为当前节点
current_node = next_node       # 当前节点为暂存的节点
return pre_node



展开全文
• class Link: def __init__(self): self.n = 0 self.fist_node = Node() super(Link, self).__init__() def isEmply(self): return self.n == 0 def clear(self): self.n = 0 self.fist_node = Node() ...
class Link:

def __init__(self):
self.n = 0
self.fist_node = Node()

def isEmply(self):
return self.n == 0

def clear(self):
self.n = 0
self.fist_node = Node()

item = self.fist_node
self.n += 1

if i > self.n:
return -1
temp = self.fist_node
for x in range(1, self.n + 1):
if x == i:
break

def get(self, i):
if self.n == 0:
return -1
for x in range(1, self.n + 1):
if x == i:
break
return temp.value

def delete(self, i):
if i > self.n or i <= 0:
return -1
temp = self.fist_node
for x in range(1, self.n + 1):
if x == i:
break
self.n -= 1

def reverse(self):

def node_reverse(self, node):
return node

else:
return node

class Node:
self._pre = pre
self._value = value

@property
def pre(self):
return self._pre

@pre.setter

@property

@property
def value(self):
return self._value

@value.setter
def value(self, value):
self._value = value

if __name__ == '__main__':

node = Node(value='11')
node1 = Node(value='12')
node2 = Node(value='13')
node3 = Node(value='13')




展开全文
• 单链表反转python实现，简洁详细易于理解，附带注释易于分析
• python实现单链表反转（经典笔试题）

万次阅读 多人点赞 2018-07-16 22:40:18
0、说在前面的话  链表结构，说难不难，说易不易，一定要亲自编程实现一下。其次就是一定要耐心，慢慢... 建立三个变量，L、M、R互相赋值迭代，并建立指向关系，从而实现单链表反转。 3、python代码实现 cla...
0、说在前面的话

链表结构，说难不难，说易不易，一定要亲自编程实现一下。其次就是一定要耐心，慢慢去体会其中的道道，博主一开始也是有点懵逼的，后来仔细琢磨了一下终于搞明白了，相信聪明的你也一定可以，有问题可以留言交流。

1、单链表结构

2、反转的想法

建立三个变量，L、M、R互相赋值迭代，并建立指向关系，从而实现单链表的反转。

3、python代码实现

class Node(object):
def __init__(self, data, next=None):
self.val = data
self.next = next

return None
while R.next != None:
L = M
M = R
R = R.next
M.next = L
R.next = M
return R
#测试用例
if __name__ == '__main__':
l1 = Node(3)
l1.next = Node(2)
l1.next.next = Node(1)
l1.next.next.next = Node(9)
l = fun4(l1)
print (l.val, l.next.val, l.next.next.val, l.next.next.next.val)


展开全文
• 主要介绍了单链表反转python实现，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
• 三个指针实现单链表反序输出 class Node(object): def __init__(self, item, next=None): self.val = item self.next = next #三个指针遍历反转 def reverse(head): #p、q指针指定先后两个节点 if head == ...
• 反转1_头插4. 反转2 1. 链表节点类 class LinkListNode(object): def __init__(self, val, next=None): self.val = val self.next = next 2. 创建链表(附赠) def CreateLinkList(l): """ l: list, 节点值...
• 链表是一种基础的数据结构，也是算法学习的重中之重。其中单链表反转是一个经常会被考察到的知识点。...现在来给大家简单介绍一下单链表反转算法实现的基本原理和python代码实现。 算法基本原理及python...
• 单链表反转python实现

千次阅读 2016-08-28 19:16:00
单链表反转可以使用循环，也可以使用递归的方式 1.循环反转单链表 循环的方法中，使用pre指向前一个结点，cur指向当前结点，每次把cur->next指向pre即可。   代码： [python] view
• 单链表反转，可以使用 循环、递归 两种方式 循环方式 class ListNode: def __init__(self, x): self.val = x self.next = None def non_recurse(head): if head is None or head.next is None: return ...
• 单链表反转 | 不合法的路径地址转变为...1. python单链表反转 单链表结构 单链表反转问题就不细说，网上能找到很多。使用三个变量L、M、R互相赋值迭代，并建立指向关系，从而实现单链表的反转。直接上代码 cl...
• 单链表反转_python版

万次阅读 多人点赞 2019-03-21 13:01:10
反转单链表反转过程如下： 第一步：next = head.next 将 head.next 赋值给 next 变量，即next 指向了节点2，先将节点2 保存起来。 第二步：head.next = pre （初始pre==None） 将 pre 变量赋值给 ...
• 最近一直在学数据结构的知识，今天接触到了链表，通过Python实现了单链表，双向链表以及单向循环链表。采用面向对象的思想，对其进行封装成一个类，就类似list的一样，具有一些简单的操作函数，如：append、insert...
• 单链表反转

2019-02-28 23:19:00
• 单链表反转 单链表反转这道题可谓是链表里面的高频问题了，差不多可以说只要被问到链表，就会问单链表反转。 今天我们就一起来看下。 题目链接： https://leetcode-cn.com/problems/reverse-linked-list/ 题目描述：...
• 链表是一种基础的数据结构，也是算法学习的重中之重。其中单链表反转是一个经常会被考察到的知识点。...现在来给大家简单介绍一下单链表反转算法实现的基本原理和python代码实现。  算法基本原理及python代码 1...

...

python 订阅