无序表的python实现

最近在MOOC上自学北京大学 《数据结构与算法Python版》陈斌 等

在课程313与314的无序表的链表实现，老师的代码并不十分详细，故在课下自我尝试实现了一下无序表的几个基本功能，在此分享

代码如下：

class MyNode:
     #初始化节点
    def __init__(self,data):
        self.data = data
        self.next = None

     #返回节点数据
    def getData(self):
        return self.data

     #返回节点的下一个节点（仍为MyNode类）
    def getNext(self):
        return self.next

     #修改节点的数据
    def setData(self,data):
        self.data = data

     #修改节点的下一个节点（在做列表的remove方法时，关键就是设置下一个节点）
    def setNext(self,next):
        self.next = next

class UnorderedList:
     #初始化列表头
    def __init__(self):
        self.head = None

     #添加元素（任意类型）(add(第一个参数为添加元素，默认为None, 第二个元素为插入位置，默认为‘last’，即表尾))
    def add(self, item=None, place='last'):
        if ((self.size() == 0) and (place == 'last')) or place == 0:   #在[0]处添加
            temp = MyNode(item)
            temp.setNext(self.head)
            self.head = temp

        elif (place == self.size()) or (place == 'last'):              #在末尾添加
            current = self.head
            while (current.getNext() != None) :
                current = current.getNext()
            temp = MyNode(item)
            current.setNext(temp)

        elif place > self.size():                                      #越界报错
            print('Sorry lenth of list just {0},\
            place is {1}!!! cannot above it'.format(self.size(),place))

        elif (place > 0) and (type(place) == int):                     #中间插入
            temp = MyNode(item)
            current = self.head
            count = 1
            while count < place:
                count = count + 1
                current = current.getNext()
            temp.setNext(current.getNext())
            current.setNext(temp)

        else:                                                          #不规范输入报错
            print('Error argument place!!!')

     #返回列表大小（size）
    def size(self):
        current = self.head
        count = 0
        while current != None:
            count = count + 1
            current  = current.getNext()
        return count

     #删除指定元素（remove）(有多个重复对象，则删除第一个)
    def remove(self,item):
        current = self.head
        if current.getData() == item:                                   #开头删除
            self.head = current.getNext()
            current = None
            return item

        else:                                                           #非开头删除
            while (current.getNext()).getData() != item:
                current = current.getNext()
                if current.getNext() == None:
                    print("Sorry havn't found {0}!".format(item))       #未发现待删除对象
                    return None

            if (current.getNext()).getNext() == None:                   #结尾删除
                current.next = None
                return item

            else:                                                       #中间删除
                current.next = (current.getNext()).getNext()
                return item

     #展示列表内容（showData）
    def showData(self):
        current = self.head
        while current != None:
            print('{0}'.format(current.getData()), end=' ')
            current = current.getNext()


#代码测试
alist = UnorderedList()
alist.add(0)
print(alist.size())
alist.add(3, 0)
alist.add(4, 0)
alist.add(5)
alist.add([1, 2, 3], 2)
alist.add(None)
print('size is {0}'.format(alist.size()))

print('data is')
alist.showData()
print('\n')

alist.remove(6)
print('data is')
alist.showData()
print('\n')

alist.remove(5)
print('after remove 5 data is')
alist.showData()

运行结果：

"D:\mixture\python creat\数据结构\venv\Scripts\python.exe" "D:/mixture/python creat/数据结构/venv/MyNode.py"
1
size is 6
data is
4 3 [1, 2, 3] 0 5 None 

Sorry havn't found 6!
data is
4 3 [1, 2, 3] 0 5 None 

after remove 5 data is
4 3 [1, 2, 3] 0 None 
进程已结束，退出代码 0

这个无序表的实现过程中需要注意的是：

1.节点的next属性是下一个节点对象（除了最后一个节点）

2.列表中节点的属性data可以是None，而列表的最后一个节点的特征它的next属性是None

比较有意思的地方是：

本程序的remove方法中，非开头非结尾的删除并没有采用陈斌老师课件中的双指针来实现

而是用了节点的双重getNext来实现，这样current就是待删除的节点的前一个节点，要删除节点，直接将current的next属性设置为(current.getNext()).getNext()  （待删除节点的下一个节点）即可

 

以上。