线性表

线性结构：

（1）      存在惟一一个“第一个”元素和“最后一个”元素

（2）      除第一个元素外，每个数据仅有一个“前驱”和“后继”

1.   线性表

2.      线性表：n个数据元素的有限集合

n定义为线性表的长度

3.      线性表的顺序表示和实现

顺序表示：用一组地址连续的存储单元依次存储

存储位置的关系：

L : 每个元素占用的存储单元

线性表的顺序存储结构是一种随机存取的存储结构（只要确定了表的起始位置，任一元素可随机存取）

通常用数组来描述数据结构中的顺序存储结构。

 

4.      线性表的插入与删除

插入：由于逻辑上相邻的数据结构在物理上相邻，因此插入必须原来数据元素向后移动

删除：原来的数据向前移动

时间复杂度为O（n）

上两种操作的时间主要消耗在数据移动，而移动的元素个数取决于插入（删除）的位置

 

移动元素的次数：

插入：E = n/2          删除：E = (n-1)/2

在顺序存储结构中，插入或删除一个元素，平均移动表中一半数据。

 

2. 线性链表

特点：使用一组任意的存储单元存储（也就是，物理地址可以不连续）

 

存储地址

数据元素

指向下一元素地址指针

 

整个链表的存取必须从头指针开始，头指针指向第一个元素的存储地址

 

p->data = 

p->next->data =

 

单链表是非随机存取的存储结构

 

2.1 插入和删除

插入

删除

仅需要修改指针，不需要一定元素。时间复杂度为O（n）

3. 循环链表

特点：表中最后一个元素的指针域指向头节点，整个链表形成一个环。

操作与线性链表一致，区别在于判断p或p ànext是否为头节点

 

4. 双向链表

单向链表的缺点：从某个节点出发后只能往后查询其他节点，想要查询给节点的前驱，需要从头指针出发

 

双向链表

前驱（prior）

数据元素

后继(next)

 

 

4.1   插入和删除

需要修改两个方向的指针，时间复杂度为O（n）

插入

删除

实现：
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 22 09:41:08 2018
单链表
@author: dell-1
"""
#
class ListNode:
    def __init__(self, elem, p=None):
        self.elem = elem
        self.next = p
        
class LinkList(object):
    def __init__(self):
        self.head = None
        
    def creat(self,data):
        self.head = ListNode(data[0])
        p = self.head
        for i in data[1:]:
            p.next = ListNode(i)
            p = p.next
            
    def print_Link(self):
        p =self.head
        while p is not None:      
            print(p.elem)
            p = p.next
            
    def length(self):
        length = 0
        p = self.head
        while p is not None:
            length += 1
            p = p.next
        print(length)
        
    def is_empty(self):
        return self.length == 0
        
    def insert_trail_data(self,item):
        #从表尾插入数据
        if self.is_empty():
            self.head = ListNode(item)
        else:
            p = self.head
            while p.next is not None:
                p = p.next
            p.next = ListNode(item)
    
    def getItem(self, index):
        #获取指定位置的数据
        if self.is_empty():
            print('链表为空')
            return
#        if index >= self.length() or index<0:
#            print('index超出链表大小')
#            return
        p = self.head
        count = 0
        while count != index:
            p = p.next
            count += 1
        print(p.elem)
        
    def insert_data(self,index,item):
        #从表的任意位置插入数据
        if index == 0:
            self.head = ListNode(item,self.head)
        else:
            p = self.head
            count = 0
            while count != index-1:
                p = p.next
                count += 1
            p.next = ListNode(item,p.next)
    
    def del_data(self,index):
        #删除指定位置的元素
        if index == 0:
            p = self.head
            self.head = p.next
        else:
            count = 0
            p = self.head
            while count != index-1:
                p = p.next
                count += 1
            p.next = p.next.next
        
    def clear(self):
        self.head = None
            
    def print_reverse_Link(self):
        out = []  
        p = self.head
        while p is not None:
            out.append(p.elem)
            p = p.next
        out.reverse()
        print(out)
            
a = LinkList()
a.creat([1,2,34,5])
a.insert_data(1,333)
print(a.print_reverse_Link2())