数据结构设计 贪吃蛇数据结构设计

#include

数据结构设计 贪吃蛇数据结构设计

数据结构设计 贪吃蛇数据结构设计

#include

typedef struct Lnode{

int data;

struct Lnode next;

}Lnode,LinkList;//定义单链表

void Create_LinkList(LinkList &L, int n)

{L=(LinkList)malloc(sizeof(Lnode));

L->next =NULL;

int j=0;//记录单链表中元素个数

printf("输入链表中的%d个元素:",n);

LinkList q=L;

for(int i=1;i<=n;i++)

{LinkList p=(LinkList)malloc (sizeof(Lnode));

q->next=p;

p->next=NULL;

q=q->next ;

scanf("%d",&p->data);

j++;//记录单链表的长度

}//(正序实现)

}//初始化单链表

void Printf_LinkList(LinkList L)

{LinkList p;

p=L->next;

while(p!=NULL)

{printf("%d ",p->data );

p=p->next;

}printf("

");

}//输出单链表

bool GetElem_LinkList(LinkList &L)

{LinkList temp,p,q;

int diff1 = 0;

int diff2 = 0;

temp=L;

bool flag = true;

if(temp==NULL)

printf("此链表为空！

");

p = temp -> next;

q = temp -> next -> next;

if(q == NULL)//数列中只有一个元素 则数列是等数列

{return true;

}diff1 = q->data - p -> data;

while(q->next!=NULL)

{p = p->next;

q = q->next;

diff2 = q->data - p -> data;

if(diff2 != diff1)

{flag = false;

break;

}}

return flag;

}int main()

{int n;

bool type;

LinkList La;//创建单链表La

printf("请输入数列元素的个数：");

scanf("%d",&n);

Create_LinkList(La,n);//初始化单链表

printf("你输入的数列是：

");

Printf_LinkList(La);//输出单链表

type = GetElem_LinkList(La);

if(type)

{printf("此数列是等数列。

");

}if(!type)

{printf("此数列不是等数列。

");

}return 0;

}/运行结果

请输入数列元素的个数：8

输入链表中的8个元素:1 2 3 4 5 6 7 8

你输入的数列是：

1 2 3 4 5 6 7 8

此数列是等数列。

请输入数列元素的个数：6

输入链表中的6个元素:1 2 3 4 5 8

你输入的数列是：

1 2 3 4 5 8

此数列不是等数列。

请输入数列元素的个数：1

输入链表中的1个元素:66

你输入的数列是：

66

此数列是等数列。

/ 希望能对你有所帮助，望采纳！！！

数据结构课程目的：基本掌握面向对象程序设计的基本思路和方法

数据结构课程意义 ：数据结构课程设计是《数据结构》理沦课的必要补 充，是复习和检验前期所学课程的重要手段，也是为毕业设计做必要的准备。

文件数据结构设计？

首先想清楚什么数据存内存，什么数据存文件。

一般来讲，参与逻辑运算的标志位，中间变量，计数器存内存；需要显示的东西、实时的东西先存内存，挑选你要存文件的东西存文件；存内存的意思是当进程结束这些东西都会被释放回收。

给用户设置参数的配置信息存文件，还有需要查看的历史信息存文件。

存在哪里这个基本不需要考虑吧，开始你就存在工程目录下比较方便，这样打开和保存的时候都不需要写路径。

至于存什么格式的文件无关紧要，关键是搞好读取文件的方式，然后就存成txt好了。有段时间我下电影经常下到PDF格式的电影，几个G的PDF你敢信？然后直接用播放器播放一样能看。

数据结构中，逻辑上（逻辑结构：数据元素之间的逻辑关系）可以把数据结构分成线性结构和非线性结构。线性结构的顺序存储结构是一种随机存取的存储结构，线性表的链式存储结构是一种顺序存取的存储结构。线性表若采用链式存储表示时所有结点之间的存储单元地址可连续可不连续。逻辑结构与数据元素本身的形式、内容、相对位置、所含结点个数都无关。

算法的设计取决于数据（逻辑）结构，而算法的实现依赖于采用的存储结构。数据的运算是在数据的逻辑结构上定义的作算法，如检索、插入、删除、更新的排序等。

数据结构课程设计是什么

一个软件系统框架应建立在数据之上，而不是建立在作之上。一个含抽象数据类型的软件模块应包含定义、表示、实现三个部分。

对每一个数据结构而言，必定存在与它密切相关的一组作。若作的种类和数目不同，即使逻辑结构相同，数据结构能起的作用也不同。

不同的数据结构其作集不同，但下列作必不可缺：

1. 结构的生成；

2. 结构的销毁；

3. 在结构中查找满足规定条件的数据元素；

4. 在结构中插入新的数据元素；

5. 删除结构中已经存在的数据元素；

6. 遍历。

抽象数据类型：一个数学模型以及定义在该模型上的一组作。抽象数据类型实际上就是对该数据结构的定义。因为它定义了一个数据的逻辑结构以及在此结构上的一组算法。抽象数据类型可用以下三元组表示：（D，S，P）。D是数据对象，S是D上的关系集，P是对D的基本作集。ADT的定义为：

ADT 抽象数据类型名{

数据对象：（数据元素）

数据关系：（数据关系二元组结合）

基本作：（作函数的罗列）

} ADT 抽象数据类型名;

抽象数据类型有两个重要特性：

数据抽象

o 用ADT描述程序处理的实体时，强调的是其本质的特征、其所能完成的功能以及它和外部用户的接口（即外界使用它的方法）。

数据封装

o 将实体的外部特性和其内部实现细节分离，并且对外部用户隐藏其内部实现细节。

数据结构中，逻辑上（逻辑结构：数据元素之间的逻辑关系）可以把数据结构分成线性结构和非线性结构。线性结构的顺序存储结构是一种随机存取的存储结构，线性表的链式存储结构是一种顺序存取的存储结构。线性表若采用链式存储表示时所有结点之间的存储单元地址可连续可不连续。逻辑结构与数据元素本身的形式、内容、相对位置、所含结点个数都无关。

算法的设计取决于数据（逻辑）结构，而算法的实现依赖于采用的存储结构。数据的运算是在数据的逻辑结构上定义的作算法，如检索、插入、删除、更新的排序等。

数据结构的形式定义为：数据结构是一个二元组：

Data-Structure=(D，S)

其中：D是数据元素的有限集，S是D上关系的有限集。

数据结构不同于数据类型，也不同于数据对象，它不仅要描述数据类型的数据对象，而且要描述数据对象各元素之间的相互关系。

数据结构设计及用法说明就是给出你所设计的数据结构以及怎么使用。

你要给出数据结构的定义：包含是类型，注释等信息。例如

struct

student{

string

name;//学生姓名

int

age;//学生年龄

int

grade;//学生所在年级

int

class;//学生所在班级

}然后如果是函数的话，就给出参数的含义，以及这个函数实现的功能，例如

int

sum(int

a,int

b)//返回值int型，对参数a和参数b进行求和运算

{......

}简单的说就是为了使你写的东西让其他人也能使用，能理解你的思想。

这个很好办啊，你可以在加个存放店名的表啊，店名表里面有一个主键和各个店的店名，在你的原表上加一项“商品所在店”字段。把店名表的主键放到这个字段里面。以后你只要修改这个字段的内容就好了。哪怕你移动了n家店。也不存在任何问题啊。

我的意思就是你用个表结合就好。

select 主键

form 店名表

where 商品所在店=要移动的店名

搜索出来的数据放到你张表加的“商品所在店”字段

就好了。哪怕你移动一万家店也不会有问题啊，只要你在店名表里面加店名就好了。明白了吗。

1.//存储结构：deque

//多项式相加的基本过程：(1)、两个多项式的次幂较高的那个，存入endPower；

// (2)、从ix=0开始，对多项式的对应项做运算；

// (3)、递增，如果ix>=endPower，结束；否则，重复2和3。

#include

#include

using namespace std;

class Expression {

public:

Expression() { int highestPower=0; factors=deque(0.0); }

~Expression() { factors.clear(); }

bool create();

void display();

Expression &add( Expression &another );

Expression &subtract( Expression &another );

int HighestPower() const;

double Factor( int index ) const;

private:

int highestPower; //次幂

deque factors; //系数（从次幂~0的系数都保存，如果某次幂不存在，则系数为0）

};

bool

Expression::

create() {

cout<<"Enter the highest power: ";

cin>>highestPower;

double dTemp;

for( int ix=highestPower; ix>=0; --ix ) {

cout<<"Enter the factor of x^"<

cin>>dTemp;

factors.push_front( dTemp );

}return true;

}void

Expression::

display() {

for( int ix=highestPower; ix>=0; --ix ) {

if( ix0 )

cout<<"+";

if( factors.at(ix)!=0 ) {

cout<

if( ix>0 )

cout<<"x"<<"^"<

}}

cout<

}Expression &

Expression::

add( Expression &another ) {

int endPower = (highestPower>another.HighestPower()) ? highestPower : another.HighestPower();

for( int ix=0; ix<=endPower; ++ix ) {

if( ix>highestPower ) {

factors.push_back( another.Factor(ix) );

highestPower=ix;

} else if( ix<=another.HighestPower() ){

factors.at(ix) += another.Factor(ix);

}}

return this;

}Expression &

Expression::

subtract( Expression &another ) {

int endPower = (highestPower>another.HighestPower()) ? highestPower : another.HighestPower();

for( int ix=0; ix<=endPower; ++ix ) {

if( ix>highestPower ) {

factors.push_back( (-1)another.Factor(ix) );

highestPower=ix;

} else if( ix<=another.HighestPower() ){

factors.at(ix) -= another.Factor(ix);

}}

return this;

}int

Expression::

HighestPower() const {

return highestPower;

}double

Expression::

Factor( int index ) const {

return factors.at(index);

}int main() {

Expression aExpression, bExpression;

if( aExpression.create() )

aExpression.display();

if( bExpression.create() )

bExpression.display();

cout<<"aExpression.add( bExpression ): "<

aExpression.add( bExpression );

aExpression.display();

cout<<"aExpression.subtract( bExpression ): "<

aExpression.subtract( bExpression );

aExpression.display();

}2.char a;

int m;

cout<<"输入猴子个数:"<

cin>>m;

a=new char[m];

cout<<"输入N:"<

int n;

cin>>n;

if(n>m)

{cout<<"输入错误,必须小于M="<

cin>>n;

}for(int i=0;i

{a[i]=1;

}bool c=true;

for (int j=0;;j++)

{for(int k=0;k

{if(a[k]!=0)

{c=false;

break;

}else c=true;

}if(c!=true)//判断退出

break;

if(j%n==0)

a[j%m]=0;

}int result=j%m;

cout<<"猴子的序号是:"<

---------------2-----------------

insert(int arry[],int address,int data)

{int l=arry.length();

for(int i=l-1;i>address;i--)

{arry[i]=arry[i-1];

}arry[i]=data;

}sort01(int a[])

{int temp;

int l=a.length();

temp=a[0];

for(int i=1;i

{if(a[i]

insert(a,i-1,temp);

temp=a[i];

}}

------------------------------------

swap(int x,int y)

{int temp;

temp=x;

y=temp

x=y;

}l=a.length;

temp1=a[0];temp2=a[1];

for(int k=0;k

for(int i=k;i

{if(a[i]>a[i+1])

swap(a[i],a[i+1);

}3.//二叉树

struct node {

int key;

node left;

node right;

};

//链表

struct list {

node data;

list next;

};

//队列

struct queue {

list front;

int count;

list rear;

};

//Enqueue for Breadth-First Trersal

queue BST::_enqueue (queue Q, node n) //进队

{list pNew = new list;

pNew->data = n;

pNew->next = NULL;

if (Q->count == 0)

Q->front = pNew;

else

Q->rear->next = pNew;

Q->rear = pNew;

Q->count++;

return Q;

}//Dequeue for Breadth-First Trersal

node BST::_dequeue (queue &Q) //出队

{if (Q->count == 1)

Q->rear = NULL;

list pDel = Q->front;

node temp = pDel->data;

Q->front = Q->front->next;

Q->count--;

delete pDel;

pDel = NULL;

return temp;

}//Breadth-First Trersal (层序遍历）

void BST::_trerse (const node T)

{queue Q = new queue;

Q->front = Q->rear = NULL;

Q->count = 0;

while (T != NULL)

{cout << T->key << " ";

if (T->left != NULL)

Q = _enqueue (Q, T->left); //左孩子进队

if (T->right != NULL)

Q = _enqueue (Q, T->right); //右孩子进队

if (Q->count != 0) //排队输出下一个将要处理的

T = _dequeue (Q);

else //队列为空，跳出

T = NULL;

}return ;

}你看看这个行不

感性和理性是一对相对立的概念，理性是什么？就是相信在纷繁复杂的事物运动背后，隐藏着一种不变的普适的规律。这种规律可以解释这些运动和变化。理性是对感性认识的加工，以达到把握感性对象本质的过程。理性分裂了现象和本质。认为现象背后有更“实在”的本质。理性认为人类应该追求的是这个更实在的东西。

理性是在道德，公共秩序，文化教育的熏陶中慢慢形成的。人受的教育程度越高，应该理性成份越多，而感性的时候越少。

理性认识是认识的高级阶段，是人们对事物的主体、本质和内部联系的反映。理性认识包括概念、判断、推理三种形式。理性认识的特点是间接性和抽象性。

西蒙曾为《科学辞典》专门撰写了“理性”条目。对经济学理性概念作了这样的说明：

1、广义而言，理性指一种行为方式，它(a)适合实现指定目标，(b)而且在给定条件和约束的限度之内。

2、在某些特殊场合下，这个定义的(a)(b)两方面可以有更精细的规定。这类特殊用法中的重要者包括:(a)目标可定是效用函数期望值在某一时间区域上极大化的形式(对策论称此为极小极大化)。效用函数的存在性，可从决策者偏好的有序性和一致性定上导出。形式化的经济理论就是这样认为合理消费者谋求期望效用而合理企业家谋求期望利润的。如果要使这种极其严格的形式区别于更一般的形式，则可将前者称为性，称后者为适应性或功能性。(b)目标可定是意欲达到的一些准则所构成的，但要么全部达到，要么全部达不到(例如欲望水平的达成)。(c)条件和约束的一般定义，可指决策者的外部环境的客观特征，可指该环境被感知到的特征，也可指以固定形式出现的、不受自身支配的抉择者自身特征。我们有时通过区分客观理性和主观理性及有限理性，来区别上述种定义和后两种定义。(d)定义中的所谓目标，可以是抉择者的目标，抉择者所属系统的目标，或观察者的目标。(e)毫不含糊地使用理性一词，要求使用者讲清楚他对目标和条件这两者所做的定。

总之，“经济学家一般用理性一词表示靠抉择过程挑选出来的行动方案的属性，而不是表示抉择过程的属性。达尔和林德布鲁姆这样说道：‘一项行为是理性的，就是说，对于指定目标及其真实处境说，该行动被‘正确性’设计成为一种能谋求成功的行动’。

理性概念是哲学与经济学两大学科的重要基石，也是理解西方近代古典文化传统不可或缺的概念性工具。随着20世纪人类对理性文化传统的批判与解构，理性概念及其文化形态受到了哲学、学、法学、学、宗教学和文学等领域的查审。

在哲学的工具书上，理性通常被定义为一种人所具有的探索真理的能力，或达到真理认识的某一认识阶段。早在古希腊时期，哲学家赫拉克利特就曾指出，由于自然的真理“躲藏”在事物之中，因此唯有人的“思想”而不是感觉才能获得真理。赫拉克利特的“思想”相当于“理性”。最早明确提出理性概念的是阿那科萨哥拉。他认为“物的‘种子’是存在物的始基。”人的感官只能认识具体的事物，唯有理性是截示“始基”的可靠工具。斯多葛派把理性视为神的属性和人的本性。近代唯理论认为，理性是知识的源泉，只有理性才是可信赖的。18世纪法国哲学家将理性概念从认识论引申到领域，认为凡是合乎自然、合乎人性的就是理性。理性成为衡量一切存在的价值尺度。