python数据结构

1、栈(后进先出）

代码：

# -*- coding: cp936 -*-

class Stack:
    """模拟栈"""
    def __init__(self):
        self.items=[];
    def isEmpty(self):
        return len(self.items)==0;
    def push(self,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());

实验结果为：

2、队列（先进先出）

实验代码：

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):
        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());

实验结果：

问题：为什么tail()函数中self.queue[-1]下标为-1 呐？

3、树（非线性的数据结构）（具有非常高的层次性，在很大程度上节约存储空间）

二叉树：要么是空树，要么有左右两个子树。是一个有序树，即使只有一个子树，也要区分该子树是左子树还是右子树。二叉树有两种存储方式，一种是顺序存储，一种是链式存储。顺序存储中采用一维数组的存储方式；链式存储，采用链表的存储方式。在链式存储中，树节点包含数据域、左子链域、右子链域。

完全二叉树：指除最后一层外，每一层上的节点数均达到最大值，在最后一层上只缺少右边的若干节点。

满二叉树：是一种特殊的完全二叉树，指除最后一层无任何子节点外，每一层上的所有节点都有两个子节点的二叉树。

遍历二叉树的思想：要让树中的所有节点被且仅被访问一次，即按一定规律排列成一个线性队列。

实验代码：

# -*- coding: cp936 -*-
class Node(object):
    def __init__(self,data=-1,lchild=None,rchild=None):
        self.data=data;
        self.lchild=lchild;
        self.rchild=rchild;
class BinaryTree(object):
    def __init__(self):
        self.root=Node();
    def add(self,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.in_order(node.lchild);
        print node.data;
        self.in_order(node.rchild);
    def post_order(self,start):
        node=start;
        if node==None:
            return;
        self.post_order(node.lchild);
        self.post_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 '\n in_order:'
    tree.in_order(tree.root);
    print '\npost_order:'
    tree.post_order(tree.root);

实验结果为：

分析图片：

4、链表

实验代码：

# -*- coding: cp936 -*-
class Node():
    __slots__=['_item','_next'];#限定实例属性
    def __init__(self,item):
        self._item=item;
        self._next=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;
        self._size=0;
    def isEmpty(self):
        return self._head==None;
    #add()函数用于在链表前端添加元素
    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);
    #index()函数用于返回指定元素在链表中的位置，注，返回的并不是下标，而是第几个位置
    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);
    def size(self):
        count=0;
        if self.isEmpty():
            return count; 
        else:
            current=self._head;
            count=1;
            while current.getNext()!=None:
                current=current.getNext();
                count+=1;
            return count;
    def travel(self):
        
        if self.isEmpty():
            print "null";
        else:
            current=self._head;
            while current.getNext()!=None:
                print current.getItem();
                current=current.getNext();
            print current.getItem();
            
if __name__=='__main__':
    a=SingleLinkedList();
    for i in range(1,10):
        a.append(i);
    print "链表长度为："+str(a.size());
    print "打印单向链表元素:"
    a.travel();
    print "打印第5个元素："+str(a.index(5));
    a.remove(4);
    print "删除完位置4的元素：";
    a.travel();
    a.insert(4,100);
    print "插入4位置100："
    a.travel();

实验结果为：