专栏首页逸繁Python手写模拟单向链表对象,栈对象和树

Python手写模拟单向链表对象,栈对象和树

单向链表:

class error(Exception):
    def __init__(self,msg):
        super(error,self).__init__()
        self.msg=msg
    def __str__(self):
        return self.msg    
class Node:
    def __init__(self,ele):
        self.ele=ele
        self.next=None
class mylist:
    def __init__(self,ele=None):
        self.index=0
        self.pos=0
        if ele:
            self._head=Node(ele)
        else:
            self._head = None
    def __iter__(self):
        return self
    def __next__(self):
        if self.pos < self.length():
            self.pos += 1
            cursor = self._head
            current=cursor
            num = 0
            while cursor != None:
                current = cursor
                cursor = cursor.next
                num += 1
                if num == self.pos:
                    return current.ele
        else:
            raise StopIteration
    def empty(self):
        return  self._head==None
    def add(self,item):
        node=Node(item)
        node.next=self._head
        self._head=node
    def length(self):
        cur=self._head
        num=0
        if cur:
            num+=1
            while cur.next:
                cur=cur.next
                num+=1
            return num
        else:
            return num      
    def append(self,item):
        node=Node(item)
        cursor=self._head
        if self.empty():
            self._head = node
        else:
            while cursor.next!= None:
                cursor = cursor.next
            cursor.next=node
    def pop(self):
        if self.empty():
            return None
        else:
            if self.length()==1:
                ele=self._head.ele
                self._head.ele=None
                return ele
            else:
                cur=self._head
                current=cur
                while cur.next!=None:
                    current=cur
                    cur=cur.next 
                    ele=cur.ele
                current.next=None
                return ele
    def insert(self,index,item):
        if index<0 or index>self.length():
            raise error("out of range")
        else:
            if index==0:
                self.add(item)
            elif index==self.length():
                self.append(item)
            else:
                node = Node(item)
                cur=self._head
                pre=0
                while pre<index-1:
                    cur=cur.next
                    pre+=1
                node.next=cur.next
                cur.next=node     
    def get(self,index):
        if index<0 or index>self.length()-1:
            raise error("out of range")
        else:
            num=0
            cur=self._head
            while num<index:
                cur=cur.next
                num+=1
            return cur.ele
    def remove(self,item):
        cur=self._head
        pre=None
        while cur!=None:
            if cur.ele==item:
                if pre==None:
                    self._head=cur.next
                else:    
                    pre.next=cur.next
                break    
            else:
                pre=cur
                cur=cur.next    
    def delete(self,index):
        if index<0 or index>self.length()-1:
            raise error("out of range")
        else:
            if index==0:
               self._head=self._head.next
            else:
                num=1
                current=self._head
                cur=current.next
                while num!=index:
                    current=cur
                    cur=current.next
                    num+=1
                current.next=cur.next
                cur.ele=None
                cur.next=None

栈:

class stack:
    def __init__(self):
        self._box=[]
    def empty(self):
        return self._box==[]
    def length(self):
        return len(self._box)
    def push(self,item):
        self._box.append(item)
    def pop(self):
        return self._box.pop()        

树:

class Node:
    def __init__(self,ele=None,left=None,right=None):
        self.ele = ele
        self.left = None
        self.right = None
class Tree:
    def __init__(self,node=None):
        self.root = node
    def append(self,item):
        node = Node(item)
        if self.root is None:
            self.root = node
        else:
            queue = [self.root]
            while queue:
                current=queue.pop(0)
                if current.left is None:
                    current.left = node
                    return
                elif current.right is None:
                    current.right = node
                    return
                else:
                    queue.append(current.left)
                    queue.append(current.right)
    def loop(self):
        if self.root is None:
            return
        queue=[self.root]#广度优先
        while queue:
            current=queue.pop(0)
            print(current.ele)
            if current.left!=None:
                queue.append(current.left) 
            elif current.right!=None:
                queue.append(current.right) 

    def deep_loop_top(self,node):
        if node==None:
            return
        print(node.ele)
        self.deep_loop_top(node.left)
        self.deep_loop_top(node.right)

    def deep_loop_left(self,node):
        if node==None:
            return
        self.deep_loop_left(node.left)
        print(node.ele)
        self.deep_loop_left(node.right)

    def deep_loop_last(self,node):
        if node==None:
            return
        self.deep_loop_last(node.left)
        self.deep_loop_last(node.right)
        print(node.ele)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Python - 面向对象编程 - __new__() 和单例模式

    使用 类名() 创建对象时,Python 的解释器首先会调用 __new__ 方法为对象分配内存空间

    小菠萝测试笔记
  • iOS数据结构与算法面试题合集

    static int count = 0;//目前已经放了多少个数(相当于栈顶位置)

    iOSSir
  • Python知识点

    宇宙之一粟
  • 干货满满--亲身经历的 Python 面试题

    如果看过我第一篇文章(三个月自学拿到 python 开发 offer!)的朋友可能知道,我来上海一个多星期,面试了大概十几家公司,收到了一些 offer,其实截...

    编程文青李狗蛋
  • 2019年Java工程师成神之路正式版

    你是否想让自己的Java知识更上一层呢?是否想成为Java工程师大神呢?下面将告诉你如何成神之路,让自己更牛逼!

    格姗知识圈
  • Java 工程师成神之路 | 2019正式版

    JVM 还支持哪些语言(Kotlin、Groovy、JRuby、Jython、Scala)

    乔戈里
  • Python后端技术栈(二)

    Darkness cannot drive out darkness; only light can do that. Hate cannot drive ou...

    小闫同学啊
  • Python面向对象魔法方法和单例模块代码实例

    ​ 凡是在类内部定义,以“__开头__结尾”的方法都称之为魔法方法,又称“类的内置方法”, 这些方法会在某些条件成立时触发。

    砸漏
  • 蚂蚁金服暑期实习生一面总结

    牛客网
  • 为了BAT,你必须了解的java修仙之路

    classLoader、类加载过程、双亲委派(破坏双亲委派)、模块化(jboss modules、osgi、jigsaw)

    乔戈里
  • Java开发 2019秋招 面经整理

    进入面试流程的包括字节跳动、招银科技、百度、Keep、华为、花旗、京东、有赞、去哪儿、拼多多、okcoin,收到的offer有华为、招银、有赞、去哪儿,其他有一...

  • java 成神之路

    java404
  • 给广大码农分享福利:一个业界良心的github仓库,中文计算机资料

    我今天查资料时无意发现的,https://github.com/CyC2018/CS-Notes

    Jerry Wang
  • 给广大码农分享福利:一个业界良心的github仓库,中文计算机资料

    版权声明:本文为博主汪子熙原创文章,未经博主允许不得转载。 https://jerry.blog....

    Jerry Wang
  • 2020年 Python学习路线及学习目标规划 拿走不谢!

    找不到完整的学习路线?小编分享2020年Python学习路线及学习目标规划拿走不谢,Python作为今年来特别受欢迎的编程语言,是AI时代头牌语言AI领域的敲门...

    python学习教程
  • 27-内存知识

    数组、列表:数据是有顺序的,从左到右,从0开始。如果要在列表中,插入一个数据,那么在插入位置之后的数据,都需要移动,删除列表中间某个数据,在位置之后的数据,也都...

    zx钟
  • JAVA试练塔之试炼技能图

    1.计算机基础: 1.1数据机构基础: 主要学习: 1.向量,链表,栈,队列和堆,词典。熟悉 2.树,二叉搜索树。熟悉 3.图,有向图,无向图,基本概念 4.二...

    hbbliyong
  • C++后台开发必看,这个学习路线必须收藏

    在去年结束的秋季招聘中,后台开发或服务器开发的岗位需求一度火热,甚至超过了算法岗。不少同学从诸神黄昏的算法岗战场上退下,转向更偏向工程能力的后台开发岗,从而造成...

    java架构师
  • 面试常考知识点总结——面试必看

    答: 7层:应用层、表示层、会话层、传输层、网络层、数据链路层、物理层 4层:应用层、传输层、网络层、链路层 为什么分层: ①多层之间相互独立,灵活性好...

    海盗船长

扫码关注云+社区

领取腾讯云代金券