数据结构之线性表

线性表

顺序存储结构

如：数组(在python中类似于列表)

优点：由于是顺序存储，所以可以很方便的知道每个元素的存储位置。

缺点：在进行插入或者删除元素时需要移动大量元素，会耗费大量时间。(插入元素时需要将后面的每个元素都向后移动一个位置，删除元素时则需要将后面的每个元素都向前移动一个位置)

链式存储结构

优点：存储位置不确定，并不是有序的。在进行插入或删除元素时不需要移动大量元素，节省时间开销。

缺点：如果要查找某个元素的存储位置，必须从第一个结点开始依次遍历，需要花费时间去遍历所有元素。

单向链表

结点的含义：一个结点包含数据区和指针区

在单向链表中每个结点都有一个指向下一个结点位置的指针(最后一个结点的指针为NULL)，我们把存储第一个结点位置的指针称为头指针。

另外，为了对链表的操作更加方便，通常我们还会设置一个头结点。头结点的指针区存储的就是头指针，数据区可以不存储任何数据，也可以存储一些链表的附加信息(如链表长度等)

#使用python模拟单向链表
class Node:
    def __init__(self, data, next_node):
        self.data = data
        self.next_node = next_node


class LinkTable:
    
    def __init__(self):
        self.first_node = Node('', None)
        self.len = 0

    def insert(self, index, data):
        if index > self.len:
            raise ValueError('索引超出范围')
        node = self.first_node
        i = 0
        while i < index and node.next_node:
            node = node.next_node
            i += 1
        node.next_node = Node(data, node.next_node)
        self.len += 1

    def append(self, data):
        node = self.first_node
        while node.next_node:
            node = node.next_node
        node.next_node = Node(data, None)
        self.len += 1

    def remove(self, data):
        node = self.first_node
        i = 0
        while i < self.len and node.next_node:
            if node.next_node.data == data:
                next_node = node.next_node
                node.next_node = node.next_node.next_node
                next_node.next_node = None
                del next_node
                self.len -= 1
                return
            node = node.next_node
            i += 1
        else:
            raise ValueError('要删除的元素不存在')

    def lenth(self):
        return self.len

    def get_item(self, index):
        if index >= self.len:
            raise ValueError('索引超过范围')
        node = self.first_node.next_node 
        data = node.data
        i = 0
        while i <= index and node:
            data = node.data
            node = node.next_node
            i += 1
        return data

    def get_index(self, data):
        i = 0
        node = self.first_node.next_node
        while node:
            if node.data == data:
                return i
            i += 1
            node = node.next_node
        else:
            raise ValueError('该元素不存在')

    def clear(self):
        node = self.first_node
        while node.next_node:
            next_node = node.next_node
            node.next_node = next_node.next_node
            next_node.next_node = None
            del next_node
        self.len = 0 

#测试demo
from linktable import LinkTable
import time


lb = LinkTable()
lb_start = time.time()

x = 200000

for i in range(0, x):
    lb.insert(0, i)
lb_end = time.time()

print('插入%d条数据，链表使用的时间为%.18f秒' % (x, lb_end - lb_start))

ls = []
ls_start = time.time()
for i in range(0, x):
    ls.insert(0, i)
ls_end = time.time()

print('插入%d条数据，列表使用的时间为%.18f秒' % (x, ls_end - ls_start))

lb_start_time = time.time()
item = lb.get_item(x-1)
lb_end_time = time.time()
print('获取最后一个元素，链表使用的时间为%.18f秒' % (lb_end_time - lb_start_time))

ls_start_time = time.time()
item = ls[x-1]
ls_end_time = time.time()
print('获取最后一个元素，列表使用的时间为%.18f秒' % (ls_end_time - ls_start_time))

#测试结果
插入200000条数据，链表使用的时间为0.262263774871826172秒
插入200000条数据，列表使用的时间为7.788862228393554688秒
获取最后一个元素，链表使用的时间为0.033907175064086914秒
获取最后一个元素，列表使用的时间为0.000000953674316406秒

单向循环链表

单向循环链表是在单向链表的基础上，将最后一个结点的指针指向第一个结点的位置，并且在单向链表中常用的头结点不能再继续使用。

#使用python模拟单向循环链表
class Node:
    def __init__(self, data, next_node):
        self.data = data
        self.next_node = next_node


class LinkTable:
    
    def __init__(self):
        self.node = None
        self.len = 0
    
    def __init(self, data):
        self.node = Node(data, None) 
        self.node.next_node = self.node

    def insert(self, index, data):
        if index > self.len:
            raise ValueError('索引超出范围')
        if not self.node:
            self.__init(data)
            self.len += 1
            return
        if index == 0:
            self.node = Node(data, self.node)
            self.len += 1
            return
        node = self.node
        i = 0
        while i < index and node.next_node:
            node = node.next_node
            i += 1
        node.next_node = Node(data, node.next_node)
        self.len += 1

    def append(self, data):
        if not self.node:
            self.__init(data)
            self.len += 1
            return
        node = self.node
        while node.next_node != self.node:
            node = node.next_node
        node.next_node = Node(data, self.node)
        self.len += 1

    def remove(self, data):
        node = self.node
        i = 0
        while i < self.len and node.next_node:
            if node.next_node.data == data:
                next_node = node.next_node
                node.next_node = next_node.next_node
                next_node.next_node = None
                del next_node
                self.len -= 1
                return
            node = node.next_node
            i += 1
        else:
            raise ValueError('要删除的元素不存在')

    def lenth(self):
        return self.len

    def get_item(self, index):
        if index >= self.len:
            raise ValueError('索引超过范围')
        node = self.node
        i = 0
        while i <= index and node:
            data = node.data
            node = node.next_node
            i += 1
        return data

    def get_index(self, data):
        i = 0
        node = self.node
        while i < self.len:
            if node.data == data:
                return i
            node = node.next_node
            i += 1
        else:
            raise ValueError('该元素不存在')

    def clear(self):
        node = self.node
        next_node = node.next_node
        while node.next_node:
            next_node = node.next_node
            node.next_node = next_node.next_node
            next_node.next_node = None
            del next_node
        self.len = 0 

静态链表(用两个数组实现)

需要使用两个并行数组来实现，一个数组用来存储元素，另一个数组则用来存储下一个元素的位置。由于有些语言不支持指针和引用，一般用此方法模拟实现链表，此处不再使用代码实现。

双向链表

由于双向链表是基于单向链表的前提下的"升级版",所以很多特点与单向链表相同。

双向链表与单向列表的不同之处主要在于：每个结点有两个存储指针的区域，分别存储前一个结点的位置和下一个结点的位置。

#使用python模拟双向链表
class Node:
    def __init__(self, data, per_node, next_node):
        self.data = data
        self.per_node = per_node
        self.next_node = next_node


class LinkTable:
    
    def __init__(self):
        self.first_node = Node('', None, None)
        self.len = 0

    def insert(self, index, data):
        if index > self.len:
            raise ValueError('索引超出范围')
        node = self.first_node
        i = 0
        while i < index and node.next_node:
            node = node.next_node
            i += 1
        node.next_node = Node(data, node, node.next_node)
        self.len += 1

    def append(self, data):
        node = self.first_node
        while node.next_node:
            node = node.next_node
        node.next_node = Node(data, node, None)
        self.len += 1

    def remove(self, data):
        node = self.first_node
        i = 0
        while i < self.len and node.next_node:
            if node.next_node.data == data:
                next_node = node.next_node
                node.next_node = next_node.next_node
                next_node.next_node = None
                next_node.per_node = None
                del next_node
                self.len -= 1
                return
            node = node.next_node
            i += 1
        else:
            raise ValueError('要删除的元素不存在')

    def lenth(self):
        return self.len

    def get_item(self, index):
        if index >= self.len:
            raise ValueError('索引超过范围')
        node = self.first_node 
        i = 0
        while i <= index and node.next_node:
            node = node.next_node
            data = node.data
            i += 1
        return data

    def get_index(self, data):
        i = 0
        node = None
        while i < self.len:
            node = self.first_node.next_node if not node else node.next_node
            if node.data == data:
                return i
            i += 1
        else:
            raise ValueError('该元素不存在')

    def clear(self):
        node = self.first_node
        while node.next_node:
            next_node = node.next_node
            node.next_node = next_node.next_node 
            next_node.per_node = None
            next_node.next_node = None
            del next_node
        self.len = 0 

双向循环链表：在双向链表的基础上，将第一个结点的前驱指针指向最后一个结点的位置，将最后一个结点 的后继指针指向第一个结点的位置。