数据结构与算法（python） 线性结构：无序列表 Unordered List以及链表

参考自 MOOC数据结构与算法Python版

一、什么是列表List

一种数据项按照相对位置存放的数据集,特别的，被称为“无序表unordered list”, 其中数据项只按照存放位置来索引，如第1个、第2个……、最后一个等。

二、抽象数据类型List

2.1 List的基本操作

函数	含义
List()	创建一个空列表
add(item)	添加一个数据项到列表中，假设item原先不存在于列表中
append(item)	添加一个数据项到表末尾，假设item原先不存在于列表中
remove(item)	从列表中移除item，列表被修改， item原先应存在于表中
search(item)	在列表中查找item，返回布尔类型值
isEmpty()	返回List是否为空
size()	返回List中包含数据项的个数
index(item)	返回数据项在表中的位置
insert(pos, item)	将数据项插入到位置pos，假设item原先不存在与列表中，同时原列表具有足够多个数据项，能让item占据位置pos
pop()	从列表末尾移除数据项，假设原列表至少有1个数据项
pop(pos)	移除位置为pos的数据项，假设原列表存在位置pos

三、 Python实现链表：节点Node

• 为了实现无序表数据结构， 可以采用链接表的方案。
• 虽然列表数据结构要求保持数据项的前后相对位置， 但这种前后位置的保持， 并不要求数据项依次存放在连续的存储空间(在数据项之间建立链接指向， 就可以保持其前后相对位置)
• 链表实现的最基本的元素是Node
• 每个节点至少要包含2个信息： 数据项本身，以 及指向下一个节点的引用信息。注意：next为None的意义是没有下一个节点了

链表实现：

• 可以采用链接节点的方式构建数据集来实现无序表
• add: 最后被加入的数据项是头节点
• size：从链条头head开始遍历到表尾同时用变量累加经过的节点个数
• search：从链表头head开始遍历到表尾， 同时判断当前节点的数据项是否目标
• remove(item)：首先要找到item， 这个过程跟search一样， 但在删除节点时， 需要特别的技巧：current指向的是当前匹配数据项的节点，而删除需要把前一个节点的next指向current的下一个节点，所以我们在search current的同时，还要维护前一个(previous)节点的引用。找到item之后， current指向item节点，previous指向前一个节点， 开始执行删除，需要区分两种情况：
  1. current是首个节点
  2. 位于链条中间的节点

代码如下：

class Node:
   def __init__(self,initdata):
       self.data = initdata
       self.next = None
       self.head = None
   def getData(self):
       return self.data
   def getNext(self):
       return self.next
   def setData(self,newdata):
       self.data = newdata
   def setNext(self, newnext):
       self.next = newnext
   def add(self, item):
       temp = Node(item)
       temp.setNext(self.head)
       self.head = temp
   def size(self):
       current = self.head
       count = 0
       while current!=None:
           count += 1
           current = current.getNext()
       return count
   def search(self,item):
       current = self.head
       found = False
       while current != None and not found:
           if current.getData() == item:
               found = True
           else:
               current = current.getNext()
       return found
   def remove(self,item):
       current = self.head
       previous = None
       found  = False
       while not found(): #必须在可以找到的情况下
           if current.getData() == item:
               found = True
           else:
               previous = current
               current = current.getNext()
       if previous == None:   #头节点
           self.head = current.getNext()
       else: #中间的某个节点
           previous.setNext(current.getNext)

3.1 从尾到头打印链表

剑指offer原题，复原了接口

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        # 方法一  使用栈
        if not listNode:
            return []
        temp = []
        result = []
        while listNode:
            temp.append(listNode.value) # 进栈
            listNode = listNode.next
        while temp:
            result.append(temp.pop()) # 出栈
        return result
class node(object):
    def __init__(self, item):
        self.value = item
        self.next = None
if __name__ == '__main__':
    # 创建链表
    head_node = node(67)
    node1 = node(0)
    node2 = node(24)
    node3 = node(58)
    head_node.next = node1
    node1.next = node2
    node2.next = node3
    so = Solution()
    print(so.printListFromTailToHead(head_node))

output:
[58, 24, 0, 67]