暑期学习记录08

数据结构精要

最新推荐文章于 2025-07-18 21:01:37 发布

原创最新推荐文章于 2025-07-18 21:01:37 发布 · 254 阅读

0 ·

CC 4.0 BY-SA版权

学习笔记专栏收录该内容

35 篇文章

订阅专栏

python

栈
队列
树
链表

1.栈
栈相当于一端开口，一端封闭的容器。支持出栈和进栈两种操作。
后进先出特性。
stack通常的操作：
Stack() 建立一个空的栈对象
push() 把一个元素添加到栈的最顶层
pop() 删除栈最顶层的元素，并返回这个元素
peek() 返回最顶层的元素，并不删除它
isEmpty() 判断栈是否为空
size() 返回栈中元素的个数

演示过程如下：

如果希望把数据A出栈，则首先需要将数据B出栈。

利用python列表实现栈的数据结构

# -*- coding: cp936 -*-
class Stack:
    """模拟栈"""
    def __init__(self): 
        self.items =[]  #定义一个列表items用于实现栈的容器

    def isEmpty(self): 
        return len(self.items)==0  

    def push(self,item):#执行item进栈操作
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def peek(self):#返回栈顶元素，但不删除
            if not self.isEmpty():
                return self.items[len(self.items)-1]

    def size(self):#返回栈的大小
            return len(self.items)

s=Stack() 
print(s.isEmpty()) 
s.push('DataA') 
s.push('DataB') 
print(s.peek()) 
s.push('DataC') 
print(s.size()) 
print(s.isEmpty()) 
s.push('DataD') 
print(s.pop()) 
print(s.pop()) 
print(s.size()) 

>>>
True
DataB
3
False
DataD
DataC
2

2.队列
队列相当于两边都开口的容器，但是一边只能进行删除操作，一边只能进行插入操作，进行插入操作的一端叫做队尾，进行删除操作的叫队首。
有入队和出队两种操作。
遵循先进先出原则

利用python实现队列

# -*- coding: cp936 -*-
class Queue(object):
    def __init__(self):
        self.queue=[]

    def isempty(self):
        return self.queue==[]

    def enqueue(self,item):
        self.queue.append(item)

    def dequeue(self):#程序调用列表的pop函数返回并删除第一个元素
        if self.queue!=[]:
            return self.queue.pop(0)
        else:
            return None

    def head(self):#返回队首元素
        if self.queue!=[]:
            return self.queue[0]
        else:
            return None

    def tail(self):
        if self.queue!=[]:
            return self.queue[-1]
        else :
            return None

    def length(self):
        return len(self.queue)


q=Queue()
print q.isempty()
q.enqueue('DataA')
q.enqueue('DataB')
print q.head()
print q.tail()
q.enqueue('DataC')
print q.length()
print q.isempty()
q.enqueue('DataD')
print q.dequeue()
print q.dequeue()
print q.length()

>>>
True
DataA
DataB
3
False
DataA
DataB
2

这里写图片描述

最后三步：
这里写图片描述

具体过程点击此处粘贴代码查看

3.树（非线性数据结构）
遍历二叉树：
先序遍历根节点-左子树-右子树
中序遍历左-根-右
后序遍历左-右-根
python中实现树的数据结构

# -*- coding: cp936 -*-
class Node(object):
    def __init__(self,data=-1,lchild=None,rchild=None):#定义树节点类Non
        self.data=data#树节点存储的数据
        self.lchild=lchild#左子树
        self.rchild=rchild#右子树
class BinaryTree(object):
    def __init__(self):
        self.root=Node()#root是Node对象，表示二叉树的根节点

    def add(self,data):#data为新节点的数据
        node=Node(data)

        if self.isEmpty():#如果二叉树为空，则将新节点作为二叉树的根节点
            self.root=node
        else:
            tree_node=self.root
            queue=[]#以列表存储二叉树
            queue.append(self.root)

            while queue:#遍历二叉树
                tree_node=queue.pop(0)
                if tree_node.lchild==None:
                    tree_node.lchild=node
                    return
                elif tree_node.rchild==None:

                    tree_node.rchild=node
                    return
                else:
                    queue.append(tree_node.lchild)
                    queue.append(tree_node.rchild)
    def pre_order(self,start):#先序遍历
        node=start
        if node==None:
            return

        print node.data,

        if node.lchild==None and node.rchild==None:
            return

        self.pre_order(node.lchild)
        self.pre_order(node.rchild)

    def in_order(self,start):#先序遍历
        node=start
        if node==None:
            return
        self.pre_order(node.lchild)

        print node.data,
        self.pre_order(node.rchild)

    def post_order(self,start):#先序遍历
        node=start
        if node==None:
            return
        self.pre_order(node.lchild)
        self.pre_order(node.rchild)
        print node.data,

    def isEmpty(self):
        return True if self.root.data== -1 else False

    def length(self):
        return len(self.queue)


if __name__ == '__main__':
    arr=[]
    for i in range(10):
        arr.append(i)
    print arr

    tree=BinaryTree()
    for i in arr:
        tree.add(i)

    print 'pre order:'
    tree.pre_order(tree.root)
    print '\nin order:'
    tree.in_order(tree.root)
    print '\npostorder:'
    tree.post_order(tree.root)

>>> 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
pre order:
0 1 3 7 8 4 9 2 5 6 
in order:
1 3 7 8 4 9 0 2 5 6 
postorder:
1 3 7 8 4 9 2 5 6 0

关于遍历其他参考

4.链表
用python实现单向链表

# -*- coding: cp936 -*-
class Node():
  __slots__=['_item','_next']   #限定Node实例的属性
  def __init__(self,item):
    self._item=item   #存储数据
    self._next=None   #Node的指针部分默认指向None
  def getItem(self):
    return self._item
  def getNext(self):
    return self._next
  def setItem(self,newitem):
    self._item=newitem
  def setNext(self,newnext):
    self._next=newnext

class SingleLinkedList(): 
  def __init__(self):
    self._head=None #初始化为空链表
  def isEmpty(self):
    return self._head==None
  def size(self):
    current=self._head
    count=0
    while current!=None:
      count+=1
      current=current.getNext()
    return count
  def travel(self):
    current=self._head
    while current!=None:
      print current.getItem()
      current=current.getNext()
  def add(self,item):
    temp=Node(item)
    temp.setNext(self._head)
    self._head=temp

  def append(self,item):
    temp=Node(item)
    if self.isEmpty():
      self._head=temp  #若为空表，将添加的元素设为第一个元素
    else:
      current=self._head
      while current.getNext()!=None:
        current=current.getNext()  #遍历链表
      current.setNext(temp)  #此时current为链表最后的元素
  def search(self,item):
    current=self._head
    founditem=False
    while current!=None and not founditem:
      if current.getItem()==item:
        founditem=True
      else:
        current=current.getNext()
    return founditem
  def index(self,item):
    current=self._head
    count=0
    found=None
    while current!=None and not found:
      count+=1
      if current.getItem()==item:
        found=True
      else:
        current=current.getNext()
    if found:
      return count
    else:
      raise ValueError,'%s is not in linkedlist'%item       
  def remove(self,item):
    current=self._head
    pre=None
    while current!=None:
      if current.getItem()==item:
        if not pre:
          self._head=current.getNext()
        else:
          pre.setNext(current.getNext())
        break
      else:
        pre=current
        current=current.getNext()           
  def insert(self,pos,item):
    if pos<=1:
      self.add(item)
    elif pos>self.size():
      self.append(item)
    else:
      temp=Node(item)
      count=1
      pre=None
      current=self._head
      while count<pos:
        count+=1
        pre=current
        current=current.getNext()
      pre.setNext(temp)
      temp.setNext(current)

if __name__=='__main__':
  a=SingleLinkedList()
  for i in range(1,10):
    a.append(i)
  print a.size()
  a.travel()
  print a.search(6)
  print a.index(5)
  a.remove(4)
  a.travel()
  a.insert(4,100)
  a.travel()

>>>
9
1
2
3
4
5
6
7
8
9
True
5
1
2
3
5
6
7
8
9
1
2
3
100
5
6
7
8
9