【OJ算法训练】02__八月__线性表

线性表

参考资料：

C语言中文网：http://c.biancheng.net/view/3336.html

数据结构与算法教程：http://data.biancheng.net/view/158.html

... ...

定义

顺序存储结构：将线性表L=(a0,a1, ……,an-1)中的各元素依次存储于计算机一片连续的存储空间。【集中存储】

链式存储结构：将线性表L=(a0,a1, ……,an-1)中的各元素分散存储，物理存储位置随机。【分散存储】每个数据元素在存储时都配备一个指针，用于指向自己的直接后继元素。

数据元素之间的关系：一对一。即：除首尾元素之外，其他数据元素均为首尾相接(大部分线性表)。

特点

1．集合中必存在唯一的一个“第一元素”。

2．集合中必存在唯一的一个 “最后元素” 。

3．除最后一个元素之外，均有唯一的后继(后件)。

4．除第一个元素之外，均有唯一的前趋(前件)。

程序实现

>>>L = [1, 2, 3, 4]
>>>L.append(10)  # 尾部增加元素
L
[1, 2, 3, 4, 10]
>>>L.insert(1,20)  # 插入元素
L
[1, 20, 2, 3, 4, 10]
>>>L.remove(3)  # 删除元素
L
[1, 20, 2, 4, 10]
>>>L[4] = 30  # 修改
L
[1, 20, 2, 4, 30]
>>>L.index(2)  # 查找
2

以下代码参考CSDN大佬：

wenlyq：python线性表_wenlyq的博客-CSDN博客_python线性表

单向链表

# !/usr/bin/env python
# coding: utf-8
​
# 创建一个链表中的节点类(item,next)
class Node:
    def __init__(self, item):  # 节点初始条件有值
        self.item = item
        self.next = None
​
​
# 创建链表的类
class SingleLink:
    # 初始化，给定链表的头部属性
    def __init__(self, node=None):
        self.__head = node
​
    # 判断链表是否为空，即判断链表的head指针是否指向空
    def is_empty(self):
        return self.__head is None  # 为None返回True，不为None，False
​
    # 判断链表的长度
    def length(self):
        if self.is_empty():
            return 0
        else:
            current_node = self.__head  # 代表current_node指向当前节点的游标与head指针指向同一个节点
            length_count = 1  # 对比注释部分另一个方法，length_count=0
            while current_node.next is not None:
                length_count += 1
                current_node = current_node.next
            return length_count
​
    # 遍历整个链表
    def travel(self):
        if self.is_empty():
            return None
        else:
            all_item_list = []
            current_node = self.__head
            all_item_list.append(current_node.item)  # 先加入第一个
            while current_node.next is not None:
                current_node = current_node.next  # 尽管最后一个current_node.next==None,但已经加入过
                all_item_list.append(current_node.item)
            return all_item_list
​
    # 链表头部加入元素
    def add(self, new_item):
        new_node = Node(new_item)
        if self.is_empty():
            self.__head = new_node
        else:
            new_node.next = self.__head
            self.__head = new_node
​
    # 尾部添加元素,需要判断是否为空
    def append(self, new_item):
        new_node = Node(new_item)
        if self.is_empty():  # 类之间的函数调用用self.func
            self.__head = new_node
        else:
            current_node = self.__head
            while current_node.next is not None:
                current_node = current_node.next
            current_node.next = new_node
​
    # 指定位置添加元素，根据位置分为头部添加，尾部添加，中间位置添加，中间位置添加时需找到添加位置的前一个节点
    def insert(self, position, new_item):
        if position <= 0:
            self.add(new_item)
        elif position >= self.length():  # 大于等于链表长度
            self.append(new_item)
        else:
            current_node = self.__head
            position_count = 0
            new_node = Node(new_item)
            while position_count < (position - 1):  # current_node为插入位置前一个的节点
                current_node = current_node.next
                position_count += 1
            new_node.next = current_node.next
            current_node.next = new_node
​
    # 删除节点，再循环条件内查找
    def remove(self, item):
        current_node = self.__head
        pre_node = None
        while current_node is not None:  # 判断是否找到
            if current_node.item == item:  # 找到删除的值对应的节点
                if pre_node is None:  # 如果前一个节点为空，则当前节点为第一个节点
                    self.__head = current_node.next
                else:
                    pre_node.next = current_node.next
                break  # 注意break
            else:
                pre_node = current_node  # 将当前节点给前一个节点
                current_node = current_node.next  # 当前节点为其next的指向
        # 如果找到，判断current_node是否为第一个节点
​
    # 查找节点
    def search(self, item):
        current_node = self.__head
        found = False
        while not found and current_node is not None:  # 此处是current_node，最后一个值也可找
            if current_node.item == item:
                found = True
            else:
                current_node = current_node.next
        return found
​
    # 更新链表某个位置的值
    def update(self, position, new_item):
        if (position < 0) or (position > self.length()):