数据结构学习之（一）------线性表（Python）

一.概述

1.定义

2.基本操作

（1）结构初始化操作
（2）结构销毁操作
（3）引用型操作：查询，定位，找元素的前驱和后继，线性表的长度，判断是否为空
（4）加工型操作：插入，删除元素

二.存储结构

1.顺序存储：用一组地址连续的存储单元依次存放线性表中的元素

2.链式存储：用一组地址任意的存储单元存放线性表

三.顺序存储结构

1.时间复杂度分析

（1）初始化：O（1）

（2）查找：

（1）按位置查找：O（1）
（2）按值查找：
最好：O（1）
最坏：O（n）
平均：比较n/2次，时间复杂度是O(n)

（3）插入：O（n）

在第i 个位置插入e，要移动n-i+1个元素，而在第i个位置上插入的概率为Pi,平均移动次数为n/2 时间复杂度O（n）

（4）删除：O(n)

最好：删除最后一个
最坏：删除第一个，移动n-1
平均：移动次数(n-1)/2，时间复杂度O(n)

（5）总结：

顺序存储插入和删除操作开销较大

三.链式存储

1.分类：带头结点和不带头结点的链表

带头节点：头节点永远存在，为空时L.next=null,操作更加方便
不带头节点：空时为null

2.时间复杂度分析

（1）查找

按值查找：O（n）
按位置查找：

（2）插入

单是指插入本身而言，效率为O（1），由于定位操作，效率为O(n)，比起顺序结构需要移动大部分数据，链式存储只需要改变指针的指向，所以十分高效，

（3）删除

同插入的分析

四.单链表的变形

1.循环单链表：最后一个节点的指针指向头节点，从任意位置出发都可以访问所有节点

2.带尾指针的循环单链表：

应用情形1：将两个单链表进行合并
应用情形2:经常要在最后一个元素后面添加新元素和在第一个元素面前插入新元素

3.双向链表：每个节点有两个指针，分别指向节点的前驱和后继

下面是python实现带头节点的单链表的基本操作

五.链表的基本操作Python实现代码

#定义节点类
class Node():
    def __init__(self,data,next=None):
        self.data=data
        self.next=next
#定义带头指针的单链表，头指针数据域为链表的长度        
class Linked_list():
    def __init__(self):
        self.head = Node(0)
    #顺序创建链表，即输入顺序和链表顺序一致
    def create_Linked_list_shunxu(self):
        element = input('input item：')
        if not element:
            pass
        else:
            node1 = Node(data=element)
            self.head.data=1
            self.head.next = node1
            currentnode=node1
            while True:
                element = input('input item：')
                if not element:
                    break
                else:
                    newnode=Node(data=element)
                    self.head.data+=1
                    currentnode.next=newnode
                    currentnode =newnode
    #逆序创建链表，即先输入的元素在链表的后面
    def create_Linked_list_nixu(self):
        element = input('input item：')
        if not element:
            pass
        else:
            node1 = Node(data=element)
            self.head.data=1
            self.head.next = node1
            currentnode=node1
            while True:
                element = input('input insert_item：')
                if not element:
                    break
                else:
                    newnode=Node(data=element)
                    self.head.data+=1
                    self.head.next=newnode
                    newnode.next=currentnode
                    currentnode=newnode
    #按值查找
    def seek_Linked_list_element(self, element):
        currentnode=self.head
        i=0
        while currentnode and currentnode.data!=element:
              i+=1
              currentnode = currentnode.next
        if currentnode==None:
            print('There is no item like this')
        else:
            return i
    #按位置查找
    def seek_Linked_list_pos(self, pos):
        currentnode=self.head
        i=0
        while currentnode and i<pos:
            i+=1
            currentnode=currentnode.next
        if currentnode :
            return currentnode.data
        else:
            print('out of index')
    #在某个位置插入元素
    def insert_Linked_list(self, element, pos):
        currentnode=self.head
        i=0
        while currentnode and i<pos-1:
            currentnode =currentnode.next
            i+=1
        if currentnode :
            insertnode=Node(element,currentnode.next)
            currentnode.next=insertnode
        else:
            print('Your pos might be out of index or illegal')
        self.head.data+=1
    #删除某个位置的元素
    def del_Linked_list(self, pos):
        currentnode=self.head
        i=0
        while pos<=self.head.data and i<pos-1:
            i+=1
            currentnode=currentnode.next
        if currentnode:
            mid_node=currentnode.next
            currentnode.next=mid_node.next
        self.head.data-=1
    #打印链表内容
    def print_Linked_list(self):
        currentnode=self.head
        if currentnode:
            currentnode=currentnode.next
            while currentnode :
                print(currentnode.data)
                currentnode = currentnode.next
        else:
            print('The Linked_list is empty')