基本数据结构——线性结构（列表/无序表）

1.什么是列表（List）?

一个数据项按照相对位置存放的数据集。特别的，被称为“无序表(unordered list)”，其中数据项只按照存放位置来索引，如第1个、第2个…、最后一个等。
如一个考试分数的集合“54,26,93,17,77,31”，如果用无序表来表示，就是[54,26,93,17,77,31]

2.抽象数据类型：无序表List的操作

3.用链表实现无序表

为了实现无序表数据结构，可以采用链接表的方案。
虽然列表数据结构要求保持数据项的前后相对位置，但这种前后位置的保持，并不要求数据项一次存放在连续的存储空间。
如下图，数据项存放位置并没有规则，但如果在数据项之间建立链表指向，就可以保持其前后相对位置。第一个和最后一个数据项需要显式标记出来，一个是队首，一个是队尾，后面再无数据了。

3.1 链表实现

3.1.1 节点Node

链表实现的最基本元素是节点Node。
每个节点至少要包含2个信息：数据项本身以及指向下一个节点的引用信息。next为None的意义是没有下一个节点了。

3.1.2 节点Node的python实现

#定义节点
class Node:
    def __init__(self,initdata):
        self.data=initdata#把初始项传进去，且下一节点设置为空
        self.next=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#修改下一个节点的指向引用
temp=Node(93)#创建一个数据项为93的节点
temp.getData()

3.2 链表实现无序表（UnorderedList）

可以采用链接节点的方式构建数据集来实现无序表。
链表的第一个和最后一个节点最重要。如果想访问到链表中的所有节点，就必须从第一个节点开始沿着链接遍历下去。所以无序表必须要有对第一个节点的引用信息。

class UnorderedList:
    def __init__(self):
        self.head=None
        
mylist=UnorderedList()
print(mylist.head)

随着数据项的加入，无序表的head始终指向链条中的第一个节点。
注意！！！
无序表mylist对象本身并不包含数据项（数据项在节点中），其中包含的head只是对首个节点Node的引用。
判断空表的isEmpty()很容易实现—return self.head ==None

3.2.1 链表实现：add方法实现

由于无序表并没有限定数据项之间的顺序，新数据项可以加入到原表的任何位置。按照实现的性能考虑，应添加到最容易加入的位置上。
由链表结构可知，要访问整条链上的所有数据项，都必须从表头head开始沿着next链接逐个向后查找。所以添加新数据项最快捷的位置时表头，整个链表的首位置。

#定义节点
class Node:
    def __init__(self,initdata):
        self.data=initdata#把初始项传进去，且下一节点设置为空
        self.next=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

3.2.2 链表实现：size

size:从链条头head开始遍历到表尾，同时用变量累加经过的节点数。

python代码实现

#定义节点
class Node:
    def __init__(self,initdata):
        self.data=initdata#把初始项传进去，且下一节点设置为空
        self.next=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 size(self):
    current=self.head
    count=0
    while current != None:
        count=count+1
        current=current.getNext()
    return count

3.2.3 链表实现：search

从链表头head开始遍历到表尾，同时判断当前节点的数据项是否为目标。

python代码实现

#定义节点
class Node:
    def __init__(self,initdata):
        self.data=initdata#把初始项传进去，且下一节点设置为空
        self.next=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 search(self,item):
    current=self.head
    isOK=False
    while current !=None and not isOK:
        if current.getData()==item:
            isOK=True
        else:
            current=current.getNext()
    return isOK

3.2.4 链表实现：remove(item)方法

（1）首先找到item，这个过程跟search一样，但在删除节点时，需要特别的技巧
current指向的是当前匹配数据项的节点，而删除需要把前一个节点的next指向current的下一个节点。所以，我们在search current的同时，还要维护前一个（previous）节点的引用。

（2）找到item之后，current指向item节点，previous指向前一个节点，开始执行删除时，需要区分两种情况：current是个首节点或者是位于链条中间的节点。

python代码实现

#定义节点
class Node:
    def __init__(self,initdata):
        self.data=initdata#把初始项传进去，且下一节点设置为空
        self.next=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 remove(self,item):
    previous=None
    current=self.head
    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())