顺序表与单向链表

线性表两种实现模型：

顺序表：将元素顺序地存放在一块连续的储存区里，元素间的顺序关系由他们的存储顺序自然表示。

链表：将元素存放在通过链接构造起来的一系列储存块中。

---

顺序表

下图a，表示的是，相同数据类型的元素，按顺序排列存储的形式，可以根据前项的地址配合索引求出各项的地址，从而得到各项的数值。

下图b，当数据类型不一致时，不同的数据类型所占的内存不一样，所以不能根据索引求出各项地址，如list1 = [123,'ab',3.14]，则需要使用图b中，元素外置的顺序表，（一个地址占4个字节），顺序表中是各项元素的地址，再由地址指向相对应的存储空间代表的元素值。最右图便于理解，里面的Li都指向顺序表最开始的位置。

顺序表一体式结构和分离式结构

右图便于理解，直观展示了顺序表的一体式结构和分离式结构。当数据慢慢添加，原始顺序表不够时，

1）一体式结构的顺序表首先向系统申请一个新的储存空间，把数据写入新的存储空间，并在旧的存储空间释放内存，这里表头的max（最大存放元素个数），num(当前元素个数)也要搬到新的存储空间，地址产生变化，较为复杂。

2）分离式结构的顺序表，也许向系统申请一个新的存储空间，但是仅仅书数据区变化，表头区不变，仅仅将表头的最后一个元素中指向数据区的值进行更改即可，由于Li开头指向表头所在的位置，所以分离式结构的顺序表在增加数据存储时，Li指向的地址不发生变化。如下图所示：

 

---

链表：是一种常见的基础数据结构，是一种线性表，但是不想顺序表一样连续的存储数据，而是每个节点（数据的存储单元）里面存放下一个节点的位置信息(即地址)
 

单向链表

单向链表也叫单链表，是链表中最简单的一种形式，他的每个节点包含两个域，一个信息域(放元素值的)，一个链接域(存放下一个节点的地址)，这个链接指向链表的下一个节点，而最后一个节点的链接域则指向一个空值。】

python中交换两个变量的值：

a = 10
b = 20
a,b = b,a

a = 10,表示，一个内存里面存储着10，他的地址假如是0x15，则a是另一个空间，里面存放着值为10的空间的地址，即0x15，

a,b = b,a表示a指向的地址是20，b里面的地址指向10。

 a = 表示：a中的地址指向不同的值。，

a可以指向任何值。

 

---

单向链表代码：

# -*- coding: utf-8 -*-
"""
Created on Fri Nov 16 15:53:22 2018

@author: Hhaicl
"""


class Node(object):
    '''节点'''
    def __init__(self,elem):
        self.elem = elem
        self.next = None
        pass

class SingleLinkList(object):
    '''单链表'''
    
    def __init__(self,node = None):
        self.__head = None

    def is_empty(self):
        '''链表判空'''
        return self.__head == None


    def length(self):
        '''链表长度'''
        # cur 游标，用来移动遍历节点
        cur = self.__head
        # count记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历整个链表'''
        cur = self.__head
        while cur !=None:
	        print(cur.elem,end = ' ')
	        cur = cur.next
      
    def append(self,item):
        #item 不是节点，是一个具体的元素
        node = Node(item)
        #    if self._head ==None:
        if self.is_empty():
            self.__head = node
        else:
            cur= self.__head
            while cur.next != None:
	            cur = cur.next
            cur.next = node
    def add(self,item):
        node = Node(item)
        node.next = self.__head
        self.__head = node



    def insert(self,pos,item):
        node = Node(item)
        if pos <= 0:
            self.add(item)
        elif pos > self.length():
            self.append(item)
        else:
            count = 0
            cur = self.__head
            while count < pos-1:
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node
            
    def search(self,item):
        cur = self.__head
        while cur != None:
            if  cur.elem == item:
                print('存在')
                return True
            else:
                cur = cur.next
        return False
    
    def remove(self,item):
        pre = None
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                if cur == self.__head:
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                # 删除完毕要退出，不然会死循环
                break
            else:
                pre = cur
                cur = cur.next

---

顺序表和链表区别：

顺序表在存取元素的时候可以一次性定位，较为高效，但是顺序表的空间必须是连续的，若一旦动态改变，则整个存储区都要改变，要是数据较大系统没有一个连续的存储空间则顺序表就达不到要求。链表则可以达到对离散的数据空间充分应用，但是链表访问元素效率没有顺序表那么高。在中间插入和删除，链表主要耗时在遍历链表上，而顺序表主要耗时在拷贝和覆盖上。