• Python链表与反链表



    复制代码

    # -*- coding:utf8 -*-
    #/usr/bin/env python
    
    class Node(object):
        def __init__(self, data, pnext = None):
            self.data = data
            self._next = pnext
            print('self._next',self._next)
    
        def __repr__(self):
            return str(self.data)
    
    class ChainTable(object):
        def __init__(self):
            self.head = None
            self.length = 0
    
        def isEmpty(self):
            return (self.length == 0)
    
        def append(self, dataOrNode):
            item = None
            print('Node',Node)
            if isinstance(dataOrNode, Node):
                item = dataOrNode
                print(123)
            else:
                item = Node(dataOrNode)
                print(item,456)
            if not self.head:
                self.head = item
                self.length += 1
                print('self.head',self.head._next)
            else:
                node = self.head
                print('1111node',node)
                print('111node._next',node._next)
                while node._next:
                    print(222222222222222222222222,node._next)
                    node = node._next
                    print(444444444444444,node)
                node._next = item
                print(11111111111111111111111,node._next)
                self.length += 1
    
        def reverseChainTable(self,chaintable):
            if isinstance(chaintable, Node):
                item = chaintable
                print(123)
            else:
                print('这不是链表')
                return
    
    
        def delete(self, index):
            if self.isEmpty():
                print ("this chain table is empty.")
                return
    
            if index < 0 or index >= self.length:
                print ('error: out of index')
                return
    
            if index == 0:
                self.head = self.head._next
                self.length -= 1
                return
    
            j = 0
            node = self.head
            prev = self.head
            while node._next and j < index:
                prev = node
                node = node._next
                j += 1
    
            if j == index:
                prev._next = node._next
                self.length -= 1
    
        def insert(self, index, dataOrNode):
            if self.isEmpty():
                print ("this chain tabale is empty")
                return
    
            if index < 0 or index >= self.length:
                print ("error: out of index")
                return
    
            item = None
            if isinstance(dataOrNode, Node):
                item = dataOrNode
            else:
                item = Node(dataOrNode)
    
            if index == 0:
                item._next = self.head
                self.head = item
                self.length += 1
                return
    
            j = 0
            node = self.head
            prev = self.head
            while node._next and j < index:
                prev = node
                node = node._next
                j += 1
    
            if j == index:
                item._next = node
                prev._next = item
                self.length += 1
    
        def update(self, index, data):
            if self.isEmpty() or index < 0 or index >= self.length:
                print ('error: out of index')
                return
            j = 0
            node = self.head
            while node._next and j < index:
                node = node._next
                j += 1
    
            if j == index:
                node.data = data
    
        def getItem(self, index):
            if self.isEmpty() or index < 0 or index >= self.length:
                print ("error: out of index")
                return
            j = 0
            node = self.head
            while node._next and j < index:
                node = node._next
                j += 1
    
            return node.data
    
    
        def getIndex(self, data):
            j = 0
            if self.isEmpty():
                print ("this chain table is empty")
                return
            node = self.head
            while node:
                if node.data == data:
                    return j
                node = node._next
                j += 1
    
            if j == self.length:
                print ("%s not found" % str(data))
                return
    
        def clear(self):
            self.head = None
            self.length = 0
    
        def __repr__(self):
            if self.isEmpty():
                return "empty chain table"
            node = self.head
            nlist = ''
            while node:
                nlist += str(node.data) + ' '
                node = node._next
            return nlist
    
        def __getitem__(self, ind):
            if self.isEmpty() or ind < 0 or ind >= self.length:
                print ("error: out of index")
                return
            return self.getItem(ind)
    
        def __setitem__(self, ind, val):
            if self.isEmpty() or ind < 0 or ind >= self.length:
                print ("error: out of index")
                return
            self.update(ind, val)
    
        def __len__(self):
            return self.length
    
    chariin = ChainTable()
    for i in range(10):
        chariin.append(i)
    
    print(chariin)

     

  • 相关阅读:
    linux内存的使用与page buffer (转)
    基于linux2.6.38.8内核的SDIO/wifi驱动分析(转)
    RamDisk块设备驱动实例开发讲解一
    Linux加密框架设计与实现(转)
    v4l2子系统学习心得
    一句memset引发的疑案
    linux 信号量之SIGNAL 0(转)
    可重入函数
    从ARM VIVT看linux的cache 处理
    内核抢占与preempt_count
  • 原文地址:https://www.cnblogs.com/palace/p/9599530.html
Copyright © 2020-2023  润新知