数据结构程序设计(用c++)!!急求!!!

#include<iostream>

using namespace std;

int enter()

{

char c;

int num;

while(!(cin>>num)||num<0||((c=getchar())&&(c!=' '&&c!='\n')))//如果输入字母或者字母和数字的组合，或者输入数小于0，提示输入错误，并恢复输入缓冲区的正确状态，刷新输入缓冲区

{

cinclear();//恢复错误标志

fflush(stdin);//清空刷新 输入缓冲区

cout<<"请输入正整数"<<endl;

}

return num;

}

int IsInclude7(int num)

{

int temp;

do

{

temp=num%10;//num对10取余数,也就是取个位数字。

// cout<<"t="<<temp<<" ";

if(temp==7) return 1;//包含7

num=num/10;//将个位数字去掉

if(num==0) return 0;//不包含7

}while(1);

}

int main()

{

int num,i;

num=enter();

for(i=1;i<=num;)

{

if(i%7==0)//如果能被7整除

{

if(IsInclude7(i))//如果包含有数字7

cout<<i<<" ";

i=i+7;//不再加一，而是加7，因为能被7整除的，加7也能被7整除。

}

else

i++;

}

return 0;

}

问题一：什么叫结构化程序设计？它的主要内容是什么？ 结构化程序设计的思路是：自顶向下、逐步求精；其程序结构是按功能划分为若干个基本模块；各模块之间的关系尽可能简单，在功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成；其模块化实现的具体方法是使用子程序。结构化程序设计由于采用了模块分解与功能抽象，自顶向下、分而治之的方法，从而有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。

虽然结构化程序设计方法具有很多的优点，但它仍是一种面向过程的程序设计方法，它把数据和处理数据的过程分离为相互独立的实体。当数据结构改变时，所有相关的处理过程都要进行相应的修改，每一种相对于老问题的新方法都要带来额外的开销，程序的可重用性差。

由于图形用户界面的应用，程序运行由顺序运行演变为事件驱动，使得软件使用起来越来越方便，但开发起来却越来越困难，对这种软件的功能很难用过程来描述和实现，使处面向过程的方法来开发和维护都将非常困难

问题二：什么是结构化程序设计方法？ 一个结构化程序就是用高级语言表示的结构化算法。用三种基本结构组成的程序必然是结构化的程序，这种程序便于编写、阅读、

修改和维护。这就减少了程序出错的机会，提高了程序的可靠性，保证了程序的质量。

结构化程序设计强调程序设计风格和程序结构的规范化，提倡清晰的结构。怎样才能得到一个结构化的程序呢如果我们面临一

个复杂的问题，是难以一下子写出一个层次分明、结构清晰、算法正确的程序的。结构化程序设计方法的基本思路是，把一个复

杂问题的求解过程分阶段进行，每个阶段处理的问题都控制在人们容易理解和处理的范围内。

具体说，采取以下方法保证得到结构化的程序。

(1)自顶向下；(2)逐步细化；(3)模块化设计；(4)结构化编码。

在接受一个任务后应怎样着手进行呢有两种不同的方法：一种是白顶向下，逐步细化；―种是自下而上，逐步积累。以写文章为

例来说明这个问题。有的人胸有全局，先没想好整个文章分成哪几个部分，然后再进一步考虑每一部分分成哪几节，每一节分成哪

几段，每一段应包含什么内容，用这种方法逐步分解，直到作者认为可以直接将各小段表达为文字语句为止。这种方法就叫做

“自顶向下，逐步细化”。

另有些人写文章时不拟提纲，如同写信一样提起笔就写，想到哪里就写到哪里，直到他认为把想写的内容都写出来了为止。

这种方法叫做“自下而上，逐步积累”。

显然，用第一种方法考虑周全，结构清晰，层次分明，作者容易写，读者容易看。如果发现某一部分中有一段内容不妥，需要修改

只需找出该部分，修改有关段落即可，与其他部分无关。我们提倡用这种方法设计程序。这就是用工程的方法设计程序。

我们应当掌握自顶向下、逐步细化的设计方法。这种设计方法的过程是将问题求解由抽象逐步具体化的过程。

用这种方法便于验证算法的正确性，在向下一层展开之前应仔细检查本层设计是否正确，只有上一层是正确的才能向下细化。

如果每一层设计都没有问题，则整个算法就 正确的。由于每一层向下细化时都不太复杂，因此容易保证整个算法的正确性检查

时也是由上而下逐层检查，这样做，思路清楚，有条不紊地一步一步进行，既严谨又方便。

举一个例子来说明这种方法的应用。

例 将1到1000之间的素数打印出来。

我们已在本章中讨论过判别素数的方法，现在采用“筛法”来求素数表。所谓“筛法”指的是“埃拉托色尼(Eratosthenes)筛法”

他是古希腊的著名数学家。他采取的方法是，在一张纸上写上1到1000全部整数，然后逐个判断它们是否素数,找出一个非素数,就

把它 挖掉，最后剩下的就是素数

具体作法如下：

（1） 先将1挖掉（因为1不（2） 是素数）。

（3） 用2去除它后面的各个数，（4） 把能被2整除的数挖掉，（5） 即把2 的倍（6） 数挖掉。

（7） 用3去除它后面各数，（8） 把3的倍（9） 数挖掉

（10） 分别用4、5…各数作为除数去除这些数以后个各数。这个过程一直进行到除数后面的数已全被挖掉为止。

上面的算法可表示为：

（1） 挖去1；

（2） 用刚才被挖去的数的下一个数p去除p后面各数，（3） 把p的倍（4） 数挖掉；

（5） 检查p是否小于√n的整数部分（如果n=1000，（6） 则检查p∠31？），（7）如果是则返回（2）继续执行，（8）否则

就结束；

（9） 之上盛夏的数就是素数。>>

问题三：结构化程序设计的工作原理是什么？ 是进行以模块功能和处理过程设计为主的详细设计的基本原则。结构化程序设计是过程式程序设计的一个子集，它对写入的程序使用逻辑结构，使得理解和修改更有效更容易。

中文名：结构化程序设计

外文名：structured programming

提出人：EWDijikstra

时间：1965年

分享

概述

概念

其概念最早由EWDijikstra在1965年提出的，是软件发展的一个重要的里程碑。它的主要观点是采用自顶向下、逐步求精及模块化的程序设计方法；使用三种基本控制结构构造程序，任何程序都可由顺序、选择、循环三种基本控制结构构造。结构化程序设计主要强调的是程序的易读性。

内容

详细描述处理过程常用三种工具：图形、表格和语言。

图形：程序流程图、N-S图、PAD图　表格：判定表

语言：过程设计语言（PDL）

结构化程序设计曾被称为软件发展中的第三个里程碑。该方法的要点是：

（1) 主张使用顺序、选择、循环三种基本结构来嵌套连结成具有复杂层次的“结构化程序”，严格控制GOTO语句的使用。用这样的方法编出的程序在结构上具有以下效果：

a 以控制结构为单位，只有一个入口，一个出口，所以能独立地理解这一部分。

b 能够以控制结构为单位，从上到下顺序地阅读程序文本。

c由于程序的静态描述与执行时的控制流程容易对应，所以能够方便正确地理解程序的动作。

（2）“自顶而下，逐步求精”的设计思想，其出发点是从问题的总体目标开始，抽象低层的细节，先专心构造高层的结构，然后再一层一层地分解和细化。这使设计者能把握主题，高屋建瓴，避免一开始就陷入复杂的细节中，使复杂的设计过程变得简单明了，过程的结果也容易做到正确可靠。

（3）“独立功能，单出、入口”的模块结构，减少模块的相互联系使模块可作为插件或积木使用，降低程序的复杂性，提高可靠性。程序编写时，所有模块的功能通过相应的子程序(函数或过程)的代码来实现。程序的主体是子程序层次库，它与功能模块的抽象层次相对应，编码原则使得程序流程简洁、清晰，增强可读性。

（4） 主程序员组。

其中（1）、（2）是解决程序结构规范化问题；（3）是解决将大划小，将难化简的求解方法问题；（4）是解决软件开发的人员组织结构问题。

模型

结构化程序设计通常使用自上往下的设计模型，开发员将整个程序结构映射到单个小部分。已定义的函数或相似函数的 在单个模块或字模块中编码，这意味着，代码能够更有效的载入存储器，模块能在其它程序中再利用。模块单独测试之后，与其它模块整合起来形成整个程序组织。

程序流程遵循简单的层次化模型，采用“for”、“repeat”、“while”等循环结构，鼓励使用“Go To”语句。几乎任何语言都能使用结构化程序设计技术来避免非结构化语言的通常陷阱。非结构化程序设计必须依赖于开发人员避免结构问题，从而导致程序组织较差。大多数现代过程式语言都鼓励结构化程序设计。

基本结构

结构化程序设计的三种基本结构是:顺序结构、选择结构和循环结构。

顺序结构

顺序结构表示程序中的各 *** 作是按照它们出现的先后顺序执行的。

选择结构

选择结构表示程序的处理步骤出现了分支，它需要根据某一特定的条件选择其中的一个分支执行。选择结构有单选择、双选择和多选择三种形式。

循环结构

循环结构表示程序反复执行某个或某些 *** 作，直到某条件为假（或为真）时才可终止循环。在循环结构中最主要的是：什么情况下执行循环？哪些 *** 作需要循环执行？循环结构的基本形式有两种：当型循环和直到型循环。

当型循环：表示先判断条件，当满足给定的>>

问题四：结构化程序设计的三种基本结构是什么。各有什么特点 顺序结构、分支结构、循环结构

顺序结构就是从头到尾一次执行每一个语句

分支结构根据不同的条件执行不同的语句或者语句体

循环结构就是重复的执行语句或者语句体,达到重复执行一类 *** 作的目的

问题五：什么是结构化程序设计 结构化程序设计（structured programming）是进行以模块功能和处理过程设计为主的详细设计的基本原则。结构化程序设计是过程式程序设计的一个子集，它对写入的程序使用逻辑结构，使得理解和修改更有效更容易。结构化程序设计的三种基本结构是:顺序结构、选择结构和循环结构。结构化程序设计曾被称为软件发展中的第三个里程碑。结构化程序设计通常使用自上往下的设计模型，开发员将整个程序结构映射到单个小部分。当型循环：表示先判断条件，当满足给定的条件时执行循环体，并且在循环终端处流程自动返回到循环入口；如果条件不满足，则退出循环体直接到达流程出口处。

问题六：结构化程序设计原则 1．自顶向下：程序设计时，应先考虑总体，后考虑细节；先考虑全局目标，后考虑局部目标。不要一开始就过多追求众多的细节，先从最上层总目标开始设计，逐步使问题具体化。 2．逐步求精：对复杂问题，应设计一些子目标作为过渡，逐步细化。 3．模块化：一个复杂问题，肯定是由若干稍简单的问题构成。模块化是把程序要解决的总目标分解为子目标，再进一步分解为具体的小目标，把每一个小目标称为一个模块。 4．限制使用goto语句

问题七：结构化程序设计的目的构成与方法 结构化程序设计的目的：通过设计结构良好的程序，以程序静态的良好的结构保证程序动态执行的正确性，使程序易理解、易调试、易维护，以提高软件开发的效率，减少出错率。构成：控制结构+数据结构，控制结构有顺序、选择、循环结构。方法：模块丁，自顶向下，自底向上。

问题八：结构化与非结构化程序的区别？ 结构化就是把整体分布,把每部分都解决

问题九：什么叫结构化程序设计？它的主要内容是什么？ 结构化程序设计的思路是：自顶向下、逐步求精；其程序结构是按功能划分为若干个基本模块；各模块之间的关系尽可能简单，在功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成；其模块化实现的具体方法是使用子程序。结构化程序设计由于采用了模块分解与功能抽象，自顶向下、分而治之的方法，从而有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。

虽然结构化程序设计方法具有很多的优点，但它仍是一种面向过程的程序设计方法，它把数据和处理数据的过程分离为相互独立的实体。当数据结构改变时，所有相关的处理过程都要进行相应的修改，每一种相对于老问题的新方法都要带来额外的开销，程序的可重用性差。

由于图形用户界面的应用，程序运行由顺序运行演变为事件驱动，使得软件使用起来越来越方便，但开发起来却越来越困难，对这种软件的功能很难用过程来描述和实现，使处面向过程的方法来开发和维护都将非常困难

问题十：什么是结构化程序设计方法？ 一个结构化程序就是用高级语言表示的结构化算法。用三种基本结构组成的程序必然是结构化的程序，这种程序便于编写、阅读、

修改和维护。这就减少了程序出错的机会，提高了程序的可靠性，保证了程序的质量。

结构化程序设计强调程序设计风格和程序结构的规范化，提倡清晰的结构。怎样才能得到一个结构化的程序呢如果我们面临一

个复杂的问题，是难以一下子写出一个层次分明、结构清晰、算法正确的程序的。结构化程序设计方法的基本思路是，把一个复

杂问题的求解过程分阶段进行，每个阶段处理的问题都控制在人们容易理解和处理的范围内。

具体说，采取以下方法保证得到结构化的程序。

(1)自顶向下；(2)逐步细化；(3)模块化设计；(4)结构化编码。

在接受一个任务后应怎样着手进行呢有两种不同的方法：一种是白顶向下，逐步细化；―种是自下而上，逐步积累。以写文章为

例来说明这个问题。有的人胸有全局，先没想好整个文章分成哪几个部分，然后再进一步考虑每一部分分成哪几节，每一节分成哪

几段，每一段应包含什么内容，用这种方法逐步分解，直到作者认为可以直接将各小段表达为文字语句为止。这种方法就叫做

“自顶向下，逐步细化”。

另有些人写文章时不拟提纲，如同写信一样提起笔就写，想到哪里就写到哪里，直到他认为把想写的内容都写出来了为止。

这种方法叫做“自下而上，逐步积累”。

显然，用第一种方法考虑周全，结构清晰，层次分明，作者容易写，读者容易看。如果发现某一部分中有一段内容不妥，需要修改

只需找出该部分，修改有关段落即可，与其他部分无关。我们提倡用这种方法设计程序。这就是用工程的方法设计程序。

我们应当掌握自顶向下、逐步细化的设计方法。这种设计方法的过程是将问题求解由抽象逐步具体化的过程。

用这种方法便于验证算法的正确性，在向下一层展开之前应仔细检查本层设计是否正确，只有上一层是正确的才能向下细化。

如果每一层设计都没有问题，则整个算法就 正确的。由于每一层向下细化时都不太复杂，因此容易保证整个算法的正确性检查

时也是由上而下逐层检查，这样做，思路清楚，有条不紊地一步一步进行，既严谨又方便。

举一个例子来说明这种方法的应用。

例 将1到1000之间的素数打印出来。

我们已在本章中讨论过判别素数的方法，现在采用“筛法”来求素数表。所谓“筛法”指的是“埃拉托色尼(Eratosthenes)筛法”

他是古希腊的著名数学家。他采取的方法是，在一张纸上写上1到1000全部整数，然后逐个判断它们是否素数,找出一个非素数,就

把它 挖掉，最后剩下的就是素数

具体作法如下：

（1） 先将1挖掉（因为1不（2） 是素数）。

（3） 用2去除它后面的各个数，（4） 把能被2整除的数挖掉，（5） 即把2 的倍（6） 数挖掉。

（7） 用3去除它后面各数，（8） 把3的倍（9） 数挖掉

（10） 分别用4、5…各数作为除数去除这些数以后个各数。这个过程一直进行到除数后面的数已全被挖掉为止。

上面的算法可表示为：

（1） 挖去1；

（2） 用刚才被挖去的数的下一个数p去除p后面各数，（3） 把p的倍（4） 数挖掉；

（5） 检查p是否小于√n的整数部分（如果n=1000，（6） 则检查p∠31？），（7）如果是则返回（2）继续执行，（8）否则

就结束；

（9） 之上盛夏的数就是素数。>>

#include <stdioh>

#include <stdlibh>

#include <stringh>

#define N 100

#define M 2N-1

typedef char HuffmanCode[2M];//haffman编码

typedef struct

{

int weight;//权值

int parent;//父节节点

int LChild;//左子节点

int RChild;//右子节点

}HTNode,Huffman[M+1];//huffman树

typedef struct Node

{

int weight; //叶子结点的权值

char c; //叶子结点

int num; //叶子结点的二进制码的长度

}WNode,WeightNode[N];

/产生叶子结点的字符和权值/

void CreateWeight(char ch[],int s,WeightNode CW,int p)

{

int i,j,k;

int tag;

p=0;//叶子节点个数

//统计字符出现个数,放入CW

for(i=0;ch[i]!='\0';i++)

{

tag=1;

for(j=0;j<i;j++)

if(ch[j]==ch[i])

{

tag=0;

break;

}

if(tag)

{

CW[++p]c=ch[i];

CW[p]weight=1;

for(k=i+1;ch[k]!='\0';k++)

if(ch[i]==ch[k])

CW[p]weight++;//权值累加

}

}

s=i;//字符串长度

}

/创建HuffmanTree/

void CreateHuffmanTree(Huffman ht,WeightNode w,int n)

{

int i,j;

int s1,s2;

//初始化哈夫曼树

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

{

ht[i]weight =w[i]weight;

ht[i]parent=0;

ht[i]LChild=0;

ht[i]RChild=0;

}

for(i=n+1;i<=2n-1;i++)

{

ht[i]weight=0;

ht[i]parent=0;

ht[i]LChild=0;

ht[i]RChild=0;

}

for(i=n+1;i<=2n-1;i++)

{

for(j=1;j<=i-1;j++)

if(!ht[j]parent)

break;

s1=j; //找到第一个双亲不为零的结点

for(;j<=i-1;j++)

if(!ht[j]parent)

s1=ht[s1]weight>ht[j]weightj:s1;

ht[s1]parent=i;

ht[i]LChild=s1;

for(j=1;j<=i-1;j++)

if(!ht[j]parent)

break;

s2=j; //找到第二个双亲不为零的结点

for(;j<=i-1;j++)

if(!ht[j]parent)

s2=ht[s2]weight>ht[j]weightj:s2;

ht[s2]parent=i;

ht[i]RChild=s2;

ht[i]weight=ht[s1]weight+ht[s2]weight;//权值累加

}

}

/叶子结点的编码/

void CrtHuffmanNodeCode(Huffman ht,char ch[],HuffmanCode h,WeightNode weight,int m,int n)

{

int i,c,p,start;

char cd;

cd=(char )malloc(nsizeof(char));

cd[n-1]='\0';//末尾置0

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

{

start=n-1; //cd串每次从末尾开始

c=i;

p=ht[i]parent;//p在n+1至2n-1

while(p) //沿父亲方向遍历,直到为0

{

start--;//依次向前置值

if(ht[p]LChild==c)//与左子相同,置0

cd[start]='0';

else //否则置1

cd[start]='1';

c=p;

p=ht[p]parent;

}

weight[i]num=n-start; //二进制码的长度(包含末尾0)

h[i]=(char )malloc((n-start)sizeof(char));

strcpy(h[i],&cd[start]);//将二进制字符串拷贝到指针数组h中

}

free(cd);//释放cd内存

system("pause");

}

/所有字符的编码/

void CrtHuffmanCode(char ch[],HuffmanCode h,HuffmanCode hc,WeightNode weight,int n,int m)

{

int i,k;

for(i=0;i<m;i++)

{

for(k=1;k<=n;k++) /从weight[k]c中查找与ch[i]相等的下标K/

if(ch[i]==weight[k]c)

break;

hc[i]=(char )malloc((weight[k]num)sizeof(char));

strcpy(hc[i],h[k]); //拷贝二进制编码

}

}

/解码/

void TrsHuffmanTree(Huffman ht,WeightNode w,HuffmanCode hc,int n,int m)

{

int i=0,j,p;

printf("StringInformation\n");

while(i<m)

{

p=2n-1;//从父亲节点向下遍历直到叶子节点

for(j=0;hc[i][j]!='\0';j++)

{

if(hc[i][j]=='0')

p=ht[p]LChild;

else

p=ht[p]RChild;

}

printf("%c",w[p]c); /打印原信息/

i++;

}

}

/释放huffman编码内存/

void FreeHuffmanCode(HuffmanCode h,HuffmanCode hc,int n,int m)

{

int i;

for(i=1;i<=n;i++)//释放叶子结点的编码

free(h[i]);

for(i=0;i<m;i++) //释放所有结点的编码

free(hc[i]);

}

void print(Huffman &ht,int i,int space)//打印哈弗曼树

{

int j;

if(i)

{

print(ht,ht[i]RChild,space+5);

for(j=0;j<=space;j++)

printf(" ");

printf("%d\n",ht[i]weight);

print(ht,ht[i]LChild,space+5);

}

return ;

}

void main()

{

int i,n=0; /n为叶子结点的个数/

int m=0; /m为字符串ch[]的长度/

char ch[N]; /ch[N]存放输入的字符串/

Huffman ht; /Huffman二叉数 /

HuffmanCode h,hc; /h存放叶子结点的编码，hc 存放所有结点的编码/

WeightNode weight; /存放叶子结点的信息/

printf("\n");

printf(" 欢迎使用哈弗曼编码解码系统\n");

printf("\n");

printf("\tHuffmanCoding\n");

printf("please input information :");

gets(ch); /输入字符串/

CreateWeight(ch,&m,weight,&n); /产生叶子结点信息，m为字符串ch[]的长度/

printf("WeightInformation\n Node ");

for(i=1;i<=n;i++) /输出叶子结点的字符与权值/

printf("%c ",weight[i]c);

printf("\nWeight ");

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

printf("%d ",weight[i]weight);

CreateHuffmanTree(ht,weight,n); /产生Huffman树/

printf("\nHuffamnTreeInformation\n");

printf("\ti\tweight\tparent\tLChild\tRChild\n");

for(i=1;i<=2n-1;i++) /打印Huffman树的信息/

printf("\t%d\t%d\t%d\t%d\t%d\n",i,ht[i]weight,ht[i]parent,ht[i]LChild,ht[i]RChild);

CrtHuffmanNodeCode(ht,ch,h,weight,m,n); /叶子结点的编码/

printf(" NodeCode\n"); /打印叶子结点的编码/

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

{

printf("\t%c:",weight[i]c);

printf("%s\n",h[i]);

}

CrtHuffmanCode(ch,h,hc,weight,n,m); /所有字符的编码/

printf("StringCode\n\n"); /打印字符串的编码/

for(i=0;i<m;i++)

printf("%s",hc[i]);

system("pause");

TrsHuffmanTree(ht,weight,hc,n,m); /解码/

FreeHuffmanCode(h,hc,n,m);

printf("\n");

printf("\n哈弗曼树\n");

print(ht,2n-1,0);

system("pause");

}

#include <stdioh>

#include <malloch>

#define INFINITY 32767

#define MAX_VEX 20 //最大顶点个数

#define QUEUE_SIZE (MAX_VEX+1) //队列长度

bool visited; //访问标志数组

//图的邻接矩阵存储结构

typedef struct{

char vexs; //顶点向量

int arcs[MAX_VEX][MAX_VEX]; //邻接矩阵

int vexnum,arcnum; //图的当前顶点数和弧数

}MGraph;

//队列类

class Queue{

public:

void InitQueue(){

base=(int )malloc(QUEUE_SIZEsizeof(int));

front=rear=0;

}

void EnQueue(int e){

base[rear]=e;

rear=(rear+1)%QUEUE_SIZE;

}

void DeQueue(int &e){

e=base[front];

front=(front+1)%QUEUE_SIZE;

}

public:

int base;

int front;

int rear;

};

//图G中查找元素c的位置

int Locate(MGraph G,char c){

for(int i=0;i<Gvexnum;i++)

if(Gvexs[i]==c) return i;

return -1;

}

//创建无向网

void CreateUDN(MGraph &G){

int i,j,w,s1,s2;

char a,b,temp;

printf("输入顶点数和弧数:");

scanf("%d%d",&Gvexnum,&Garcnum);

temp=getchar(); //接收回车

Gvexs=(char )malloc(Gvexnumsizeof(char)); //分配顶点数目

printf("输入%d个顶点\n",Gvexnum);

for(i=0;i<Gvexnum;i++){ //初始化顶点

printf("输入顶点%d:",i);

scanf("%c",&Gvexs[i]);

temp=getchar(); //接收回车

}

for(i=0;i<Gvexnum;i++) //初始化邻接矩阵

for(j=0;j<Gvexnum;j++)

Garcs[i][j]=INFINITY;

printf("弧的输入方法:1 2 1\n");

printf("输入%d条弧\n",Garcnum);

for(i=0;i<Garcnum;i++){ //初始化弧

printf("输入弧%d:",i);

scanf("%c %c %d",&a,&b,&w); //输入一条边依附的顶点和权值

temp=getchar(); //接收回车

s1=Locate(G,a);

s2=Locate(G,b);

Garcs[s1][s2]=Garcs[s2][s1]=w;

}

}

//图G中顶点k的第一个邻接顶点

int FirstVex(MGraph G,int k)

{

int i;

if(k>=0 && k<Gvexnum){ //k合理

for(i=0;i<Gvexnum;i++)

if(Garcs[k][i]!=INFINITY) return i;

}

return -1;

}

//图G中顶点i的第j个邻接顶点的下一个邻接顶点

int NextVex(MGraph G,int i,int j)

{

int k;

if(i>=0 && i<Gvexnum && j>=0 && j<Gvexnum)

{ //i,j合理

for(k=j+1;k<Gvexnum;k++)

if(Garcs[i][k]!=INFINITY)

return k;

}

return -1;

}

//深度优先遍历

void DFS(MGraph G,int k)

{

int i;

if(k==-1){ //第一次执行DFS时,k为-1

for(i=0;i<Gvexnum;i++)

if(!visited[i]) DFS(G,i); //对尚未访问的顶点调用DFS

}

else{

visited[k]=true;

printf("%c ",Gvexs[k]); //访问第k个顶点

for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))

if(!visited[i]) DFS(G,i); //对k的尚未访问的邻接顶点i递归调用DFS

}

}

//广度优先遍历

void BFS(MGraph G){

int k;

Queue Q; //辅助队列Q

QInitQueue();

for(int i=0;i<Gvexnum;i++)

if(!visited[i]){ //i尚未访问

visited[i]=true;

printf("%c ",Gvexs[i]);

QEnQueue(i); //i入列

while(Qfront!=Qrear){

QDeQueue(k); //队头元素出列并置为k

for(int w=FirstVex(G,k);w>=0;w=NextVex(G,k,w))

if(!visited[w]){ //w为k的尚未访问的邻接顶点

visited[w]=true;

printf("%c ",Gvexs[w]);

QEnQueue(w);

}

}

}

}

//主函数

void main()

{

printf("无向图的的深度优先遍历和广度优先遍历!\n");

int i;

MGraph G;

CreateUDN(G);

visited=(bool )malloc(Gvexnumsizeof(bool));

printf("\n深度优先遍历: ");

for(i=0;i<Gvexnum;i++)

visited[i]=false;

DFS(G,-1);

printf("\n广度优先遍历: ");

for(i=0;i<Gvexnum;i++)

visited[i]=false;

BFS(G);

printf("\n");

}

在VC60下编译通过

楼主跟我的C语言程序设计课程要求设计的程序很像，有一点点不同，不过我的程序应该能满足你的要求，代码如下：

#include <stdioh>

#include <conioh>

#include <stringh>

#define N 10

struct student{

char name[20];

int cla;

int point1;

int point2;

int point3;

int sum;

int num;

};

void printf_student(struct student stu[]);

void in_student(struct student stu[]);

void look_student(struct student stu[]);

void main(){

student stu[N];

int choice1;

while(choice1!=5){

printf("请选择您要 *** 作的项目:\n");

printf("1读取数据\n2录入数据\n3分析数据\n4保存数据\n5退出\n");

scanf("%d",&choice1);

switch(choice1){

case 1:

printf_student(stu);

break;

case 2:

in_student(stu);

break;

case 3:

look_student(stu);

break;

}}

}

void printf_student(struct student stu[]){

FILE fout;

int i=0;

int j=0;

fout=fopen("stu1txt","r");

if(fout==NULL){printf("找不到文件");}

else{

while(!feof(fout)){

fscanf(fout,"%s %d %d %d %d",stu[i]name,&stu[i]cla,&stu[i]point1,&stu[i]point2,&stu[i]point3);

i++;

}

printf("已经读取");

printf("\n姓名\t\t班级\t\t成绩1\t\t成绩2\t\t成绩3\n");

for(j=0;j<i;j++){

printf("%s\t\t",stu[j]name);

printf("%d\t\t",stu[j]cla);

printf("%d\t\t",stu[j]point1);

printf("%d\t\t",stu[j]point2);

printf("%d\t\t",stu[j]point3);}

}

fclose(fout);

}

void in_student(struct student stu[]){

FILE fp;

student flag;

char ch[50]={0};

fp=fopen("stu1txt","a+");

int choice=1;

if(fp==0){printf("无法打开文件\n");}

else{

while(choice){

printf("请依次输入姓名，班级，成绩1，成绩2，成绩3\n");

scanf("%s %d %d %d %d",flagname,&flagcla,&flagpoint1,&flagpoint2,&flagpoint3);

sprintf(ch,"%s\t%d\t%d\t%d\t%d",flagname,flagcla,flagpoint1,flagpoint2,flagpoint3);

/fwrite(flagname,20,1,fp);

fwrite("\t",2,sizeof("\t"),fp);

fwrite(&flagcla,sizeof(flagcla),1,fp);

fwrite("\t",sizeof("\t"),1,fp);

fwrite(&flagpoint1,sizeof(flagpoint1),1,fp);

fwrite("\t",2,sizeof("\t"),fp);

fwrite(&flagpoint2,sizeof(flagpoint2),1,fp);

fwrite("\t",2,sizeof("\t"),fp);

fwrite(&flagpoint3,sizeof(flagpoint3),1,fp);/

fwrite(ch,strlen(ch),1,fp);

printf("%s",ch);

printf("若想继续录入，请输入1，若退出，请输入0\n");

scanf("%d",&choice);

}}

fclose(fp);

}

void look_student(struct student stu[]){

FILE fp;

int i=0;

int sum=0;

student flag;

fp=fopen("stu1txt","r");

if(fp==0){printf("无法打开文件\n");}

else{

while(!feof(fp)){

fscanf(fp,"%s %d %d %d %d",stu[i]name,&stu[i]cla,&stu[i]point1,&stu[i]point2,&stu[i]point3);

i++;

}}

for(int j=0;j<i;j++){

sum=stu[j]point1+stu[j]point2+stu[j]point3;

stu[j]sum=sum;

sum=0;

}

int t=0;

for(t=1;t<i;t++){

for(j=0;j<i-t;j++){

if(stu[j]sum<stu[j+1]sum){

strcpy(flagname,stu[j+1]name);

flagcla=stu[j+1]cla;

flagpoint1=stu[j+1]point1;

flagpoint2=stu[j+1]point2;

flagpoint3=stu[j+1]point3;

flagsum=stu[j+1]sum;

strcpy(stu[j+1]name,stu[j]name);

stu[j+1]cla=stu[j]cla;

stu[j+1]point1=stu[j]point1;

stu[j+1]point2=stu[j]point2;

stu[j+1]point3=stu[j]point3;

stu[j+1]sum=stu[j]sum;

strcpy(stu[j]name,flagname);

stu[j]cla=flagcla;

stu[j]point1=flagpoint1;

stu[j]point2=flagpoint2;

stu[j]point3=flagpoint3;

stu[j]sum=flagsum;

}

}

}

for(j=0;j<i;j++){

stu[j]num=j+1;

}

fclose(fp);

FILE creat;

char ch[30]={0};

creat=fopen("stu2txt","w");

for(j=0;j<i;j++){

sprintf(ch,"%s\t%d\t%d\t%d\t%d\t%d\t%d",stu[j]name,stu[j]cla,stu[j]point1,stu[j]point2,stu[j]point3,stu[j]sum,stu[j]num);

fwrite(ch,30,1,creat);

}

printf("姓名\t班级\t成绩1\t成绩2\t成绩3\t总分\t排名\n");

for(j=0;j<i;j++){

printf("%s\t",stu[j]name);

printf("%d\t",stu[j]cla);

printf("%d\t",stu[j]point1);

printf("%d\t",stu[j]point2);

printf("%d\t",stu[j]point3);

printf("%d\t",stu[j]sum);

printf("%d\n",stu[j]num);

}

fclose(creat);

}

注意一下，我创建的文件时stu1txt

// 创建二叉树是按照"二叉排序树"的原则,例如:

// 输入序列20 15 10 12 18 25 30 16 17, 第1个数据是20,作为根结点,

// 第2个数据是15,比20小,作为20的左分支,第3个数据是10,比20和15小,

// 作为15的左分支,第4个数是12,比20和15小,但比10大,作为10的右分支,

// 如此类推,创建完整的二叉树

// 先序遍历用[栈],层序遍历用[队列]

//

// 示例演示

// 请输入结点的个数: 9

// 请连续输入9个数据(用空格隔开): 20 15 10 12 18 25 30 16 17

// 创建二叉树后

// 先序遍历序列: 20 15 10 12 18 16 17 25 30

// 层序遍历序列: 20 15 25 10 18 30 12 16 17

//

//         20

//       /     \

//      15     25

//   /     \     \

//  10     18     30

//   \     /

//    12  16

//         \

//          17

//

#include<stdioh>

#include<stdlibh>

struct treeNode //二叉树的结构体

{

    int data;

    struct treeNode left;

    struct treeNode right;

};

typedef struct treeNode BTree;

typedef struct stack_node //栈的结构体

{

    BTree bt;

struct stack_node next;

} stack_list, stack_link;

struct queue_node //队列的结构体

{

    BTree bt;

    struct queue_node next;

};

typedef struct queue_node queue_list;

typedef queue_list queue_link;

//插入节点(非递归)

BTree insertNode(BTree root,int value)

{

    BTree newnode;

    BTree current;

    BTree back;

    newnode=(BTree)malloc(sizeof(struct treeNode));

    if(newnode==NULL)

    {

        printf("\n内存分配失败!\n");

        exit(1);

    }

    newnode->data=value;

    newnode->left=NULL;

    newnode->right=NULL;

    if(root==NULL)

    {

        return newnode;

    }

    else

    {

        current=root;

        while(current!=NULL)

        {

            back=current;

            if(current->data > value)

               current=current->left;

            else

               current=current->right;

        }

        if(back->data > value)

            back->left=newnode;

        else

            back->right=newnode;

    }

    return root;

}

BTree createTree() //创建二叉树(非递归)

{

    BTree root=NULL;

    int len;

    int num;

    int i;

    printf("请输入结点的个数: ");

    scanf("%d",&len);

    printf("请连续输入%d个数据(用空格隔开): ",len);

    for(i=0;i<len;i++)

    {

        scanf("%d",&num);

        root=insertNode(root,num);

    }

    return root;

}

//检查[队列]是否是空

int isQueueEmpty(queue_link front)

{

if(front == NULL)

    {

        return 1;

    }

    else

    {

        return 0;

    }

}

int enqueue(queue_link front,queue_link rear,BTree bt) //入队列

{

    queue_link new_node;

    new_node=(queue_link)malloc(sizeof(queue_list));

    if(new_node==NULL)

    {

        printf("\n内存分配失败!\n");

        exit(1);

    }

    new_node->bt=bt;

    new_node->next=NULL;

    if(rear == NULL)

    {

        front=new_node;

    }

    else

    {

        (rear)->next = new_node;

    }

    rear = new_node;

    return 1;

}

int dequeue(queue_link front,queue_link rear,BTree bt) //出队列

{

    queue_link top;

    if(front != NULL)

    {

        top = front;

        front = (front)->next;

        if(front == NULL)

        {

            rear = front;

        }

        bt=top->bt;

        free(top);

        return 0;

    }

    else

    {

        return -1;

    }

}

//检查[栈]是否是空

int isStackEmpty(stack_link stack)

{

if(stack == NULL)

    {

        return 1;

    }

    else

    {

        return 0;

    }

}

//入栈

stack_link push(stack_link stack,BTree bt)

{

stack_link new_node;

new_node=(stack_link)malloc(sizeof(stack_list));

if(!new_node)

{

return NULL;

}

new_node->bt=bt;

new_node->next=stack;

stack=new_node;

return stack;

}

//出栈

stack_link pop(stack_link stack,BTree bt)

{

stack_link top;

if(isStackEmpty(stack))

{

bt = NULL;

return NULL;

}

top=stack;

bt=top->bt;

stack=top->next;

free(top);

return stack;

}

void preOrderByStack(BTree bt) //先序遍历(非递归)

{

    BTree p=NULL;

    stack_link oneStack=NULL;

    if(bt == NULL) return;

    p=bt;          //当前二叉树的节点

    oneStack=push(oneStack,p);

    while(isStackEmpty(oneStack) != 1) //[栈]不是空

    {

        oneStack=pop(oneStack,&p); //出栈

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

        if(p->right != NULL)  //如果有右子树,入栈

        {

            oneStack=push(oneStack,p->right);

        }

        if(p->left != NULL) //如果有左子树,入栈

        {

            oneStack=push(oneStack,p->left);

        }

    }

}

void LevelDisp(BTree bt) //层序遍历(非递归)

{

    queue_link front=NULL;

    queue_link rear=NULL;

    BTree p=NULL;

    if(bt==NULL) return;

    p=bt;                    //当前二叉树的节点

    enqueue(&front,&rear,p); //入队

    while(isQueueEmpty(front) != 1) //[队列]不是空

    {

        dequeue(&front,&rear,&p); //出队

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

        if(p->left != NULL)

        {

            enqueue(&front,&rear,p->left); //左分支入队

        }

        if(p->right != NULL)

        {

            enqueue(&front,&rear,p->right); //右分支入队

        }

    }

}

int main()

{

    BTree root=NULL;

    root=createTree();//创建二叉树(非递归)

    printf("\n创建二叉树后");

    printf("\n先序遍历序列: ");

    preOrderByStack(root);

    printf("\n层序遍历序列: ");

    LevelDisp(root);

    printf("\n");

return 0;

}

以上就是关于数据结构程序设计(用c++)!!急求!!!全部的内容，包括:数据结构程序设计(用c++)!!急求!!!、什么叫结构化程序设计、赫夫曼OR哈弗曼编码 c语言 数据结构 简单的程序设计等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！