数据结构基础题目代码

#include

typedef struct Node

{

char data[100];

struct Node *pNext;

}NODE, *PNODE;

PNODE create_list(void);

void traverse_list(PNODE pHead);

int main(void)

{

PNODE pHead=NULL;

pHead=create_list();

traverse_list(pHead);

return 0;

}

PNODE create_list(void)

{

int len;

int i;

char val[100];

PNODE pHead=(PNODE)malloc(sizeof(NODE));

PNODE pTail=pHead;

scanf("%d",&len);

for(i=0;i

{

scanf("%s",val);

PNODE pNew=(PNODE)malloc(sizeof(NODE));

strcpy(pNew->data,val);

pTail->pNext=pNew;

pTail=pNew;

pTail->pNext=NULL;

}

return pHead;

}

void traverse_list(PNODE pHead)

{

PNODE p=pHead->pNext;

while(NULL !=p)

{

printf("%s ",p->data);

p=p->pNext;

}

#include

typedef struct nixu

{

int data;

struct nixu *next;

} lb;

lb *tou()

{

lb *L;

L=(lb *)malloc(sizeof(lb));

L->next=NULL;

return L;

}

void get(lb *l)

{

lb *L,*h;

int x;

L=l;

int i,len;

scanf("%d",&len);

for(i=0;i

{

scanf("%d",&x);

h=(lb *)malloc(sizeof(lb));

h->data=x;

h->next=L->next;

L->next=h;

}

void put(lb *l)

{

lb *L;

L=l;

while(L->next!=NULL)

{

printf("%d ",L->next->data);

L=L->next;

}

printf("\n");

}

main()

{

lb *a;

a=tou();

get(a);

put(a);

}

//链表排序

#include

//链表节点的数据结构typedef struct list

{

int data;

struct list *link; }list,*LinkPtr;

//声明函数

LinkPtr create_list(void); void traverse_list(); LinkPtr SelectSort2(void);

int main(void)

{

create_list();

SelectSort2();

traverse_list(); }

LinkPtr L=NULL;

//创建无头结点的单链表LinkPtr create_list(void) {

LinkPtr head,p,q;

int length,i,val;

//printf("自定义链表节点数\nm=");

scanf("%d",&length);

p=head=(list *)malloc(sizeof(list));

scanf("%d",&val);

head->data=val;

head->link=NULL;

for(i=1;i

{

q=(list *)malloc(sizeof(list));

scanf("%d",&val);

q->data=val;

q->link=NULL;

p->link=q;

p=q;

/*if(i==0)

{

L=p;

q=p;

i++;

continue;

}*/

// q=(list *)malloc(sizeof(list)); // q->link=p;

// q=p;

}

L=head;

}

LinkPtr SelectSort2(void)

{

LinkPtr X=L;

LinkPtr p,q,small;

int temp;

for(p = X; p->link != NULL; p = p->link)

{

small = p;

for(q = p->link; q; q = q->link)

{

if(q->data < small->data)

{

small = q;

}

//printf("循环后，获得最小值为:%d, 此时链表为:", small->data);

if(small != p)

{

temp = p->data;

p->data = small->data;

small->data = temp;

}

//traverse_list();

}

// printf("输出排序后的数字:\n");

return X;

}

//输出链表

void traverse_list()

{

LinkPtr p=L;

while(NULL !=p)

{

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

p=p->link;

}

//链表查询

#include

//链表节点的数据结构

typedef struct list

{

int data;

struct list *link;

} list,*LinkPtr;

//声明函数

LinkPtr create_list(void);

void traverse_list();

LinkPtr SelectSort2(void);

int main(void)

{

create_list();

SelectSort2();

traverse_list();

}

LinkPtr L=NULL;

LinkPtr SelectSort2()

{

LinkPtr list=L;

LinkPtr p,q,pre;

//p=list->link;

// p=list;

// pre=list;

// q=p;

q=pre=list;

//p是用来指向当前结点

//q是用来保存最小值结点

p=list->link;//p现在指向第二个结点

while(p!=NULL)//p不为空则继续循环

{

if(p->datadata)//当前结点值小于q

{

pre->link=p->link;//前结点连接当前的结点的下一值

q=p;//更新q指向

}

p=p->link;

}

//printf("最小值%d\n",q->data);

//最小值插入到第一位

if(q!=list)//如果q不是第一结点

{

q->link=list;//让q的下结点为原开头则q就是新开头

L=q;//更新链表开头为q

}

//创建无头结点的单链表

LinkPtr create_list(void)

{

LinkPtr head,p,q;

int length,i,val;

//printf("自定义链表节点数\nm=");

scanf("%d",&length);

p=head=(list *)malloc(sizeof(list));

scanf("%d",&val);

head->data=val;

head->link=NULL;

for(i=1; i

{

q=(list *)malloc(sizeof(list));

scanf("%d",&val);

q->data=val;

q->link=NULL;

p->link=q;

p=q;

}

L=head;

}

//输出链表

void traverse_list()

{

LinkPtr p=L;

while(NULL !=p)

{

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

p=p->link;

}

//链表排序

#include

//链表节点的数据结构

typedef struct list

{

int data;

struct list *link;

}list,*LinkPtr;

//声明函数

LinkPtr create_list(void);

void traverse_list();

LinkPtr SelectSort2(void);

int main(void)

{

create_list();

SelectSort2();

traverse_list();

}

LinkPtr L=NULL;

//创建无头结点的单链表

LinkPtr create_list(void)

{

LinkPtr head,p,q;

int length,i,val;

//printf("自定义链表节点数\nm=");

scanf("%d",&length);

p=head=(list *)malloc(sizeof(list));

scanf("%d",&val);

head->data=val;

head->link=NULL;

for(i=1;i

{

q=(list *)malloc(sizeof(list));

scanf("%d",&val);

q->data=val;

q->link=NULL;

p->link=q;

p=q;

/*if(i==0)

{

L=p;

q=p;

i++;

continue;

}*/

// q=(list *)malloc(sizeof(list));

// q->link=p;

// q=p;

}

L=head;

}

LinkPtr SelectSort2(void)

{

LinkPtr X=L;

LinkPtr p,q,small;

int temp;

for(p = X; p->link != NULL; p = p->link)

{

small = p;

for(q = p->link; q; q = q->link)

{

if(q->data < small->data)

{

small = q;

}

//printf("循环后，获得最小值为:%d, 此时链表为:", small->data);

if(small != p)

{

temp = p->data;

p->data = small->data;

small->data = temp;

}

//traverse_list();

}

// printf("输出排序后的数字:\n");

return X;

}

//输出链表

void traverse_list()

{

LinkPtr p=L;

while(NULL !=p)

{

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

p=p->link;

}

//链表合并

#include

typedef struct node

{

int data;

struct node *next;

}NODE,*PNODE;

PNODE create();

void lianbiaohebing(NODE *pa,NODE *pb);

void print(NODE *head);

void SelectSort2(NODE *head);

main()

{

NODE *la,*lb;

la=create();

lb=create();

lianbiaohebing(la,lb);

//print(la);

SelectSort2(la);

print(la);

}

//排序算法

void SelectSort2(NODE *head)//降序排列不能实现。{

PNODE X=head->next;

PNODE p,q,big;

int temp;

for(p = X; p->next != NULL; p = p->next)

{

big = p;

for(q = p->next; q; q = q->next)

{

if(q->data > big->data)

{

big = q;

}

if(big != p)

{

temp = p->data;

p->data = big->data;

big->data = temp;

}

return X;

}

PNODE create()

{

PNODE p,q,head;

int a,n;

scanf("%d",&n);

head=(PNODE *)malloc(sizeof(NODE));

q=head;

while(n>0)

{

scanf("%d",&a);

p=(PNODE *)malloc(sizeof(NODE));

p->data=a;

q->next=p;

q=p;

n--;

}

p->next=NULL;

return (head);

}

void lianbiaohebing(NODE *la,NODE *lb)

{

NODE *pa,*pb,*q;

pa=la->next;

pb=lb->next;

while(pa&&pb)

{

if(pa->data<=pb->next)//把数据与指针相比较？这句话不懂。。

{

q->next=pa;

q=pa;

pa=pa->next;

}

else

{

q->next=pb;

q=pb;

pb=pb->next;

}

q->next=(pa?pa:pb);

free(lb);

}

void print(NODE *head)

{

NODE *a;

a=head->next;

while(a!=NULL)

{

printf("%d ",a->data);

a=a->next;

}

#include

typedef int datatype;

typedef struct node

{

datatype data;

struct node *next;

}linknode,*linklist;

typedef node ;

void print(linklist head)

{

linklist p;

p=head->next;

while(p)

{

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

p=p->next;

}

printf("\n");

}

linklist creat()

{

linklist head,s,p;

datatype x;

head=p=(linklist)malloc(sizeof(linknode));

scanf("%d",&x);

while(getchar()!='\n')

{

s=(linklist)malloc(sizeof(linknode));

s->data=x;

p->next=s;

p=s;

scanf("%d",&x);

}

p->next=NULL;

return head;

}

linklist jiaoji(linklist head1,linklist head2)//求两个集合的交集{

linklist p,q,head,r,pre,s;

head=r=(linklist)malloc(sizeof(linknode));

p=head1->next;

while(p)

{

q=head2->next;

while(q)

{

if(p->data==q->data)

{

s=(linklist)malloc(sizeof(linknode));

s->data=p->data;

r->next=s;

r=s;

break;

}

q=q->next;

}

p=p->next;

}

r->next=NULL;

return head;

}

int main()

{

linklist head1,head2,head3; head1=creat();

head2=creat();

head3=jiaoji(head1,head2); print(head3);

return 0;

}

11.2号

数据结构课程实验指导书

数据结构实验指导书一、实验目的《数据结构》是计算机学科一门重要的专业基础课程，也是计算机学科的一门核心课程。本课程较为系统地论述了软件设计中常用的数据结构以及相应的存储结构与实现算法，并做了相应的性能分析和比较，课程内容丰富，理论系统。本课程的学习将为后续课程的学习以及软件设计水平的提高打下良好的基础。由于以下原因，使得掌握这门课程具有较大的难度： 1）理论艰深，方法灵活，给学习带来困难； 2）内容丰富，涉及的知识较多，学习有一定的难度； 3）侧重于知识的实际应用，要求学生有较好的思维以及较强的分析和解决问题的能力，因而加大了学习的难度；根据《数据结构》课程本身的特性，通过实验实践内容的训练，突出构造性思维训练的特征，目的是提高学生分析问题，组织数据及设计大型软件的能力。课程上机实验的目的，不仅仅是验证教材和讲课的内容，检查自己所编的程序是否正确，课程安排的上机实验的目的可以概括为如下几个方面：（1）加深对课堂讲授内容的理解实验是对学生的一种全面综合训练。是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节。通常，实验题中的问题比平时的习题复杂得多，也更接近实际。实验着眼于原理与应用的结合点，使学生学会如何把书上学到的知识用于解决实际问题，培养软件工作所需要的动手能力；另一方面，能使书上的知识变" 活" ，起到深化理解和灵活掌握教学内容的目的。不少学生在解答习题尤其是算法设计时，觉得无从下手。实验中的内容和教科书的内容是密切相关的，解决题目要求所需的各种技术大多可从教科书中找到，只不过其出

现的形式呈多样化，因此需要仔细体会，在反复实践的过程中才能掌握。 (2) 培养学生软件设计的综合能力平时的练习较偏重于如何编写功能单一的" 小" 算法，而实验题是软件设计的综合训练，包括问题分析、总体结构设计、用户界面设计、程序设计基本技能和技巧，多人合作，以至一整套软件工作规范的训练和科学作风的培养。通过实验使学生不仅能够深化理解教学内容，进一步提高灵活运用数据结构、算法和程序设计技术的能力，而且可以在需求分析、总体结构设计、算法设计、程序设计、上机操作及程序调试等基本技能方面受到综合训练。实验着眼于原理与应用的结合点，使学生学会如何把书本上和课堂上学到的知识用于解决实际问题，从而培养计算机软件工作所需要的动手能力。 (3) 熟悉程序开发环境，学习上机调试程序一个程序从编辑，编译，连接到运行，都要在一定的外部操作环境下才能进行。所谓" 环境" 就是所用的计算机系统硬件，软件条件，只有学会使用这些环境，才能进行程序开发工作。通过上机实验，熟练地掌握程序的开发环境，为以后真正编写计算机程序解决实际问题打下基础。同时，在今后遇到其它开发环境时就会触类旁通，很快掌握新系统的使用。完成程序的编写，决不意味着万事大吉。你认为万无一失的程序，实际上机运行时可能不断出现麻烦。如编译程序检测出一大堆语法错误。有时程序本身不存在语法错误，也能够顺利运行，但是运行结果显然是错误的。开发环境所提供的编译系统无法发现这种程序逻辑错误，只能靠自己的上机经验分析判断错误所在。程序的调试是一个技巧性很强的工作，尽快掌握程序调试方法是非常重要的。分析问题，选择算法，编好程序，只能说完成一半工作，另一半工作就是调试程序，运行程序并得到正确结果。二、实验要求常用的软件开发方法，是将软件开发过程划分为分析、设计、实现和维护四个阶段。虽然数据结构课程中的实验题目的远不如从实际问题中的复杂程度度高，但为了培养一个软件工作者所应具备的科学工作的方法和作风，也应遵循以下五个步骤来完成实验题目： 1) 问题分析和任务定义在进行设计之前，首先应该充分地分析和理解问题，明确问题要求做什么?限制条件是什么。本步骤强调的是做什么?而不是怎么做。对问题的描述应避开算法和所涉及的数据类型，而是对所需完成的任务作出明确的回答。例如：输入数据的类型、值的范围以及输入的

数据结构题目及c语言代码

目题程设计《数据结构》课)C语言程序实现采用(）：3选王（学时目题1：猴子一堆猴子都有编号，编号是1，2，3 ...m，这群猴子（m个）按照1-m 的顺序围坐一圈，从第1开始数，每数到第n个，该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王。要求：m及n要求从键盘输入，存储方式采用向量及链表两种方式实现该问题求解。 //链表 #include #include // 链表节点 typedef struct _RingNode { int pos; struct _RingNode *next; }RingNode, *RingNodePtr; // 创建约瑟夫环，pHead:链表头指针，count:链表元素个数 void CreateRing(RingNodePtr pHead, int count) { RingNodePtr pCurr = NULL, pPrev = NULL; int i = 1; pPrev = pHead; while(--count > 0) {

pCurr = (RingNodePtr)malloc(sizeof(RingNode)); i++; pCurr->pos = i; pPrev->next = pCurr; pPrev = pCurr; } pCurr->next = pHead; // 构成环状链表 } void KickFromRing(RingNodePtr pHead, int n) { RingNodePtr pCurr, pPrev; int i = 1; // 计数 pCurr = pPrev = pHead; while(pCurr != NULL) { if (i == n) { // 踢出环 printf(\ %d, pCurr->pos); // 显示出圈循序 pPrev->next = pCurr->next;

天津大学数据结构和程序设计考研真题

天津大学数据结构和程序设计考研真题-考研资料- 笔记讲义许多学生在考研复习的时候,都会遇到重点不明确,不知道从何复习的情况。为此,天津考研网建议,考研复习中,专业的考研复习资料,是帮助考生能够快速掌握复习重点及方法必不可少的因素,然后就是真题和讲义,可以让同学了解历年考研的出题方向和大致范围。天津考研网推出了天津大学数据结构和程序设计的考研复习资料及真题解析班,以下为详细介绍: 天津大学数据结构和程序设计考研真题等资料由天津考研网签约的天津大学计算机科学与技术学院高分考研学生历时近一月所作,该考生在考研中取得了专业课129分的好成绩并在复试中更胜一筹,该资料包含该优秀本校考生的考研经验、考研试题解题思路分析、复试流程经验介绍以及针对官方指定参考书的重难要点并根据天津大学本科授课重点整理等,从漫漫初试长路到紧张复试亮剑为各位研友提供全程考研指导攻关。特别说明:此科目06年以前科目名称为数据结构;自06年到08年科目名称改为计算机基础(包含数据结构、程序设计、计算机原理);自09年开始全国统考,科目名称为计算机学科专业基础综合;自2013年开始由学校自主命题,科目名称改为901数据结构与程序设计。第一部分由天津考研网提供的核心复习资料: 天津大学数据结构和程序设计资料编者序言:本文的重点在于C++,数据结构的复习和复试基本情况介绍。C++、数据结构又分别从复习规划,复习用书,重点知识点结合历年考题这四个方面来展开的。复习规划大家务必看一下,然后根据自己的实际情况在制定自己的复习时间,因为内容很多,大多数同学都在考试之前复习不完,在心理因素上就落了一节。重点知识点一定要看了,这些知识点几乎每年都会有题了。另外我还给了历年试题的答案供大家参考。有的答案是自己做的答案,可能会有疏忽的地方。望大家提出宝贵的意见和建议。复试的东西现在了解一下即可,等到进复试了,还是有足够的时间看的。另外我还给了些自己复习心得。考完后感慨很多,回顾了这多半年来自己的成败得失。希望大家从一开始就沿着比较高效的方向前进,减少不必要时间的浪费。本资料格式为A4纸打印版,总量达到了130页

(完整版)数据结构实验报告全集

数据结构实验报告全集实验一线性表基本操作和简单程序 1 ．实验目的（1 ）掌握使用Visual C++ 6.0 上机调试程序的基本方法；（2 ）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。 2 ．实验要求（1 ）认真阅读和掌握和本实验相关的教材内容。（2 ）认真阅读和掌握本章相关内容的程序。（3 ）上机运行程序。（4 ）保存和打印出程序的运行结果，并结合程序进行分析。（5 ）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果实验代码： 1）头文件模块 #include iostream.h>// 头文件 #include// 库头文件------ 动态分配内存空间 typedef int elemtype;// 定义数据域的类型 typedef struct linknode// 定义结点类型 { elemtype data;// 定义数据域 struct linknode *next;// 定义结点指针 }nodetype; 2）创建单链表

nodetype *create()// 建立单链表，由用户输入各结点data 域之值， // 以0 表示输入结束 { elemtype d;// 定义数据元素d nodetype *h=NULL,*s,*t;// 定义结点指针 int i=1; cout<<" 建立一个单链表"<> d; if(d==0) break;// 以0 表示输入结束 if(i==1)// 建立第一个结点 { h=(nodetype*)malloc(sizeof(nodetype));// 表示指针h h->data=d;h->next=NULL;t=h;//h 是头指针 } else// 建立其余结点 { s=(nodetype*) malloc(sizeof(nodetype)); s->data=d;s->next=NULL;t->next=s; t=s;//t 始终指向生成的单链表的最后一个节点

数据结构实验报告代码

线性表代码一 #include "stdio.h" #include "malloc.h" #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef struct { int * elem; int length; int listsize; }SqList; int InitList_Sq(SqList *L) { L->elem = (int*)malloc(LIST_INIT_SIZE*sizeof(int)); if (!L->elem) return ERROR; L->length = 0; L->listsize = LIST_INIT_SIZE; return OK; } int ListInsert_Sq(SqList *L, int i,int e) { int *p,*newbase,*q; if (i < 1 || i > L->length+1) return ERROR; if (L->length >= L->listsize) { newbase = (int *)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof (int)); if (!newbase) return ERROR; L->elem = newbase; L->listsize += LISTINCREMENT; } q = &(L->elem[i-1]); //插入后元素后移for(p=&(L->elem[L->length-1]);p>=q;p--) *(p+1)=*p; *q=e; L->length++; return OK; } int ListDelete_Sq(SqList *L, int i, int *e) {

数据结构：树形结构完整代码,各种遍历方法,直接能跑

#include #include #define TElemType int typedef struct BiTNode { TElemType data; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; typedef BiTree DataType; typedef struct queuenode{ DataType data; struct queuenode *next; } QueueNode; //LINKQUEUE //HEAD POINTER, AND REAR POINTER ARE A V ALIBALE typedef struct { QueueNode *front; QueueNode *rear; } LinkQueue; int InitQueue(LinkQueue *Q); int DestroyQueue(LinkQueue *Q); int QueueEmpty(LinkQueue Q); int EnQueue(LinkQueue *Q, DataType e); DataType DeQueue(LinkQueue *Q); int CreateBiTree(BiTree *T); int PreOrderTraverse(BiTree T, int (*visit)(TElemType e)); int PreOrderTraverse2(BiTree T, int (*visit)(TElemType e)); int InOrderTraverse(BiTree T, int (*visit)(TElemType e)); int InOrderTraverse2(BiTree T, int (*visit)(TElemType e)); int PostOrderTraverse(BiTree T, int (*visit)(TElemType e)); int PostOrderTraverse2(BiTree T, int (*visit)(TElemType e)); int LevelOrderTraverse(BiTree T, int (*visit)(TElemType e)); int printElem(TElemType e); int InitBiTree(BiTree *T); int DestroyBiTree(BiTree *T); int ClearBiTree(BiTree *T); int BiTreeEmpty(BiTree T); int BiTreeDepth(BiTree T);

数据结构与程序设计C++描述(Kruse著)高等教育出版社_课后答案.

Programming Principles 1 1.2 THE GAME OF LIFE Exercises 1.2 Determine by hand calculation what will happen to each of the configurations shown in Figure 1.1 over the course of five generations. [Suggestion: Set up the Life configuration on a checkerboard. Use one color of checkers for living cells in the current generation and a second color to mark those that will be born or die in the next generation.] Answer (a) Figure remains stable. (b) (c) (d) Figure is stable. 1 2 Chapter 1 _ Programming Principles (e) (f) Figure repeats itself. (g) (h) (i) Figure repeats itself. (j) (k) (l) Figure repeats itself. Section 1.3 _ Programming Style 3 1.3 PROGRAMMING STYLE Exercises 1.3

E1. What classes would you define in implementing the following projects? What methods would your classes possess? (a) A program to store telephone numbers. Answer The program could use classes called Phone_book and Person. The methods for a Phone_book object would include look_up_name, add_person, remove_person. The methods for a Person object would include Look_up_number. Additional methods to initialize and print objects of both classes would also be useful. (b) A program to play Monopoly. Answer The program could use classes called Game_board, Property, Bank, Player, and Dice. In addition to initialization and printing methods for all classes, the following methods would be useful. The class Game_board needs methods next_card and operate_jail. The class Property needs methods change_owner, look_up_owner, rent, build, mortgage, and unmortgage. The class Bank needs methods pay and collect. The class Player needs methods roll_dice, move_location, buy_property and pay_rent. The class Dice needs a method roll. (c) A program to play tic-tac-toe. Answer The program could use classes called Game_board and Square. The classes need initialization and printing methods. The class Game_board would also need methods make_move and is_game_over. The class Square would need methods is_occupied, occupied_by, and occupy. (d) A program to model the build up of queues of cars waiting at a busy intersection with a traffic light. Answer The program could use classes Car, Traffic_light, and Queue. The classes would all need initialization and printing methods. The class Traffic_light would need additional methods change_status and status. The class Queue would need additional methods add_car and remove_car. E2. Rewrite the following class definition, which is supposed to model a deck of playing cards, so that it conforms to our principles of style. class a { // a deck of cards int X; thing Y1[52]; /* X is the location of the top card in the deck. Y1 lists the cards. */ public: a( ); void Shuffle( ); // Shuffle randomly arranges the cards. thing d( ); // deals the top card off the deck } ; Answer class Card_deck { Card deck[52]; int top_card; public: Card_deck( ); void Shuffle( ); Card deal( );

约瑟夫问题数据结构实验报告汇总.

中南民族大学管理学院学生实验报告实验项目: 约瑟夫问题课程名称：数据结构年级：专业：信息管理与信息系统指导教师：实验地点：管理学院综合实验室完成日期：小组成员： 2012 学年至2013 学年度第1 学期

一、实验目的（1）掌握线性表表示和实现；（2）学会定义抽象数据类型；（3）学会分析问题，设计适当的解决方案；二、实验内容【问题描述】：编号为1,2,…,n的n 个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自 1 开始顺序报数，报到m 时停止报数。报m 的人出列，将他的密码作为新的m 值，从他在顺时针方向上的下一个人开始重新从1 报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。【基本要求】：利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。【测试数据】：m 的初值为20；密码：3，1，7，2，4，8，4（正确的结果应为6，1，4，7，2，3，5）。三、实验步骤（一）需求分析对于这个程序来说，首先要确定构造链表时所用的插入方法。当数到m 时一个人就出列，也即删除这个节点，同时建立这个节点的前节点与后节点的联系。由于是循环计数，所以才采用循环列表这个线性表方式。程序存储结构利用单循环链表存储结构存储约瑟夫数据（即n个人的编码等），模拟约瑟夫的显示过程，按照出列的顺序显示个人的标号。编号为1,2,…,n 的 n 个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值 m，从第一个人开始按顺时针方向自1 开始顺序报数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从他在顺时针方向上的下一个人开始重新从 1 报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。基本要求是利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。程序执行的命令（1）构造单向循环链表。（2）按照出列的顺序引出各个人的标号。测试数据 m 的初值为 20；密码：3，1，7，2，4，8，4（正确的结果应为 6，1，4，7，2，3，5）（1）、插入：在把元素插入到循环链表中时，由于是采用的头插法，所以我保留了front头结点。在每加入一个节点时，都会直接连接在front后面，从而保证一开始就赋值的rear尾节点不用修改。伪代码阐释如下：

数据结构实验一的源代码

#include #include typedef struct Node { int key;//密码 int num;//编号 struct Node *next;//指向下一个节点 } Node, *Link; void InitList(Link &L) //创建一个空的链表{ L = (Node *)malloc(sizeof(Node)); if (!L) exit(1); L->key = 0; L->num = 0; L->next = L; } void Creatlinklist(int n, Link &L) //初始化链表{ Link p, q; q = L; for (int i = 1; i <= n; i++) { p = (Node *)malloc(sizeof(Node)); if (!p) exit(1); scanf("%d", &p->key); p->num = i; L->next = p; L = p; } L->next = q->next; free(q); } Link Locate_m(Link &p, int m)//找到第m个 { Link q; for (int j = 1; jnext; q = p->next; m = q->key;

return q; } void Delete_m(Link &L, Link p, Link q)//删除第m个{ p->next = q->next; free(q); } void main() { Link L, p, q; int n, m; L = NULL; InitList(L);//构造出一个只有头结点的空链表 printf("请输入初始密码人数每个人的密码：\n"); scanf("%d", &m);//初始密码为m scanf("%d", &n);// Creatlinklist(n, L);//构建 p = L; for (int i = 1; i <= n; i++) { q = Locate_m(p, m);//找到第m个 printf("%d", q->num); Delete_m(L, p, q);//删除第m个 } system("pause"); }

数据结构源代码(清华大学+严蔚敏)

void Union(List &La, List Lb) { // 算法2.1 // 将所有在线性表Lb中但不在La中的数据元素插入到La中 int La_len,Lb_len,i; ElemType e; La_len = ListLength(La); // 求线性表的长度 Lb_len = ListLength(Lb); for (i=1; i<=Lb_len; i++) { GetElem(Lb, i, e); // 取Lb中第i个数据元素赋给e if (!LocateElem(La, e, equal)) // La中不存在和e相同的数据元素 ListInsert(La, ++La_len, e); // 插入 } } // union void MergeList(List La, List Lb, List &Lc) { // 算法2.2 // 已知线性表La和Lb中的元素按值非递减排列。 // 归并La和Lb得到新的线性表Lc，Lc的元素也按值非递减排列。int La_len, Lb_len; ElemType ai, bj; int i=1, j=1, k=0; InitList(Lc); La_len = ListLength(La); Lb_len = ListLength(Lb); while ((i <= La_len) && (j <= Lb_len)) { // La和Lb均非空 GetElem(La, i, ai); GetElem(Lb, j, bj); if (ai <= bj) { ListInsert(Lc, ++k, ai); ++i; } else { ListInsert(Lc, ++k, bj); ++j; } } while (i <= La_len) { GetElem(La, i++, ai); ListInsert(Lc, ++k, ai); } while (j <= Lb_len) { GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj); } } // MergeList Status InitList_Sq(SqList &L) { // 算法2.3 // 构造一个空的线性表L。 L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if (!L.elem) return OK; // 存储分配失败 L.length = 0; // 空表长度为0 L.listsize = LIST_INIT_SIZE; // 初始存储容量 return OK; } // InitList_Sq Status ListInsert_Sq(SqList &L, int i, ElemType e) { // 算法2.4 // 在顺序线性表L的第i个元素之前插入新的元素e， // i的合法值为1≤i≤ListLength_Sq(L)+1 ElemType *p; if (i < 1 || i > L.length+1) return ERROR; // i值不合法 if (L.length >= L.listsize) { // 当前存储空间已满，增加容量 ElemType *newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof (ElemType)); if (!newbase) return ERROR; // 存储分配失败 L.elem = newbase; // 新基址 L.listsize += LISTINCREMENT; // 增加存储容量 } ElemType *q = &(L.elem[i-1]); // q为插入位置 for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p; // 插入位置及之后的元素右移 *q = e; // 插入e ++L.length; // 表长增1 return OK; } // ListInsert_Sq Status ListDelete_Sq(SqList &L, int i, ElemType &e) { // 算法2.5 // 在顺序线性表L中删除第i个元素，并用e返回其值。 // i的合法值为1≤i≤ListLength_Sq(L)。 ElemType *p, *q; if (i<1 || i>L.length) return ERROR; // i值不合法 p = &(L.elem[i-1]); // p为被删除元素的位置 e = *p; // 被删除元素的值赋给e q = L.elem+L.length-1; // 表尾元素的位置 for (++p; p<=q; ++p) *(p-1) = *p; // 被删除元素之后的元素左移--L.length; // 表长减1 return OK; } // ListDelete_Sq int LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType, ElemType)) { // 算法2.6 // 在顺序线性表L中查找第1个值与e满足compare()的元素的位序。// 若找到，则返回其在L中的位序，否则返回0。 int i; ElemType *p; i = 1; // i的初值为第1个元素的位序 p = L.elem; // p的初值为第1个元素的存储位置 while (i <= L.length && !(*compare)(*p++, e)) ++i; if (i <= L.length) return i; else return 0; } // LocateElem_Sq void MergeList_Sq(SqList La, SqList Lb, SqList &Lc) { // 算法2.7 // 已知顺序线性表La和Lb的元素按值非递减排列。 // 归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列。ElemType *pa,*pb,*pc,*pa_last,*pb_last; pa = La.elem; pb = Lb.elem; Lc.listsize = Lc.length = La.length+Lb.length; pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType)); if (!Lc.elem) exit(OVERFLOW); // 存储分配失败 pa_last = La.elem+La.length-1; pb_last = Lb.elem+Lb.length-1;

数据结构停车场问题实验报告汇总

数据结构课程设计 ——停车场管理问题姓名: 学号: 问题描述设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放（最先到达的第一辆车放在停车场的最里面）。如果停车场已放满n辆车，则后来的

车辆只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就进入停车场。停车场内如有某辆车要开走，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。如果停留在便道上的车未进停车场就要离去，允许其离去，不收停车费，并且仍然保持在便道上等待的车辆的次序。编制一程序模拟该停车场的管理。二、实现要求要求程序输出每辆车到达后的停车位置（停车场或便道上），以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。三、实现提示汽车的模拟输入信息格式可以是：（到达/离去，汽车牌照号码，到达/离去的时刻）。例如，（‘A'，，1，5）表示1号牌照车在5这个时刻到达，而（‘ D '，，5，20）表示5号牌照车在20这个时刻离去。整个程序可以在输入信息为（‘ E '，0，0）时结束。本题可用栈和队列来实现。四、需求分析停车场采用栈式结构，停车场外的便道采用队列结构（即便道就是等候队列）。停车场的管理流程如下 ①当车辆要进入停车场时，检查停车场是否已满，如果未满则车辆进栈（车辆进入停车场）；如果停车场已满，则车辆进入等候队列（车辆进入便道等候）。 ②当车辆要求出栈时，该车到栈顶的那些车辆先弹出栈（在它之后进入的车辆必须先退出车场为它让路），再让该车出栈，其他车辆再按原次序进栈（进入车场）。当车辆出栈完毕后，检查等候队列（便道）中是否有车，有车则从队列头取出一辆车压入栈中。

数据结构实验程序

顺序表的基本操作 #include using namespace std; typedef int datatype; #define maxsize 1024 #define NULL -1 typedef struct { datatype *data; int last; }sequenlist; void SETNULL(sequenlist &L) { L.data=new datatype[maxsize]; for(int i=0;i>https://www.360docs.net/doc/438726288.html,st; cout<<"请输入"<>L.data[i]; } int LENGTH(sequenlist &L) { int i=0; while(L.data[i]!=NULL) i++; return i; } datatype GET(sequenlist &L,int i) { if(i<1||i>https://www.360docs.net/doc/438726288.html,st) { cout<<"error1"<

int j=0; while(L.data[j]!=x) j++; if(j==https://www.360docs.net/doc/438726288.html,st) { cout<<"所查找值不存在！"<=maxsize-1) { cout<<"overflow"; return NULL; } else if(i<1||(i>https://www.360docs.net/doc/438726288.html,st)) { cout<<"error2"<=i-1;j--) L.data[j+1]=L.data[j]; L.data[i-1]=x; https://www.360docs.net/doc/438726288.html,st++; } return 1; } int DELETE(sequenlist &L,int i) { int j; if((i<1)||(i>https://www.360docs.net/doc/438726288.html,st+1)) { cout<<"error3"<

数据结构课程设计文章编辑(附录中有全部代码)

课程设计任务书专业名称：计算机科学与技术（软件工程）课程名称：数据结构课程设计设计题目：文章编辑问题起止时间：2013年6 月24 日至2013年7 月12 日问题描述静态存储一页文章，每行最多不超过80个字符，共N行，程序可以统计出文字、数字、空格的个数，并且可以对文章中特定内容进行查找及替换，同时也可以删除指定内容。基本要求（1）分别统计出其中英文字母数和空格数及整篇文章总字数；（2）统计某一字符串在文章中出现的次数，并输出该次数；（3）查找出文章中某一段文字，并用其他文字进行替换；（4）删除某一子串，并将后面的字符前移。输出形式：（1）分行输出用户输入的各行字符；（2）分4行输出"全部字母数"、"数字个数"、"空格个数"、"文章总字数"；（3）查找出指定字符串在文章中出现的所有地方并替换，输出替换后结果；（4）输出删除某一字符串后的文章；实现提示存储结构使用线性表，分别用几个子函数实现相应的功能，并且使用菜单的形式，可以选择所要进行的操作（查找、替换、删除、统计等）。

文章编辑系统 1概要设计本次课程设计的题目是文章编辑系统，本系统的功能描述如下：用户新建文本、浏览新建文本、文本字符统计、指定字符串统计、指定字符串删除、指定字符串替换等操作。 1.新建文本 2.浏览输入文本 3.文本字符统计 4.指定字符串统计 5.指定字符串删除 6.指定字符串替换 7.退出系统本系统包含七个功能模块，分别为：新建文本模块，浏览输入文本模块，指定字符串统计模块，指定字符串删除模块，指定字符串删除模块，指定字符串替换模块以退出系统模块。新建文本模块实现用户录入文本信息，并且系统自动保存录入信息。浏览输入文本模块实现了显示用户录入信息的功能。指定字符串统模块实现了对英文字母数和空格数及整篇文章总字数的统计。指定字符串统计实现了统计用户自定义字符串个数的功能。指定字符串删除模块实现了对用户自定义字符串的删除。指定字符串替换模块实现了替换用户自定义字符串为用户定义的新字符功能。退出系统模块实现了退出系统功能。

数据结构实验报告

数据结构实验报告一．题目要求 1）编程实现二叉排序树，包括生成、插入，删除； 2）对二叉排序树进行先根、中根、和后根非递归遍历； 3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。 4）分别用二叉排序树和数组去存储一个班(50人以上)的成员信息(至少包括学号、姓名、成绩3项),对比查找效率，并说明在什么情况下二叉排序树效率高,为什么? 二．解决方案对于前三个题目要求，我们用一个程序实现代码如下 #include #include #include #include "Stack.h"//栈的头文件，没有用上 typedefintElemType; //数据类型 typedefint Status; //返回值类型 //定义二叉树结构 typedefstructBiTNode{ ElemType data; //数据域 structBiTNode *lChild, *rChild;//左右子树域 }BiTNode, *BiTree; intInsertBST(BiTree&T,int key){//插入二叉树函数 if(T==NULL) { T = (BiTree)malloc(sizeof(BiTNode)); T->data=key; T->lChild=T->rChild=NULL; return 1; } else if(keydata){ InsertBST(T->lChild,key); } else if(key>T->data){ InsertBST(T->rChild,key); } else return 0; } BiTreeCreateBST(int a[],int n){//创建二叉树函数 BiTreebst=NULL; inti=0; while(i

数据结构与C语言程序设计

《数据结构与C语言程序设计》复习大纲《数据结构与C语言程序设计》包括“数据结构”与“C语言程序设计”两门课程的内容，各占比例50%。《数据结构》部分指定参考书：《数据结构教程（第二版）》唐发根编著，北京航空航天大学出版社，2005 一、概述 1．简要了解数据的逻辑结构与存储结构的基本概念； 2．了解算法的定义、算法的五个基本性质以及算法分析最基本的概念，包括算法分析的前提、目的。二、线性表 1．了解线性关系、线性表的定义，线性表的基本操作； 2．线性表的顺序存储结构与链式存储结构(包括单链表、循环链表和双向链表)的构造原理； 3．掌握在以上两种存储结构的基础上对线性表实施的基本操作，重点包括顺序表的插入和删除、链表的建立、插入和删除、检索等操作对应的过程和算法的设计。三、堆栈与队列 1．了解堆栈与队列(不含循环队列)的基本概念、基本操作； 2．掌握堆栈与队列的顺序存储结构与链式存储结构的构造原理； 3．掌握在不同存储结构的基础上对堆栈与队列实施插入与删除等基本操作过程。

四、树与二叉树 1．了解树型结构的基本概念，基本特征、名词术语； 2．了解完全二叉树、满二叉树的概念；二叉树的基本性质（至少要记住结论）； 3．了解二叉树的顺序存储结构与二叉链表存储结构的构造原理及特点，重点是二叉链表存储结构； 4．掌握二叉树的前序遍历、中序遍历、后序遍历和按层次遍历算法(非递归算法)以及利用遍历解决有关二叉树的其它操作； 5．掌握二叉排序树的基本概念、建立(插入)和查找。五、图 1．了解图结构的基本概念、基本名词术语； 2．掌握图的邻接矩阵存储方法和邻接表存储方法的基本构造原理与特点； 3．图的深度优先搜索和广度优先搜索的基本过程，遍历的基本作用； 4．最小生成树的求解过程，拓扑排序及其目的。六、文件及查找 1．掌握顺序查找法、折半查找法的查找过程，了解折半查找方法的基本要求； 2．了解散列(Hash)文件的基本特点，散列函数和散列冲突的概念，处理散列冲突的方法。七、内排序了解插入排序法、选择排序法、泡排序法、快速排序法以及堆积排序(大顶堆积)法等排序方法的排序原理、规律和特点。《C语言程序设计》部分指定参考书：《C程序设计》（第三版）谭浩强著，清华大学出版社, 2005.7