python数据结构之单链表

单链表的操作

1、is_empty()链表是否为空
2、length()链表的长度
3、add()链表的头部添加元素
4、append()链表尾部添加元素
5、insert()指定位置添加元素
6、remove()删除节点
7、search()查找链表是否存在

源代码


class Node():
    """节点"""
    def __init__(self,data = None):
        self.elem = data                #节点中的数据
        self.next = None                #下一个地址(元组也可以实现)

class singleLinkedLists(object):
    """单链表的实现"""
    #创建头结点
    def __init__(self, node = None):
        self.__head = node

    def isEmpty(self):
        """链表是否为空"""
        return self.__head == None

    def length(self):
        """链表的长度"""
        cur = self.__head
        if self.__head == None:
            return 0
        else:
            count = 1
            while cur.next != None:
                count += 1
                cur = cur.next
            return count

    def travel(self):
        """遍历链表"""
        cur = self.__head
        if self.__head == None:
            return "空链表"
        else:
            while cur.next != None:
                print(cur.elem,end=" ")
                cur = cur.next
            print(cur.elem)

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

    def insert(self,pos,data):      #pos表示插入位置,item表示插入数据
        """指定位置添加元素
        :param pos 从1开始
        """
        if pos  self.length():
            self.append(data)
            return
        count = 1  #count用来记录位置
        cur = self.__head
        node = Node(data)
        if pos == 1:
            node.next = self.__head
            self.__head = node
        else:
            while cur.next != None:
                if count == pos - 1:
                    node.next = cur.next
                    cur.next = node
                    break
                count += 1
                cur = cur.next

    def add(self,data):
        """在头部添加元素(头插法)"""
        node = Node(data)
        if self.__head == None:
            self.__head = node
        else:
            node.next = self.__head
            self.__head = node

    def remove(self,data):
        """删除节点(删除具体数据,有多个全部删除)"""
        cur = self.__head
        pre = None
        while cur != None:
            if cur.elem == data:
                #判断是否头结点
                if cur == self.__head:
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                    pre = cur
                    cur = cur.next
            else:
                pre = cur
                cur = cur.next

    def search(self,data):
        """查找链表是否存在"""
        cur = self.__head
        while cur != None:
            if cur.elem == data:
                return "该数据存在于链表中"
            else:
                cur = cur.next
        return "该数据不存在于链表中"

if __name__ == ‘__main__‘:
    #以下为测试用例
    sll = singleLinkedLists()
    #print(sll.is_empty())
    #print(sll.length())
    node = Node(100)
    ll = singleLinkedLists()
    for i in range(1,10):
        ll.append(i)
    for j in range(100,109):
        ll.add(j)
    print(ll.insert(-1,633))
    print(ll.remove(9))
    print(ll.travel())
    print("*************")
    print(ll.length())
    print(ll.search(693))

原文地址:https://www.cnblogs.com/tianyb/p/10979576.html

时间: 2024-10-01 10:45:24

python数据结构之单链表的相关文章

python——数据结构之单链表的实现

链表的定义: 链表(linked list)是由一组被称为结点的数据元素组成的数据结构,每个结点都包含结点本身的信息和指向下一个结点的地址.由于每个结点都包含了可以链接起来的地址 信息,所以用一个变量就能够访问整个结点序列.也就是说,结点包含两部分信息:一部分用于存储数据元素的值,称为信息域:另一部分用于存储下一个数据元素 地址的指针,称为指针域.链表中的第一个结点的地址存储在一个单独的结点中,称为头结点或首结点.链表中的最后一个结点没有后继元素,其指针域为空. #!/usr/bin/pytho

python数据结构与算法——链表

具体的数据结构可以参考下面的这两篇博客: python 数据结构之单链表的实现: http://www.cnblogs.com/yupeng/p/3413763.html python 数据结构之双向链表的实现: http://www.cnblogs.com/yupeng/p/3413800.html 我这里只实现了单链表的类型,代码也相对精简一点: 先构造关于节点的类: 1 class Node: 2 def __init__(self,data=None,next=None): 3 self

C#数据结构-单链表

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

数据结构:单链表结构字符串(python版)

1 #!/urs/bin/env python 2 # -*- coding:utf-8 -*- 3 4 #异常类 5 class stringTypeError(TypeError): 6 pass 7 8 #节点类 9 class Node(object): 10 def __init__(self, elem, next_ = None): 11 self.elem = elem 12 self.next = next_ 13 #单链表类 14 class single_list(obje

数据结构:单链表结构字符串(python版)添加了三个新功能

1 #!/urs/bin/env python 2 # -*- coding:utf-8 -*- 3 4 #异常类 5 class stringTypeError(TypeError): 6 pass 7 8 #节点类 9 class Node(object): 10 def __init__(self, elem, next_ = None): 11 self.elem = elem 12 self.next = next_ 13 #单链表类 14 class single_list(obje

数据结构学习--单链表(python)

概念 链表(linked_list)是物理存储单元上非连续的.非顺序的存储结构,数据元素的逻辑顺序 是通过链表的指针地址实现,每个元素包含两个结点,一个是存储元素的数据域 (内存空间) ,另一个是指向下一个结点地址的指针域.根据指针的指向,链表能形成不同的结构,例如 单链表,双向链表,循环链表等. 链表通过将链点 i 与其邻居链点 i+1 通过指针相关联,从索引 0 到索引 N-1 对链点进 行排序. 实现 class Node: """ 链点 ""&qu

Python线性表——单链表

1. 线性表简介 线性表是一种线性结构,它是由零个或多个数据元素构成的有限序列.线性表的特征是在一个序列中,除了头尾元素,每个元素都有且只有一个直接前驱,有且只有一个直接后继,而序列头元素没有直接前驱,序列尾元素没有直接后继. 数据结构中常见的线性结构有数组.单链表.双链表.循环链表等.线性表中的元素为某种相同的抽象数据类型.可以是C语言的内置类型或结构体,也可以是C++自定义类型. 2. 数组 数组在实际的物理内存上也是连续存储的,数组有上界和下界.C语言中定义一个数组: 数组下标是从0开始的

数据结构之单链表(C++实现)

有一段时间没有写一些关于数据结构的程序了,正好算法导论这门课学到红黑树,感觉数据结构都忘得差不多了,而且考研还要考,故再拿来复习一下. 一.C++实现单链表 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; void CreateList_L(LinkList &L, int n) { L = new LNode()

数据结构之——单链表

今天闲来无事,就打算把大一的时候写过的数据结构重温一遍,基本上我在大一之后只在单片机上用过几次顺序表和循环队列之外再就很少使用过数据结构了. 并且乘着写一下数据结构也可以熟悉熟悉vim. 首先定义单链表节点: 1 #define DataType int 2 3 struct node{ 4 DataType data; 5 struct node *next; 6 }; 7 struct node list,*p_list; 单链表这个数据结构需要一些函数来对她操作,一般需要有这些: 1.初始