数据结构和算法第三天~顺序表 ,链表,栈,单链表及节点的定义代码,单链表与顺序表的对比

顺序表 

结构

 

 

 顺序表的两种基本实现方式：

一体式：整体性强易于管理，但是数据元素区域是表对象的一部分顺序创建后，元素存储区就固定了

分离式：表对象里只保存与整个表有关的信息，实际数据元素存放在另一个独立的元素存储区里通过链接与基本表对象关联

考虑到数据动态变化，一般都采用分离式

链表：

将元素存放在通过链接构造起来的一系列存储块中

栈(堆栈)：

是一种容器，可存入元素，访问元素，删除元素

特点是先进后出 （LIFO,last in first out）

队列 只允许一端增加，在另一端进行删除的操作

先进先出（FIFO）

栈结构的实现

可以用链表也可以用顺序表

栈的操作：

class Stack(object):
    """栈"""
    def __init__(self):
        self.__list=[]
    def push(self,item):
        #添加一个元素到栈顶
        self.__list.append(item)

        pass
    def pop(self):
        #弹栈
        return  self.__list.pop()
        pass
    def peek(self):
        if self.__list:
            return  self.__list[-1]
        else:
            return None
        #返回栈顶元素
        pass
    def is_empty(self):
        return self.__list==[]
        #判断是否为空
        pass
    def size(self):
        return  len(self.__list)
        #返回栈个数
        pass
if __name__ == '__main__':
    s=Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())

链表

单向链表：也就是单链表，是链表中最简单的一种形式，每个节点包含两个域，就像上图的数据区（elem区）和链接区（next区）就是一个节点，链接指向链表中的下一个节点，而最后的一个节点的链接域则指向一个空值

交换a，b内容：

a=10 

b=20

a,b=b,a

本质上是改变了两者的地址导向

 

单链表及节点的定义代码：

#coding=utf8
class Node(object):
    """ 节点"""
    def __init__(self,elem):
        self.elem=elem
        self.next=None

    #node=Node(100)
    class SingleLinkList(object):
        """单链表"""
        def __init__(self,node=None):
            self._head=node

        def is_empty(self):
            """链表是否为空"""
            return self._head==None   #私有的加上个下划线
            pass
        def length(self):
            """链表长度"""
        #cur游标，用来移动遍历节点
            cur=self._head
            #count用来记录数量
            count=0
            while cur !=None:
                count +=1
                cur=cur.next#  cur 指向下一个节点
            return count
            pass
        def travel(self):
            """遍历整个链表"""
            cur=self._head
            while cur !=None:
                print(cur.elem,end=" ")    #打印当前的cur值  end=" "  换行
                cur=cur.next       #往下移动一个位置
            print("") # 打印空格就是换行

        def add(self,item):
            """链表头部添加元素，头插法"""
            node=Node(item)
            node.next=self._head
            self._head=node

            pass
        def append(self,item):
            """链表尾部添加元素,尾插法"""
            node=Node(item)
            if self.is_empty():
                self._head=None
            else:
                cur=self._head
                while cur.next !=None:
                    cur=cur.next
                cur.next=node
            print("")
            pass
        def insert(self,pos,item):
            """指定位置添加元素"""
            if pos <=0:
                self.add(item)  #从0开始，头插法
            elif pos > (self.length()-1):
                self.append(item)
            else:
                pre=self._head
                count=0
                while count<(pos-1):
                    count+=1
                    pre=pre.next
                #当循环退出后，pre指向POS-1位置
                node=Node(item)
                node.next=pre.next
                pre.next=node

            pass
        def remove(self,item):
            """删除节点"""
            cur=self._head
            pre=None
            while cur!= None:
                if cur.elem==item:
                    #判断此节点是否为头结点
                    #头结点
                    if cur==self._head:
                        self._head=cur.next
                        break
                    else:
                         pre.next=cur.next
                         break
                else:
                    pre=cur
                    cru=cur.next
                    break
            pass
        def search(self,item):
            """查找节点是否存在"""
            cur=self._head
            while cur!=None:
                if cur.elem==item:
                    return True
                else:
                    cur=cur.next
            return  False

if __name__ == "__main__":
    ll = Node.SingleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(-1,9)
    ll.travel()
    ll.insert(3,100)
    ll.travel()
    ll.insert(10,200)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(100)
    ll.travel()

单链表与顺序表的对比

 

中间插入删除区别：

• 链表用在遍历上面，
• 顺序表用在数据搬迁上面，