线性表

根据存储结构的不同可以分为顺序存储和链式存储两种结构

顺序线性表

构建的方法

1、创建
2、检测
3、遍历
4、查找、定位
5、插入
6、删除

基本实现形式

1、一体式
2、分离式

python的标准list是一种元素个数可变的线性表

1、基于下标的元素访问，O(1)
2、允许加入元素
3、连续表
4、能更换存储区，要想跟换存储区时，list对象的标识不变，必须采用分离式

线性链表

单向链表

定义表节点类

class LNode:
    def __init__(self,elem,next_ = None):

链表的基本操作

1、创建
2、检测
3、遍历
4、查找、定位
5、插入：表首插入、表尾插入、随机插入
6、删除：表首删除、表尾删除、随机删除

代码实现

#1、定义表节点类
class LNode:
    def __init__(self,elem,next_ = None):
        self.elem = elem
        self.next_ = next_
#2、定义线性链表
class LList:
    def __init__(self):
        self._head = 0
        self._length = 0
    #检测
    def is_empty(self):
        return self._length == 0
    #获取大小
    def getlen(self):
        return self._length
    #遍历
    def printall(self):
        if self._head == 0:
            return -1
        else:
            q = self._head # 临时节点
            while(q):
                print(q.elem)
                q = q.next_
    #插入
    	#前端
    def prepend(self,elem):
        p = LNode(elem)
        if self._head == 0:
            self._head = p
            self._length += 1
        else:
            p.next_ = self._head.next_
            self._head = p
            self._length += 1
            #后端
    def append(self,elem):
        p = LNode(elem) #新节点
        if self._head ==0:
            self._head = p
            self._length += 1
        else:
            q = self._head # 临时节点
            while(q.next_):
                q = q.next_
            q.next_ = p
            self._length += 1
            #任意指定位置
    def insert(self,elem,i):
        count = 0
        p = LNode(elem)
        if i< 0 or i>self._length:
            raise IndexError('insert out of the range!')    #检查范围
        else:
            #插入到0号索引
            if self._head == 0:
                self._head = p
                self._length += 1
            elif i == 0 :
                p.next_ = self._head
                self._head = p
                self._length += 1
            #插入到其他索引
            else:
                pre = self._head
                while(count < i-1):
                    pre = pre.next_
                    count +=1
                if pre.next_ is not None:
                    p.next_ = pre.next_
                    pre.next_ = p
                    self._length += 1
                else:
                    pre.next_ = p
                    self._length += 1
    #删除
    	#前端
    def del_first(self):
        if self._length == 0:
            raise IndexError('the List is empty!')
        elif self._length == 1:
            self._head = 0
            self._length -= 1
        else:
            self._head = self._head.next_
            self._length -=1
            #后端
    def del_last(self):
        if self._length == 0:
            raise IndexError('the list is empty!')
        elif self._length ==1:
            self._head =0
            self._length -=1
        else:
            q = self._head
            while(q.next_.next_):
                q = q.next_
            q.next_ =None
            self._length -=1
            #任意位置
    def del_(self,i):
        count = 0
        if i< 0 or i>self._length:
            raise IndexError('del out of the range!')    #检查范围
        else:
            #删除到0号索引
            if self._length == 1:
                self._head = 0
                self._length -= 1
            #删除到其他索引
            else:
                pre = self._head
                while(count < i-1):
                    pre = pre.next_
                    count +=1
                pre.next_ = pre.next_.next_
    #移动链表中的元素来实现插入排序
    #有两个循环：第一个是要插入的元素的循环；第二个是插入元素与其之前元素比较的循环；
    #从第一个元素开始，找到比插入元素大的元素，就交换，（然后将原始插入元素之前到新插入元素位置之间的元素想右移动）
    #交换后的元素当做插入元素，继续和剩下的原始插入元素前的元素比较交换；
    def sort1(self):
        if self._length == 0:
            return 
        crt = self._head
        while(crt):
            x = crt.elem
            p = self._head
            while p is not crt and p.elem <= x:
                p = p.next_
            while p is not crt:
                y = p.elem
                p.elem = x
                x = y
                p = p.next_
            crt.elem = x
            crt = crt.next_
    #通过变换链接的方式来实现插入排序
    #同样是两个循环：第一个循环是要插入元素的循环吗；第二个循环是插入元素与其之前元素的比较循环；
    #第二个循环的实现方式:首先将插入元素的赋给一个临时节点，并将其前一个节点的next指向其后一个节点；然后从头节点开始一直找到比插入元素
    #大的节点的前一个节点；然后将临时节点插入到该节点之后；
    def sort(self):
        if self._length <=1:
            return
        p = self._head
        rem = p.next_
        p.next_ = None
        while rem is not None:
            p = self._head
            q = None
            while p is not None and p.elem <= rem.elem:
                print(p.elem,rem.elem)
                q = p
                p = p.next_
            if q is None:
                self._head = rem
            else:
                q.next_ = rem
            q = rem
            rem = rem.next_
            q.next_ = p                   
#测试
L = LList()
L.append(1)
L.append(9)
L.append(7)
L.append(6)
L.printall()
L.getlen()
L.sort()
print('\n')
L.printall()