数据结构与算法(2)顺序表和链表

无需表List的操作如下

1. add(item):添加一个数据项到列表中，假设item原先不存在于列表中
2. remove(item):从列表中移除item，列表被修改，item原先应存放在表中
3. search(item):在列表中查找item,返回bool类型值
4. isEmpy() 返回列表是否为空
5. size()：返回列表中包含多少数据项
6. append(item):添加一个数据项到表末尾，假设item原先不存在于列表中
7. index(item):返回数据项在表中的位置
8. insert(pos, item):将数据插入到位置pos，假设item原先不存在于列表中，同时原列表具有足够多个数据项，能让item占据位置pos
9. pop():从列表末尾移除数项，假设原列表至少有一个数据项
10. pop(pos):移除位置为pos的数据项，假设原列表存在位置pos

采用链表实现无序表

1. 数据项存放位置并没有规则，但是如果在数据项之间建立连接指向，就可保持其前后相对位置
2. 第一个和最后一个数据项需要显式表现出来，一个是队首，，一个是队尾，后面再无数据了

链表实现

1. 节点Node:
   每个节点至少要包含两个信息：数据项本身，以及指向下一个节点的引用信息。
   注意next为None的意义是没有下一个节点了，这点很重要

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)
temp.getData()
# 可以采用连接节点的方式构建数据集来实现无序表
# 链表的第一个和字后一个节点最重要

# 链表实现： add方法实现
def add(self,item):
    temp = Node(item)
    temp.setNext(self.head)
    self.head = temp
# 链表实现size
def size(self):
    current = self.head
    count = 0
    while current !=None:
        count+= 1
        current = current.getNext()
    return count

有序表

1. 有序表是一种数据项按照其某科比性质来决定在列表中的位置

有序表所定义的操作如下下

1. OrderList():创建一个空的有序表
2. add(item):在表中添加一个数据项，并保持整体顺序，此项原不存在
3. search(item)
4. isEmpty()
5. size()
6. index(item)
7. pop()
8. pop(pos)

# 习题一 合并两个有序链表
class Solution:
    def mergeTwolist(self, l1, l2):
        if l1 is None:
            return l2
        elif l2 is None:
            return l1
        elif ll1.val > l2.val:
            l1=l2
            l2 = l1
        p = l1
        while p is not None:
            while l2 is not None (p.next is None or l2.val < p.next.val):
                tmp = l2
                l2 = l2.next
                tmp.next = p.next
                p.next = tmp
                p = p.next
            p = p.next
        return l1
        

# 习题2 删除链表中倒数第n个节点
class Solution:
    def removeN(self,head,n):
        h = listNode(-1)
        h.next = head
        p = h
        q = h
        for _ in range(n+1):
            q = q.next
        while q != None:
            p = p.next
            q = q.next
        p.next = p.next.next
        return h.next