数组与链表 | 易学教程

引子

假设你去看演出，需要将东西寄存。寄存处有一个柜子，柜子有很多抽屉。

在这里插入图片描述
计算机就像是很多抽屉的集合体，每个抽屉都有地址。

fe0ffeeb是一个内存单元的地址。

需要将数据存储到内存时，你请求计算机提供存储空间，计算机给你一个存储地址。需要存储多项数据时，有两种基本方式——数组和链表。但它们并非都适用于所有的情形，因此知道它们的差别很重要。接下来介绍数组和链表以及它们的优缺点。

数组有时候，需要在内存中存储一系列元素。假设你要编写一个管理待办事项的应用程序，为此需要将这些待办事项存储在内存中。

在这里插入图片描述
我们先将待办事项存储在数组中。使用数组意味着所有待办事项在内存中都是相连的（紧靠在一起的）。

现在假设你要添加第四个待办事项，但后面的那个抽屉放着别人的东西！

这就像你与朋友去看电影，找到地方就坐后又来了一位朋友，但原来坐的地方没有空位置，只得再找一个可坐下所有人的地方。在这种情况下，你需要请求计算机重新分配一块可容纳4个待办事项的内存，再将所有待办事项都移到那里。如果又来了一位朋友，而当前坐的地方也没有空位，你们就得再次转移！真是太麻烦了。同样，在数组中添加新元素也可能很麻烦。如果没有了空间，就得移到内存的其他地方，因此添加新元素的速度会很慢。

再以整型数组为例，数组的存储形式如下图所示。正如军队里的士兵存在编号一样，数组中的每一个元素也有着自己的下标，只不过这个下标从0开始，一直到数组长度-1。
在这里插入图片描述
数组中的每一个元素，都存储在小小的内存单元中，并且元素之间紧密排列，既不能打乱元素的存储顺序，也不能跳过某个存储单元进行存储。
在上图中，橙色的格子代表空闲的存储单元，灰色的格子代表已占用的存储单元，而红色的连续格子代表数组在内存中的位置。不同类型的数组，每个元素所占的字节个数也不同，本图只是一个简单的示意图。

数组的基本操作：

读取元素：

array1=[1,2,3,4,5]
print(array1[0])  # 1
print(array1[-1])  # 5

更新元素：

array1=[1,2,3,4,5]
array1[0]=8 #按照索引修改指定位置的值
print(array1)  # [8,2,3,4,5]

插入元素：
尾部插入：

l1 = ['a','b','c'].append('d')
print(l1) # ['a', 'b', 'c', 'd']
l1.extend(['a','b', 'c'])
print(l1) # ['a', 'b', 'c', 'd', 'a', 'b', 'c']

中间位置插入：

l1.insert(0,"first")  # 0表示按索引位置插值
print(l1) # ['first', 'a', 'b', 'c', 'd', 'a', 'b', 'c']

删除元素：

l = [11,22,33,44]
del l[2]  # 删除索引为2的元素
print(l) # [11,22,44]

# pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
l = [11,22,33,22,44]
res=l.pop()
print(res) # 44
res=l.pop(1)
print(res)# 22

# remove()括号内指名道姓表示要删除哪个元素，没有返回值
l = [11,22,33,22,44]
print(l.remove(22)) #从左往右查找第一个括号内需要删除的元素  None

总结：
数组拥有非常高效的随机访问能力，只要给出下标，就可以用常量时间找到对应元素。有一种高效查找元素的算法叫作二分查找，就是利用了数组的这个优势。至于数组的劣势，体现在插入和删除元素方面。由于数组元素连续紧密地存储在内存中，插入、删除元素都会导致大量元素被迫移动，影响效率。总的来说，数组所适合的是读操作多、写操作少的场景。

链表

链表中的元素可存储在内存的任何地方。
在这里插入图片描述
链表的每个元素都存储了下一个元素的地址，从而使一系列随机的内存地址串在一起。

这犹如寻宝游戏。你前往第一个地址，那里有一张纸条写着“下一个元素的地址为123”。因此，你前往地址123，那里又有一张纸条，写着“下一个元素的地址为847”，以此类推。在链表中添加元素很容易：只需将其放入内存，并将其地址存储到前一个元素中。

使用链表时，根本就不需要移动元素。这还可避免另一个问题。假设你与五位朋友去看一部很火的电影。你们六人想坐在一起，但看电影的人较多，没有六个在一起的座位。使用数组时有时就会遇到这样的情况。假设你要为数组分配10 000个位置，内存中有10 000个位置，但不都靠在一起。在这种情况下，你将无法为该数组分配内存！链表相当于说“我们分开来坐”，因此，只要有足够的内存空间，就能为链表分配内存。

在这里插入图片描述
单向链表的每一个节点又包含两部分，一部分是存放数据的变量data，另一部分是指向下一个节点的指针next。链表的第1个节点被称为头节点，最后1个节点被称为尾节点，尾节点的next指针指向空。

什么是双向链表？

双向链表比单向链表稍微复杂一些，它的每一个节点除了拥有data和next指针，还拥有指向前置节点的prev指针。
在这里插入图片描述

链表的基本操作：

查找节点：
在查找元素时，链表不像数组那样可以通过下标快速进行定位，只能从头节点开始向后一个一个节点逐一查找。

例如给出一个链表，需要查找从头节点开始的第3个节点。
在这里插入图片描述

更新节点：
如果不考虑查找节点的过程，链表的更新过程会像数组那样简单，直接把旧数据替换成新数据即可。
在这里插入图片描述

插入节点：

数组类似，链表插入节点时，同样分为3种情况。

尾部插入
头部插入
中间插入

尾部插入，是最简单的情况，把最后一个节点的next指针指向新插入的节点即可。
在这里插入图片描述
头部插入，可以分成两个步骤。
第1步，把新节点的next指针指向原先的头节点。
第2步，把新节点变为链表的头节点。

中间插入，同样分为两个步骤。
第1步，新节点的next指针，指向插入位置的节点。
第2步，插入位置前置节点的next指针，指向新节点。
在这里插入图片描述
只要内存空间允许，能够插入链表的元素是无穷无尽的，不需要像数组那样考虑扩容的问题。

删除元素：
链表的删除操作同样分为3种情况。

尾部删除
头部删除
中间删除

尾部删除，是最简单的情况，把倒数第2个节点的next指针指向空即可。
在这里插入图片描述
头部删除，也很简单，把链表的头节点设为原先头节点的next指针即可。

中间删除，同样很简单，把要删除节点的前置节点的next指针，指向要删除元素的下一个节点即可。

链表的基本操作：

class Node(object):
    def __init__(self,elem):
        self.elem = elem
        self.next = None

class SingleLinkList(object):

    def __init__(self,node=None):
        self.__head = node

    def is_empty(self):
        """链表是否为空"""
        return self.__head is None

    def length(self):
        """链表长度"""
        cur = self.__head
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历整个链表"""
        cur = self.__head
        while cur is not None:
            print(cur.elem,end=' ')
            cur = cur.next
        print("")

    def add(self,item):
        """链表头部添加节点"""
        node = Node(item)
        node.next = self.__head
        self.__head = node

    def append(self,item):
        """链表尾部添加节点"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next is not None:
                cur = cur.next
            cur.next = node

    def insert(self,pos,item):
        """指定位置插入元素
        pos:  位置参数,从0开始索引
        """
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 当循环退出后，pre指向pos-1位置
            node = Node(item)
            node.next = pre.next
            pre.next = node

    def remove(self,item):
        """指定位置删除节点"""
        cur = self.__head
        pre = None
        while cur is not 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


    def search(self,item):
        """查找节点是否存在"""
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

    def set(self,elem,new_elem):
        """替换节点"""
        cur = self.__head
        while cur is not None and elem != cur.elem:
            cur = cur.next
        if cur is not None:
            cur.elem = new_elem
            return True
        else:
            return False