逻辑数据结构包括：线形结构、树形结构、图形结构、集合；存储结构包括：顺序存储、链式存储、索引存储、散列存储。
同一种逻辑结构可以有四种存储结构，不同的存储结构增、删、查、改的速度不同。逻辑结构与存储结构排列组合，就得到4*4=16种结构。
在C/C++中，栈和队列的常用实现方式为数组和链表，存储方式分别是：顺序存储和链式存储。
在Python中，栈和队列的常用实现方式为list，存储方式是索引，实现起来要比C/C++简单的多，而且大小可以动态扩展，存取也非常方便，可以说它集成了顺序存储
和链式存储的优点，索引表本身就是顺序存储啊，就是数组，它是怎样实现动态扩展长度的呢？这个就不知道了，有空看看Python的实现代码源代码。Python也是可以
用链式存储实现线性结构的，见下面的代码，但没有list实现方便。C/C++中的内置类型(类)中没有索引存储的，你也许想到指针数组，的确，它是一种索引结构，但用
它不容易实现线性结构，因为当你添加元素时，要先用变量创建该元素，而且变量名与线性表中已有元素的变量名不能相同，每次添加都要用不同的变量名，看来这种方
式不行，那我们可以动态molloc，用指针指向该molloc，然后通过指针给新元素赋值，然后再把指针指向的地址保存在链表数组中，这样是可以，但太麻烦了。在Python
中，编程语言自动帮你实现了这个过程，这对用户来说就简单的一比了。总得来说，用list实现栈和队列和两种方法，一种是实例对象的数据属性是list，另一种是类直接
继承list类。第二种方法简单，但由于继承了list，而list提供了很多对外接口，如extend()等，这些接口其实是标准栈不应该有的。所以建议用第一种方法实现。
Stack类--实现1(推荐)
classStack(list):def __init__(self):
self.__stack =[]defis_empty(self):return notbool(len(self))defpush(self,data):
self.__stack.append(data)defpop(self):if len(self.__stack)>0:return self.__stack.pop()defpeek(self):
if len(self.__stack)>0:return self.__stack[-1]defget_length(self):return len(self.__stack)
Stack类--实现2(不建议使用)
classStack(list):defis_empty(self):return notbool(len(self))defpush(self,data):
self.append(data)defpop(self):if len(self)>0:returnself.pop()defpeek(self):if len(self)>0:return self[-1]defget_length(self):return len(self)
Stack类--实现3(链式存储，不建议使用)
classNode(object):def __init__(self,data):
self.data=data
self.next=NoneclassStack(object):def __init__(self,head_node):
self.top=head_node
self.bottom=head_nodedefpush(self,node):
node.next=self.top
self.top=nodedefpop(self):if self.top ==None:returnNoneelse:
key=self.top
self.top=self.top.nextif self.top ==None:
self.bottom=Nonereturnkey
s= Stack(Node(12))
s.push(Node(13))
s.push(Node(15))
s.push(Node(18))
s.push(Node(2))whileTrue:
a=s.pop()if a !=None:printa.datacontinue
else:break
Queue类--实现1(推荐)
classQueue(object):def __init__(self):
self.__queue =[]defis_empty(self):return not bool(len(self.__queue))defpeek(self):
if len(self.__queue)>0:return self.__stack[0]defenqueue(self,node):
self.__queue.append(node)defdequeue(self):if len(self.__queue)>0:return self.__queue.pop(0)defget_length(self):return len(self.__queue)
Queue类--实现2(不建议使用)
classQueue(list):defis_empty(self):return notbool(len(self))defpeek(self):
if len(self)>0returnself[0]defenqueue(self,node):
self.append(node)defdequeue(self,node):if len(self)>0:returnself.pop(0)defget_length(self):return len(self)
BST类(二叉树类)
我们一般很少用一般二叉树，而是用进一步约束的二叉树，如二叉搜索树、红黑树等，这些树是一般二叉树的子类，
所以二叉树有的方法，这些方法都可以有。
classNode(object):def __init__(self,data):
self.data=data
self.__left =None
self.__right =None
self.__parent =None
@propertydefleft(self):return self.__left@left.setterdefleft(self,node):if node is None or type(node) isNode:
self.__left =nodeif type(node) isNode:
node.parent=selfelse:raise Exception,'left node must be None or Node type'@propertydefright(self):return self.__right@right.setterdefright(self,node):if node is None or type(node) isNode:
self.__right =nodeif type(node) isNode:
node.parent=selfelse:raise Exception,'right node must be None or Node type'@propertydefparent(self):return self.__parent@parent.setterdefparent(self,node):if node is None or type(node) isNode:
self.__parent =nodeelse:raise Exception,'parent node must be None or Node type'
classBST(object):def __init__(self):
self.__root =None
@propertydefroot(self):return self.__root@root.setterdefroot(self,node):if node is None or type(node) isNode:
self.__root =nodeif type(node) isNode:
node.parent=Noneelse:raise Exception,'parent node must be None or Node type'
defpre_order(self,node):#递归结束点
if node ==None:return[]#分支结点
data =[node.data]
left=self.pre_order(node.left)
right=self.pre_order(node.right)return data +left +rightdefin_order(self,node):if node ==None:return[]
left=self.pre_order(node.left)
data=[node.data]
right=self.pre_order(node.right)return left + data +rightdefpost_order(self,node):if node ==None:return[]
left=self.pre_order(node.left)
right=self.pre_order(node.right)
data=[node.data]return left + right +data#查找以node为根结节的树的最大关键值节点
deffind_max(self,node):if node ==None:returnNone
p=nodewhileTrue:if p.right !=None:
p=p.rightcontinue
else:break
returnpdeffind_min(self,node):if node ==None:returnNone
p=nodewhileTrue:if p.left !=None:
p=p.leftcontinue
else:break
returnpdefsearch(self,node,key):#跟二分查找的递归方式非常像
#结束点
if node ==None:returnNone#分支节点
if key ==node.data:returnnodeif key >node.data:returnself.search(node.right,key)else:returnself.search(node.left,key)definsert(self,root,new_node):#结束点
if new_node.data >root.data:if root.right ==None:
root.right=new_nodereturnTrueif new_node.data ==root.data:returnFalseif new_node.data 
root.left=new_nodereturnTrue#分支节点
if new_node.data >root.data:if root.right !=None:
branch_ret=self.insert(root.right,new_node)if new_node.data 
branch_ret=self.insert(root.left,new_node)returnbranch_retdefdelete(self,node):#这个方法比较繁琐，有空再写
pass

想学好编程，数据结构是一定要学好的，不仅仅是结构，每一种结构里面会有几种算法，这些算法包涵了程序员不同的思想。

好的思想能想出好的好的算法。

如果你深入地理解了这些思想，那你就可以自己构思算法了。

什么是数据结构？什么是数据逻辑结构？学过一点数据结构的朋友都知道，数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。常用的数据结构分成八种。
分别是：数组，栈，链表，队列，树，图，堆，散列表，每一种数据结构都有着独特的数据存储方式。
数据结构就讲这么多，下面让我们回到题目，来浅谈下令人抓狂的—— 数据逻辑结构。



数据的逻辑结构有三种：

线性结构、图结构、树结构


在数据结构中,从逻辑上可以将其分为线性结构和非线性结构数据结构的基本操作的设置的最重要的准则是,实现应用程序与存储结构的独立。

实现应用程序是“逻辑结构”，存储的是“物理结构”。
逻辑结构主要是对该结构操作的设定，物理结构是描述数据具体在内存中的存储（如：顺序结构、链式结构、索引结构、希哈结构）等。
这在顺序存储结构中，线性表的逻辑顺序和物理顺序总是一致的。但在链式存储结构中，线性表的逻辑顺序和物理顺序一般是不同的。


算法的五个特性： 有穷性、确定性、可行性、输入、输出

好的算法要做到算法设计要求要有正确性、可读性、健壮性、高效率与低存储量等需求。

常用的数据结构
数据结构
研究对象
数据的逻辑结构
数据的物理结构
数据存储结构
分类
线性结构
非线性结构
常用的数据结构
数组(Array)
栈( Stack)
队列(Queue)
链表( Linked List)
树( Tree)
图(Graph)
堆(Heap)
散列表(Hash)

数据结构
数据结构(data structure)是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。简而言之，数据结构是相互之间存在一种或多种特定关系的数据元素的集合，即带“结构”的数据元素的集合。“结构”就是指数据元素之间存在的关系，分为逻辑结构和存储结构。
数据的逻辑结构和物理结构是数据结构的两个密切相关的方面，同一逻辑结构可以对应不同的存储结构。算法的设计取决于数据的逻辑结构，而算法的实现依赖于指定的存储结构。
数据结构的研究内容是构造复杂软件系统的基础，它的核心技术是分解与抽象。通过分解可以划分出数据的3个层次；再通过抽象，舍弃数据元素的具体内容，就得到逻辑结构。类似地，通过分解将处理要求划分成各种功能，再通过抽象舍弃实现细节，就得到运算的定义。上述两个方面的结合可以将问题变换为数据结构。这是一个从具体（即具体问题）到抽象（即数据结构）的过程。然后，通过增加对实现细节的考虑进一步得到存储结构和实现运算，从而完成设计任务。这是一个从抽象（即数据结构）到具体（即具体实现）的过程。
研究对象
数据的逻辑结构
指反映数据元素之间的逻辑关系的数据结构，其中的逻辑关系是指数据元素之间的前后件关系，而与他们在计算机中的存储位置无关。逻辑结构包括：
1.集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系；
2.线性结构：数据结构中的元素存在一对一的相互关系；  
3.树形结构：数据结构中的元素存在一对多的相互关系； 
4.图形结构：数据结构中的元素存在多对多的相互关系。 

数据的物理结构
指数据的逻辑结构在计算机存储空间的存放形式。
数据的物理结构是数据结构在计算机中的表示（又称映像），它包括数据元素的机内表示和关系的机内表示。由于具体实现的方法有顺序、链接、索引、散列等多种，所以，一种数据结构可表示成一种或多种存储结构。
数据元素的机内表示（映像方法）： 用二进制位（bit）的位串表示数据元素。通常称这种位串为节点（node）。当数据元素有若干个数据项组成时，位串中与个数据项对应的子位串称为数据域（data field）。因此，节点是数据元素的机内表示（或机内映像）。
关系的机内表示（映像方法）：数据元素之间的关系的机内表示可以分为顺序映像和非顺序映像，常用两种存储结构：顺序存储结构和链式存储结构。顺序映像借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系。非顺序映像借助指示元素存储位置的指针（pointer）来表示数据元素之间的逻辑关系。
数据存储结构
数据的逻辑结构在计算机存储空间中的存放形式称为数据的物理结构(也称为存储结构)。一般来说，一种数据结构的逻辑结构根据需要可以表示成多种存储结构，常用的存储结构有顺序存储、链式存储、索引存储和哈希存储等。

数据的存储结构的特点是：借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系；非顺序存储的特点是：借助指示元素存储地址的指针表示数据元素之间的逻辑关系。
分类
数据结构有很多种，一般来说，按照数据的逻辑结构对其进行简单的分类，包括线性结构和非线性结构两类。
线性结构
简单地说，线性结构就是表中各个结点具有线性关系。如果从数据结构的语言来描述，线性结构应该包括如下几点：
1、线性结构是非空集。  
2、线性结构有且仅有一个开始结点和一个终端结点。  
3、线性结构所有结点都最多只有一个直接前趋结点和一个直接后继结点。 

线性表就是典型的线性结构，还有栈、队列和串等都属于线性结构。
非线性结构
简单地说，非线性结构就是表中各个结点之间具有多个对应关系。如果从数据结构的语言来描述，非线性结构应该包括如下几点：
1、非线性结构是非空集。
2、非线性结构的一个结点可能有多个直接前趋结点和多个直接后继结点。

在实际应用中，数组、广义表、树结构和图结构等数据结构都属于非线性结构。
常用的数据结构
在计算机科学的发展过程中，数据结构也随之发展。目前，程序设计中常用的数据结构包括如下几个。
数组(Array)
数组是一种聚合数据类型，它是将具有相同类型的若干变量有序地组织在一起的集合。数组可以说是最基本的数据结构，在各种编程语言中都有对应。一个数组可以分解为多个数组元素，按照数据元素的类型，数组可以分为整型数组、字符型数组、浮点型数组、指针数组和结构数组等。数组还可以有一维、二维以及多维等表现形式。
栈( Stack)
栈是一种特殊的线性表，它只能在一个表的一个固定端进行数据结点的插入和删除操作。栈按照后进先出的原则来存储数据，也就是说，先插入的数据将被压入栈底，最后插入的数据在栈顶，读出数据时，从栈顶开始逐个读出。栈在汇编语言程序中，经常用于重要数据的现场保护。栈中没有数据时，称为空栈。
队列(Queue)
队列和栈类似，也是一种特殊的线性表。和栈不同的是，队列只允许在表的一端进行插入操作，而在另一端进行删除操作。一般来说，进行插入操作的一端称为队尾，进行删除操作的一端称为队头。队列中没有元素时，称为空队列。
链表( Linked List)
链表是一种数据元素按照链式存储结构进行存储的数据结构，这种存储结构具有在物理上存在非连续的特点。链表由一系列数据结点构成，每个数据结点包括数据域和指针域两部分。其中，指针域保存了数据结构中下一个元素存放的地址。链表结构中数据元素的逻辑顺序是通过链表中的指针链接次序来实现的。
树( Tree)
树是典型的非线性结构，它是包括，2个结点的有穷集合K。在树结构中，有且仅有一个根结点，该结点没有前驱结点。在树结构中的其他结点都有且仅有一个前驱结点，而且可以有聊个后继结点，m≥0。
图(Graph)
图是另一种非线性数据结构。在图结构中，数据结点一般称为顶点，而边是顶点的有序偶对。如果两个顶点之间存在一条边，那么就表示这两个顶点具有相邻关系。
堆(Heap)
堆是一种特殊的树形数据结构，一般讨论的堆都是二叉堆。堆的特点是根结点的值是所有结点中最小的或者最大的，并且根结点的两个子树也是一个堆结构。
散列表(Hash)
散列表源自于散列函数(Hash function)，其思想是如果在结构中存在关键字和T相等的记录，那么必定在F(T)的存储位置可以找到该记录，这样就可以不用进行比较操作而直接取得所查记录。

数据结构：指的是数据之间的相互关系，包含三个内容：逻辑结构，存储结构和数据的运算

数据的逻辑结构指数据元素之间的逻辑关系，分两种，线性结构和非线性结构。
常用的线性结构有：线性表，栈，队列，双队列，数组，串。

数据结构在计算机中的表示（又称映像）称为数据的物理结构，或称存储结构。
数据的存储结构可采用顺序存储或链式存储的方法。



存储结构是数据的逻辑结构用计算机语言的实现，常见的存储结构有 顺序存储，链式存储，索引存储，以及散列存储。其中散列所形成的存储结构叫散列表（又叫哈希表），因此哈希表也是一种存储结构。
栈只是一种抽象数据类型，是一种逻辑结构，栈逻辑结构对应的顺序存储结构为 顺序栈，对应的链式存储结构为链栈。循环队列是队列的顺序存储结构，链表是线性表的链式存储结构。