数据结构练习 单链表实现反转

 1 #!/usr/bin/env python3
 2
 3 class LNode(object):
 4         def __init__(self, elem, next_=None):
 5                 self.elem = elem
 6                 self.next = next_
 7
 8 class ListError(ValueError):
 9         pass
10
11 class LList(object):
12         def __init__(self):
13                 self.head = None
14                 self.num = 0
15
16         def is_empty(self):
17                 return self.head is None
18
19         def count(self):
20                 return self.num
21
22         def prepend(self, elem):
23                 self.head = LNode(elem, self.head)
24                 self.num += 1
25
26         def pop(self):
27                 if self.head is None:
28                         raise ListError
29                 e = self.head.elem
30                 self.head = self.head.next
31                 self.num -= 1
32                 return e
33
34         def append(self, elem):
35                 if self.head is None:
36                         self.head = LNode(elem, self.head)
37                         self.num += 1
38                         return
39                 p = self.head
40                 while p.next:
41                       p = p.next
42                 p.next = LNode(elem)
43                 self.num += 1
44
45         def pop_last(self):
46                 if self.head is None:
47                         raise ListError
48                 p = self.head
49                 if p.next is None:
50                         e = p.elem
51                         self.head = None
52                         self.num -= 1
53                         return e
54                 while p.next.next:
55                         p = p.next
56                 e = p.next.elem
57                 p.next = None
58                 self.num -= 1
59                 return e
60
61         def bianli(self):
62                 p = self.head
63                 li = []
64                 while p:
65                         li.append(p.elem)
66                         p = p.next
67                 return li
68
69         def reverse(self):
70                 li = self.bianli()
71                 sl = LList()
72                 for i in li:
73                         sl.prepend(i)
74                 return sl
75
76 if __name__ == ‘__main__‘:
77         l = LList()
78         l.append(1)79        l.prepend(2)
80         l.pop_last()
81         l.append(3)
82         l.append(4)
83         l.append(5)
84         li = l.bianli()
85         print(li)
86         sl = l.reverse()
87         li = sl.bianli()
88         print(li)
8889                                                             

结果:

[2,3,4,5]

[5,4,3,2]

好久没写数据结构了 回顾一下

时间: 2024-10-25 21:22:21

数据结构练习 单链表实现反转的相关文章

秒懂单链表及其反转(reverse)

什么是链表,这种数据结构是由一组Node组成的,这群Node一起表示了一个序列.链表是最普通,最简单的数据结构,它是实现其他数据结构如stack, queue等的基础. 链表比起数组来,更易于插入,删除. Node可以定义如下: typedef int element_type; typedef struct node *node_ptr; struct node { element_type element; node_ptr next; }; 另外关于要不要头节点这个问题,我建议加上头节点,

C#数据结构-单链表

理论基础: 链表是用一组任意的存储单元来存储线性表中的数据元素. 如果结点的引用域只存储该结点直接后继结点的存储地址,则该链表叫单链表(Singly Linked List). 单链表由头引用H唯一确定.头引用指向单链表的第一个结点,也就是把单链表第一个结点的地址放在H中. C#实现: 1接口 引用线性表的接口IListDS<T> 2实现 首先,必须定义一个单链表的节点类.  1 public class Node<T> 2    { 3        private T data

单链表的反转

如何把一个单链表进行反转? 方法1:将单链表储存为数组,然后按照数组的索引逆序进行反转. 方法2:使用3个指针遍历单链表,逐个链接点交替使用指针改变链表的指向进行反转. 方法3:从第3个节点到第N-1个节点,依次逐节点插入到第1个节点(head节点)之后,再将第N个节点指向head(成环),然后将此时head的下一个节点设为head,最后将原head指向NULL. 方法4:   递归(没搞懂~) 方法2: ActList* ReverseList2(ActList* head) {   //Ac

单链表的反转问题

单链表的反转问题 单链表反转问题经常会遇到.在此记录一下,以便查阅方便. 如果反转一个有头结点的使用下面的方法比较合适. //反转单链表,此单链表带有头节点. //思想:使用tmp临时指针保存头结点与链表的关系 typedef struct ListNode  { int data; struct ListNode * next; }ListNode,*LinkList; void ReverseList(ListNode* Head) { ListNode *current,*tmp; cur

用两种递归思路与循环实现单链表的反转

typedef struct ListNode{ int data; struct ListNode *next; }ListNode; //递归一 ListNode *ReverseList (ListNode *pHead, ListNode *nHead = NULL) { //每次取下第一个节点头插法创建新链表 //nHead为反转后链表的头节点 if(pHead == NULL) return NULL; ListNode *pNext = pHead -> next; pHead -

看图理解单链表的反转

如何把一个单链表进行反转? 方法1:将单链表储存为数组,然后按照数组的索引逆序进行反转. 方法2:使用3个指针遍历单链表,逐个链接点进行反转. 方法3:从第2个节点到第N个节点,依次逐节点插入到第1个节点(head节点)之后,最后将第一个节点挪到新表的表尾. 方法4:   递归(相信我们都熟悉的一点是,对于树的大部分问题,基本可以考虑用递归来解决.但是我们不太熟悉的一点是,对于单链表的一些问题,也可以使用递归.可以认为单链表是一颗永远只有左(右)子树的树,因此可以考虑用递归来解决.或者说,因为单

[算法]实现单链表的反转

实现链表的反转 解题思路: 为了正确反转一个链表,需要调整指针的指向.举例说明,例如i,m,n是三个相邻的结点,假设经过若干步操作,已经把结点i之前的指针调整完毕,这些结点的next指针都指向前面一个结点.现在遍历到结点m,当然需要调整结点的next指针,让它指向结点i,但需要注意的是,一旦调整了指针的指向,链表就断开了,因为已经没有指针指向结点n,没有办法再遍历到结点n了,所以为了避免指针断开,需要在调整m的next之前要把n保存下来.接下来试着找到反转后链表的头结点.不难分析出翻转后链表的头

数据结构(一) 单链表的实现-JAVA

数据结构还是很重要的,就算不是那种很牛逼的,但起码得知道基础的东西,这一系列就算是复习一下以前学过的数据结构和填补自己在这一块的知识的空缺.加油.珍惜校园中自由学习的时光.按照链表.栈.队列.排序.数组.树这种顺序来学习数据结构这门课程把. -WH 一.单链表的概念 链表是最基本的数据结构,其存储的你原理图如下图所示 上面展示的是一个单链表的存储原理图,简单易懂,head为头节点,他不存放任何的数据,只是充当一个指向链表中真正存放数据的第一个节点的作用,而每个节点中都有一个next引用,指向下一

java数据结构:单链表常见操作代码实现

一.概述: 本文主要总结单链表常见操作的实现,包括链表结点添加.删除:链表正向遍历和反向遍历.链表排序.判断链表是否有环.是否相交.获取某一结点等. 二.概念: 链表: 一种重要的数据结构,HashMap等集合的底层结构都是链表结构.链表以结点作为存储单元,这些存储单元可以是不连续的.每个结点由两部分组成:存储的数值+前序结点和后序结点的指针.即有前序结点的指针又有后序结点的指针的链表称为双向链表,只包含后续指针的链表为单链表,本文总结的均为单链表的操作. 单链表结构: Java中单链表采用No