2019.9.17-单向循环链表:遍历+求长度+添加元素(完整代码)

# coding:utf-8

class Node(object):
"""節點0"""
def __init__(self, elem):
self.elem = elem
self.next = None

# node = None(100)
class SingleLinkList(object):
"""單向循環鏈表"""
def __init__(self, node=None):
self.__head = node
if node:
node.next = node

def is_empty(self):
"""鏈表是否爲空"""
return self.__head == None

def length(self):
"""鏈表長度"""
if self.is_empty():
return 0
# cur遊樸,用來移動遍歷節點
cur = self.__head
# count記錄數量
count = 1
while cur.next != self.__head:
count += 1
cur = cur.next
return count

def travel(self):
"""遍歷整個鏈表"""
cur = self.__head
while cur.next != self.__head:
print(cur.elem, end=" ")
cur = cur.next
# 退出循環, cur指向尾節點,但尾節點的元素未打印
print(cur.elem)

def add(self, item):
"""鏈表頭部添加元素,頭插法"""
node = Node(item)
if self.is_empty():
self.__head = node
node.next = node
else:
cur = self.__head
while cur.next != self.__head:
cur = cur.next
# 退出循環, cur指向尾節點
node.next = self.__head
self.__head = node
# cur.next = node
cur.next = self,__head

def append(self, item):
"""鏈表尾部添加元素,尾插法"""
node = Node(item)
if self.is_empty():
self.__head = node
node.next = node
else:
cur = self.__head
while cur.next != self.__head:
cur = cur.next
# node.next = cur.next
node.next = self.__head
cur.next = node

def insert(self, pos, item):
"""指定位置添加元素
:param pos 從0開始
"""
if pos <= 0:
self.add(item)
elif pos > (self.length()-1):
self.append(item)
else:
pre = self.__head
count = 0
while count < (pos-1):
count += 1
pre = pre.next
# 當循環退出後,pre指向pos-1位置
node = Node(item)
node.next = pre.next
pre.next = node

def remove(self, item):
"""刪除節點"""
cur = self.__head
pre = None
while cur != None:
if cur.elem == item:
# 先判斷此結點是否是頭節點
# 頭節點
if cur == self.__head:
self.__head = cur.next
else:
pre.next = cur.next
break
else:
pre = cur
cur = cur.next

def search(self, item):
"""查找節點是否存在"""
cur = self.__head
while cur != None:
if cur.elem == item:
return True
else:
cur = cur.next
return False

if __name__ == "__main__":
ll = SingleLinkList()
print(ll.is_empty())
print(ll.length())

ll.append(1)
print(ll.is_empty())
print(ll.length())

ll.append(2)
ll.add(8)
ll.append(3)
ll.append(4)
ll.append(5)
ll.append(6)
# 8 1 2 3 4 5 6
ll.insert(-1, 9) # 9 8 123456
ll.travel()
ll.insert(3, 100) # 9 8 1 100 2 3456
ll.travel()
ll.insert(10, 200) # 9 8 1 100 23456 200
ll.travel()
ll.remove(100)
ll.travel()
ll.remove(9)
ll.travel()
ll.remove(200)
ll.travel()

原文地址:https://www.cnblogs.com/lishuide/p/11537966.html

时间: 2024-10-27 06:25:21

2019.9.17-单向循环链表:遍历+求长度+添加元素(完整代码)的相关文章

已知二叉树的前序遍历、中序遍历或者中序遍历、后序遍历求二叉树结构的算法

二叉树中的前序遍历是先访问根结点,再访问左子树,右子树. 中序遍历是先访问左子树,再是根结点,最后是右子树. 后序遍历是先访问左子树,再是右子树,最后是根结点. 算法思路是先根据前序遍历的第一个结点或者后序遍历的最后一个结点,查找对应在中序遍历中的位置,就可以确定左子树包含的元素和右子树包含的元素,最后通过递归来实现就可以了. 二叉树的表示形式为 //二叉树的结构表示为 class TreeNode { int val; TreeNode left; TreeNode right; TreeNo

用单向循环链表实现约瑟夫环问题

约瑟夫环的问题和种类有很多,这是一道基本的约瑟夫环问题,通过单向循环链表实现模拟此过程. 代码如下: #include<stdio.h> #include<stdlib.h> typedef struct Node { int num; int password; struct Node *next; }CircleNode,*CircleList; CircleList Create(int n); void Knockout(CircleList L,int n,int m);

数据结构与算法 1 :基本概念,线性表顺序结构,线性表链式结构,单向循环链表

[本文谢绝转载] <大纲> 数据结构: 起源: 基本概念 数据结构指数据对象中数据元素之间的关系  逻辑结构 物理结构 数据的运算 算法概念: 概念 算法和数据结构区别 算法特性 算法效率的度量 大O表示法 时间复杂度案例 空间复杂度 时间换空间案例 1)线性表: 线性表初步认识: 线性表顺序结构案例 线性表顺序结构案例,单文件版 线性表的优缺点 企业级线性表链式存储案例:C语言实现 企业级线性表链式存储案例:C语言实现 单文件版 企业级线性表链式存储案例,我的练习  线性表链式存储优点缺点

Python 单向循环链表

操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item) 在尾部添加一个节点 insert(pos, item) 在指定位置pos添加节点 remove(item) 删除一个节点 search(item) 查找节点是否存在 class Node(object): """节点""" def __init__(self, item): se

javascript实现数据结构: 树和二叉树的应用--最优二叉树(赫夫曼树),回溯法与树的遍历--求集合幂集及八皇后问题

赫夫曼树及其应用 赫夫曼(Huffman)树又称最优树,是一类带权路径长度最短的树,有着广泛的应用. 最优二叉树(Huffman树) 1 基本概念 ① 结点路径:从树中一个结点到另一个结点的之间的分支构成这两个结点之间的路径. ② 路径长度:结点路径上的分支数目称为路径长度. ③ 树的路径长度:从树根到每一个结点的路径长度之和. 以下图为例: A到F :结点路径 AEF : 路径长度(即边的数目) 2 : 树的路径长度:3*1+5*2+2*3=19: ④ 结点的带权路径长度:从该结点的到树的根结

链表练习:单向循环链表变双向

已知有一个单向循环链表,其每个结点中含三个域:prior,data 和 next,其中 data 域为数据域,next 为指向后继结点的指针域,prior 也为指针域,但它的值为空 (NULL) ,试编写算法将此单向循环链表改为双向循环链表,即使 prior 成为指向前驱结点的指针域. 输入格式 输入共有三行,第一行为该单向循环链表的长度 n(1≤n≤50):第二行为该单向循环链表的各个元素 aii??(1≤ai ??≤1000),它们各不相同且都为数字:第三行为一个数字 m,表示链表中的一个元

(java实现)单向循环链表

什么是单向循环链表 单向循环链表基本与单向链表相同,唯一的区别就是单向循环链表的尾节点指向的不是null,而是头节点(注意:不是头指针). 因此,单向循环链表的任何节点的下一部分都不存在NULL值. 由于单向循环链表的特性,它在处理一些环状数据的时候十分有效.大名鼎鼎的约瑟夫环问题就可以用循环单向链表求解,下面我们会有进一步的介绍. 由于单向循环链表和单向链表的差别真的不大,增添改查原理都相同.因此在这里我们不详细讲解,只提供源码.(如果你还是不理解的话,这里有单向链表的传送门) 源码实现(Ja

顺序表 初始化 插入 删除 查找 合并 交换 判断为空 求长度

#include <stdio.h> #include <stdlib.h> #define OK 1 #define TRUE 1 #define ERROR -1 #define FALSE -1 #define OVERFLOW -2 #define ElemType int #define Status int typedef int ElemType typedef int Status #define LEN sizeof(SqList) #define MLC (Li

LCS模板,求长度,并记录子串

1 //LCS模板,求长度,并记录子串  2 //亦可使用注释掉的那些代码,但所用空间会变大 3 #include<iostream> 4 #include<cstring> 5 #include<cmath> 6 #include<cstdlib> 7 #include<cstdio> 8 using namespace std; 9 #define N 5005 10 11 int len[N][N]; 12 char str1[N],str