typedef适用范围（利用栈实现逆波兰表达式求值）

本文目录

• 利用栈实现逆波兰表达式求值
• java语言与c++相比,有哪些优点
• 矩阵压缩存储的应用（稀疏矩阵运算器）

利用栈实现逆波兰表达式求值

include 《malloc.h》
#include 《stdio.h》
#include 《ctype.h》//判断是否为字符的函数的头文件
#define maxsize 100
typedef int elemtype;
typedef struct sqstack sqstack;//由于sqstack不是一个类型 而struct sqstack才是
char ch={’+’,’-’,’*’,’/’,’(’,’)’,’#’};//把符号转换成一个字符数组
int f1={3,3,5,5,1,6,0};//栈内元素优先级
int f2={2,2,4,4,6,1,0};//栈外的元素优先级
struct sqstack
{
elemtype stack;
int top;
};
void Initstack(sqstack *s)
{
s-》top=0;
}
void Push(sqstack *s,elemtype x)
{
if(s-》top==maxsize-1)
printf("Overflow\n");
else
{
s-》top++;
s-》stack=x;
}
}
void Pop(sqstack *s,elemtype *x)
{
if(s-》top==0)
printf("underflow\n");
else
{
*x=s-》stack;
s-》top--;
}
}
elemtype Gettop(sqstack s)
{
if(s.top==0)
{
printf("underflow\n");
return 0;
}
else
return s.stack;
}
elemtype f(char c)
{
switch(c)
{
case ’+’:
return 0;
case ’-’:
return 1;
case ’*’:
return 2;
case ’/’:
return 3;
case ’(’:
return 4;
case ’)’:
return 5;
default:
return 6;
}
}
char precede(char c1,char c2)
{
int i1=f(c1);
int i2=f(c2);//把字符变成数字
if(f1)//通过原来设定找到优先级
return ’》’;
else if(f1)
return ’《’;
else
return ’=’;
}
int Operate(elemtype a,elemtype theta,elemtype b)
{
int sum;
switch(theta)
{
case 0:
sum=a+b;
break;
case 1:
sum=a-b;
break;
case 2:
sum=a*b;
break;
default:
sum=a/b;
}
return sum;
}
EvaluateExpression()
{
char c;
int i=0,sum=0;
int k=1,j=1;//设置了开关变量
elemtype x,theta,a,b;
sqstack OPTR,OPND;
Initstack(&OPTR);
Push(&OPTR,f(’#’));//0压入栈
Initstack(&OPND);
c=getchar();
if(c==ch)//先对＋和-的情况忽略和左括号的情况
{
printf("错误1 \n");
k=0;
return 0;
}
if(c==ch)
c=getchar();//如果是＋，把它覆盖
if(c==ch)
{
j=0;
c=getchar();//也把－号覆盖
}
while(c!=’#’||ch!=’#’)
{
if(isdigit(c))
{
sum=0;
while(isdigit(c))
{
if(!j)
{
sum=sum*10-(c-’0’);//实现了数字串前面有负号（之前是：sum=-(sum*10)-(c-’0’)结果是－12＋13＝21）
}
else
sum=sum*10+(c-’0’);
c=getchar();
}
Push(&OPND,sum);//如果还是数字先不压栈，把数字串转化成十进制数字再压栈
j=1;
}
else
if(k)
{
switch(precede(ch,c))
{
case’《’: Push(&OPTR,f(c));//把它们整型化
c=getchar();
if(c==ch||c==’\n’)//要除去下个是‘（’的情况 也把以运算符归到这里来
{
printf("出错2\n");
k=0;
return 0;//加了开关变量和返回0的值使程序更以操作
}
break;
case’=’: Pop(&OPTR,&x);
c=getchar();
if(c==ch的情况也忽略了但此时并没有注意到右括号后面右运算符的情况
{
printf("出错2\n");
k=0;
return 0;
}
break;
case’》’: Pop(&OPTR,θ);
Pop(&OPND,&b);
Pop(&OPND,&a);//注意这里是谁先出栈
Push(&OPND,Operate(a,theta,b));
break;
}
}
}//在这里判断是否以运算符结束是不对的
return(Gettop(OPND));
}
main()
{
int result;
printf("输入你的算术表达式：\n");
result=EvaluateExpression();
printf("结果是 :%d\n",result);
return 0;
}
【jixingzhong】:
本计算器利用堆栈来实现。
1、定义后缀式计算器的堆栈结构
因为需要存储的单元不多，这里使用顺序栈，即用一维数组来模拟堆栈：
#define MAX 100
int stack;
int top=0;
因此程序中定义了长度为MAX的一维数组，这里MAX用宏定义为常数100，我们可以修改宏定义而重新定义堆栈的大小。
整型数据top为栈顶指示，由于程序开始时堆栈中并无任何数据元素，因此top被初始化为0。
2、存储后缀式计算器的运算数
我们定义了堆栈stack后，就可以利用入栈操作存储先后输入的两个运算数。
下面看一下是如何实现的：
int push(int i) /*存储运算数，入栈操作*/
{
if(top《MAX)
{
stack=i; /*堆栈仍有空间，栈顶指示上移一个位置*/
return 0;
}
else /*堆栈已满，给出错误信息，返回出错指示*/
{
printf("The stack is full");
return ERR;
}
}
我们在调用函数push时，如果它的返回值为0，说明入栈操作成功；否则，若返回值为ERR(在程序中说明为-1)，说明入栈操作失败。
3、从堆栈中取出运算数
当程序中读完了四则运算符后，我们就可以从堆栈中取出已经存入的两个运算数，构成表达式，计算出结果。取出运算数的函数采用的正是出栈算法。在本例中，实现该算法的函数 为pop():
int pop(); /*取出运算数，出栈操作*/
{
int var; /*定义待返回的栈顶元素*/
if(top!=NULL) /*堆栈中仍有数据元素*/
{
var=stack; /*堆栈指示下移一个位置*/
return var;
}
else /*堆栈为空，给出错误信息，并返回出错返回值*/
printf("The stack is cmpty!\n");
return ERR;
}
同样，如果堆栈不为空，pop()函数返回堆栈顶端的数据元素，否则，给出栈空提示，并返回错误返回值ERR。
4、设计完整的后缀式计算器
有了堆栈存储运算数，后缀式计算器的设计就很简单了。程序首先提示用户输入第一个运算数，调用push()函数存入堆栈中；而后提示用户输入第二个运算数，同样调用push()函数存入堆栈中。接下来，程序提示用户输入+,-,*,/四种运算符的一种，程序通过switch_case结构判断输入运算符的种类，转而执行不同的处理代码。以除法为例，说明程序的执行流程：
case ’/’:
b=pop();
a=pop();
c=a/b;
printf("\n\nThe result is %d\n",c);
printf("\n");
break;
程序判断用户输入的是除号后，就执行上述代码。首先接连两次调用pop()函数从堆栈中读出先前输入的运算数，存入整型数a和b中；然后执行除法运算，结果存入单元c中。这时需要考虑究竟谁是被除数，谁是除数。由于开始我们先将被除数入栈，根据堆栈“先进后出”的原则，被除数应该是第二次调用pop()函数得到的返回值。而除数则是第一次调用pop()函数得到的返回值。
最后程序打印出运算结果，并示提示用户是否继续运行程序：
printf("\t Continue?(y/n):");
l=getche();
if(l==’n’)
exit(0);
如果用户回答是"n"，那么结束程序，否则继续循环。
完整的程序代码如下：
#include《stdio.h》
#include《conio.h》
#include《stdlib.h》
#define ERR -1
#define MAX 100 /*定义堆栈的大小*/
int stack; /*用一维数组定义堆栈*/
int top=0; /*定义堆栈指示*/
int push(int i) /*存储运算数,入栈操作*/
{
if(top《MAX)
{
stack=i; /*堆栈仍有空间，栈顶指示上移一个位置*/
return 0;
}
else
{
printf("The stack is full");
return ERR;
}
}
int pop() /*取出运算数，出栈操作*/
{
int var; /*定义待返回的栈顶元素*/
if(top!=NULL) /*堆栈中仍有元素*/
{
var=stack; /*堆栈指示下移一个位置*/
return var; /*返回栈顶元素*/
}
else
printf("The stack is empty!\n");
return ERR;
}
void main()
{
int m,n;
char l;
int a,b,c;
int k;
do{
printf("\tAriothmatic Operate simulator\n"); /*给出提示信息*/
printf("\n\tPlease input first number:"); /*输入第一个运算数*/
scanf("%d",&m);
push(m); /*第一个运算数入栈*/
printf("\n\tPlease input second number:"); /*输入第二个运算数*/
scanf("%d",&n);
push(n); /*第二个运算数入栈*/
printf("\n\tChoose operator(+/-/*//):");
l=getche(); /*输入运算符*/
switch(l) /*判断运算符，转而执行相应代码*/
{
case ’+’:
b=pop();
a=pop();
c=a+b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case ’-’:
b=pop();
a=pop();
c=a-b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case ’*’:
b=pop();
a=pop();
c=a*b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case ’/’:
b=pop();
a=pop();
c=a/b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
}
printf("\tContinue?(y/n):"); /*提示用户是否结束程序*/
l=getche();
if(l==’n’)
exit(0);
}while(1);
}
【studyall123】:
#include 《stdio.h》
#include 《conio.h》
#include 《malloc.h》
#include 《stdlib.h》
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#define STACK_INIT_SIZE 100 //初始分配量
#define STACKINCREMENT 10 //存储空间的分配增量
typedef char ElemType;
typedef ElemType OperandType; //操作数
typedef char OperatorType;
typedef struct
{
ElemType *base;
ElemType *top;
int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{
//构造一个空栈S
S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status GetTop(SqStack S){
ElemType e;
if (S.top == S.base) return ERROR;
e = *(S.top-1);
return e;
}
Status Push (SqStack &S,ElemType e)
{
//插入元素e为新的栈顶元素
if (S.top - S.base 》= S.stacksize){
S.base = (ElemType *) realloc ( S.base,
(S.stacksize + STACKINCREMENT) * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return OK;
}
Status Pop (SqStack &S,ElemType &e){
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(S.top == S.base) return ERROR;
e = * --S.top;
return OK;
}
char In(char c,char OP)
{
if(c》=35 && c《=47)
return 1;
else return 0;
}
char OP={’+’,’-’,’*’,’/’,’(’,’)’,’#’,’\0’};
int m={1,1,2,2,2,1,1,
1,1,2,2,2,1,1,
1,1,1,1,2,1,1,
1,1,1,1,2,1,1,
2,2,2,2,2,0,-1,
1,1,1,1,-1,1,1,
2,2,2,2,2,-1,0};//1 》 2 《 0 = -1 不存在
char Precede(char i,char j)
{
int a,b; char *p;
for(p=OP,a=0;*p!=’\0’;p++,a++)
if(*p==i) break;
for(p=OP,b=0;*p!=’\0’;p++,b++)
if(*p==j) break;
if(m==1) return ’》’;
else if(m==2) return ’《’;
else if(m==0) return ’=’;
else return ’O’;
}
char Operate(char a,char theta,char b)
{
if(a》47) a=atoi(&a);
if(b》47) b=atoi(&b);
switch(theta)
{
case ’+’: return a+b;
break;
case ’-’: return a-b;
break;
case ’*’: return a*b;
break;
case ’/’: return a/b;
break;
}
}
OperandType EvaluateExpression()
{
SqStack OPTR,OPND;
OperandType a,b,c; OperatorType theta;
InitStack(OPTR); Push(OPTR,’#’);
InitStack(OPND); c=getchar();
while (c!=’#’ || GetTop(OPTR)!=’#’)
{
if (!In(c,OP)){Push(OPND,c);c=getchar();}
else
switch(Precede(GetTop(OPTR),c))
{
case ’《’ :
Push(OPTR,c); c = getchar();
break;
case ’=’ :
Pop(OPTR,c); c = getchar();
break;
case ’》’ :
Pop(OPTR,theta);
Pop(OPND,b); Pop(OPND,a);
Push(OPND,Operate(a,theta,b));
break;
}
}
return GetTop(OPND);
}
void main()
{
printf("(以#为结束符)\n");
printf("请输入：\n");
int a;
a=(int)EvaluateExpression();
printf("%d",a);
getch();
}
【laiwusheng】:
ls都正确
【Jim_King_2000】:
C++ In Action这本书里面有表达式求值的详细项目分析.
【xlbdan】:
数据结构的书里面都有的,仔细看一下
【zpk1234】:
studyall123的只能对0到9的数字运算才有效,对于10以上的数字就不行!不知道有没有更好的方法!
【sjjf】:
现在的人，连google一下都懒啊
【aaron85】:
实际上是按照逆波兰式的顺序让输入的表达式入栈，再根据运算符优先级来计算。
【pomiox】:
lenrning!

java语言与c++相比,有哪些优点

JAVA和C++都是面向对象语言。也就是说，它们都能够实现面向对象思想（封装，继乘，多态）。而由于c++为了照顾大量的C语言使用者，而兼容了C，使得自身仅仅成为了带类的C语言，多多少少影响了其面向对象的彻底性！JAVA则是完全的面向对象语言，它句法更清晰，规模更小，更易学。它是在对多种程序设计语言进行了深入细致研究的基础上，摒弃了其他语言的不足之处，从根本上解决了c++的固有缺陷。
Java和c++的相似之处多于不同之处，但两种语言有几处主要的不同使得Java更容易学习，并且编程环境更为简单。
我在这里不能完全列出不同之处，仅列出比较显著的区别：
1．指针
JAVA语言让编程者无法找到指针来直接访问内存无指针，并且增添了自动的内存管理功能，从而有效地防止了c／c++语言中指针操作失误，如野指针所造成的系统崩溃。但也不是说JAVA没有指针，虚拟机内部还是使用了指针，只是外人不得使用而已。这有利于Java程序的安全。
2．多重继承
c++支持多重继承，这是c++的一个特征，它允许多父类派生一个类。尽管多重继承功能很强，但使用复杂，而且会引起许多麻烦，编译程序实现它也很不容易。Java不支持多重继承，但允许一个类继承多个接口(extends+implement)，实现了c++多重继承的功能，又避免了c++中的多重继承实现方式带来的诸多不便。
3．数据类型及类
Java是完全面向对象的语言，所有函数和变量都必须是类的一部分。除了基本数据类型之外，其余的都作为类对象，包括数组。对象将数据和方法结合起来，把它们封装在类中，这样每个对象都可实现自己的特点和行为。而c++允许将函数和变量定义为全局的。此外，Java中取消了c／c++中的结构和联合，消除了不必要的麻烦。
4．自动内存管理
Java程序中所有的对象都是用new操作符建立在内存堆栈上，这个操作符类似于c++的new操作符。下面的语句由一个建立了一个类Read的对象，然后调用该对象的work方法：
Read r＝new Read()；
r.work()；
语句Read r＝new Read()；在堆栈结构上建立了一个Read的实例。Java自动进行无用内存回收操作，不需要程序员进行删除。而c十十中必须由程序员释放内存资源，增加了程序设计者的负担。Java中当一个对象不被再用到时，无用内存回收器将给它加上标签以示删除。JAVA里无用内存回收程序是以线程方式在后台运行的，利用空闲时间工作。
5．操作符重载
Java不支持操作符重载。操作符重载被认为是c十十的突出特征，在Java中虽然类大体上可以实现这样的功能，但操作符重载的方便性仍然丢失了不少。Java语言不支持操作符重载是为了保持Java语言尽可能简单。
6．预处理功能
Java不支持预处理功能。c／c十十在编译过程中都有一个预编泽阶段，即众所周知的预处理器。预处理器为开发人员提供了方便，但增加了编译的复杂性。JAVA虚拟机没有预处理器，但它提供的引入语句(import)与c十十预处理器的功能类似。
7. Java不支持缺省函数参数，而c十十支持
在c中，代码组织在函数中，函数可以访问程序的全局变量。c十十增加了类，提供了类算法，该算法是与类相连的函数，c十十类方法与Java类方法十分相似，然而，由于c十十仍然支持c，所以不能阻止c十十开发人员使用函数，结果函数和方法混合使用使得程序比较混乱。
Java没有函数，作为一个比c十十更纯的面向对象的语言，Java强迫开发人员把所有例行程序包括在类中，事实上，用方法实现例行程序可激励开发人员更好地组织编码。
8 字符串
c和c十十不支持字符串变量，在c和c十十程序中使用Null终止符代表字符串的结束，在Java中字符串是用类对象(string和stringBuffer)来实现的，这些类对象是Java语言的核心，用类对象实现字符串有以下几个优点：
(1)在整个系统中建立字符串和访问字符串元素的方法是一致的；
(2)J3阳字符串类是作为Java语言的一部分定义的，而不是作为外加的延伸部分；
(3)Java字符串执行运行时检空，可帮助排除一些运行时发生的错误；
(4)可对字符串用“十”进行连接操作。
9“goto语句
“可怕”的goto语句是c和c++的“遗物”，它是该语言技术上的合法部分，引用goto语句引起了程序结构的混乱，不易理解，goto语句子要用于无条件转移子程序和多结构分支技术。鉴于以广理由，Java不提供goto语句，它虽然指定goto作为关键字，但不支持它的使用，使程序简洁易读。
l0．类型转换
在c和c十十中有时出现数据类型的隐含转换，这就涉及了自动强制类型转换问题。例如，在c十十中可将一浮点值赋予整型变量，并去掉其尾数。Java不支持c十十中的自动强制类型转换，如果需要，必须由程序显式进行强制类型转换。
11.异常
JAVA中的异常机制用于捕获例外事件，增强系统容错能力
try{／／可能产生例外的代码
}catch(exceptionType name){
//处理
}
其中exceptionType表示异常类型。而C++则没有如此方便的机制。
附:
Java群体每天都在扩大，它既包括一些世界最大的ISV，也包括公司CIO、信息技术人员、系统分析人员、C/S开发人员、编程人员、多媒体设计者、市场行销人员、教育工作者、经理、影视生产者甚至业余爱好者等广泛的用户。从传统上看，这样一些人在一起有效地工作是不多见的。当我们谈到开放系统时，我们往往是就已发表的API及规格，或者源码的可得性，或者硬件、联网及操作系统而言的，没有一个人是从人的开放意义上来谈的。Java完成了开放系统的闭合链。它开发了人力资源，而反过来又开辟了共同工作的道路。
一谈到Java，人们马上会想起一种类似于C++的、适用于分布环境的面向对象编程语言，想到这种语言的简单、稳定、安全、与体系结构无关、可移植、可解释、高性能、多线程和动态性等特征。这些都是Java作为一种程序设计语言的主要特征。
Java是由Sun公司的一个技术小组研制出来的。在实现Java语言的过程中，Sun小组的技术人员很快就意识到:C++无法成为一种完全面向对象的、网络化的开发语言。C++是通过给原先的C语言增加面向对象功能而开发出来的，因此,它存在着先天不足。这主要体现在C++种类繁多，功能大量冗余，同时又没有任何一种C++编译器能够支持它的全部功能。鉴于这种情况，Sun公司的技术人员决定不扩充C++，而开发一种全新的计算机语言(Java的前身Oak)。但是，C++已经成了大多数编程人员所熟练掌握的语言，Java的设计显然不能无视这个现实。如果Java和C++之间的差别过大，那么程序员们在学会这种语言的过程中无疑要花费大量的时间和精力。因此，Java保留了尽可能多的C++风格。
Java自诞生起，为网络用户创造了无数客户端的小应用程序，由于这类应用程序效果良好、数量巨大，以至于许多用户想到Java编程语言时，会在脑海中出现一个不完全正确的印象-Java是用来编写小的客户端程序的。其实，随着技术的进步，Java语言正在逐步改变自己执行效率较低、无法担任企业关键计算任务的形象，不断向计算技术的核心地带前进。今天的Java技术正沿着网络渗入各个应用领域。
企业计算：企业计算是Java最重要的技术主题。Sun公司已经公布了企业JavaBean（EJB，Enterprise JavaBean）的规格，随后众多公司开始开发企业应用领域的Java技术。IBM公司也已经为Windows NT开发了IBM HPCJ（High Performance Compiler for Java）12.0版，同时研制了IBM JDK（JavaDevelopment Kit）for Windows NT，Novell公司也在宣布了一个新的服务器端的企业Java平台，而Sun公司也在积极地升级自己的JDK系统，这个形势表明，Java正在稳步走向企业高端计算。对于Java来说，与其它编程语言争夺企业计算主力编程工具的优势在于：其一，Java在进行面向对象的编程工作时，比其它的编程语言如C++更加简单，因此保证了编程的高效率，减少了编程投入；其二，Java虚拟机技术所提供的"一次编程，到处使用"的跨平台能力非常适合网络环境，这给Java在网络服务器端的发展提供了便利条件；其三，Java拥有强大的提供商和支持者队伍，该队伍包括IBM、Oracle、Novell、Sybase和Netscape等公司。
提速运行：许多企业的应用开发人员非常喜爱Java的语言特性，但是在开发重要系统时，语言特性和执行效率之间的抉择往往令人伤透脑筋。在关键计算中，用户可能并不在乎数据如何压缩或者运行的延迟关系如何设置，但是对程序的运行速度却非常重视，这使厂商将Java的编译策略开发放在了首位。现在的Java语言，其执行方式已经不仅仅是解释执行方式了，即时编译器（JITC、just-in-time compiler）技术和原型编译技术已经被许多厂家采用，包括Sun、IBM、Oracle以及Netscape等公司在内的技术提供商正在利用这些技术逐步提高Java的执行速度，其中IBM公司早已将Java虚拟机（JVM，JavaVirtual Machine）、操作系统和硬件的特性有机的结合在一起，非常有效地提高了Java的执行效率。
嵌入计算：嵌入式Java是一个潜力巨大的应用技术，该技术充分发挥了Java小巧灵活的特点。以HP公司为例，该公司以自己的方式制造编译工具和Java虚拟机，其目的是将Java嵌入各种设备，如打印机、医学监视器和自动提款机等。嵌入设备依靠一个实时操作系统来处理某一个实时生效的事件，Java被嵌入这些设备后，通过实时扩展（real-time extension）开始发挥作用，使设备具备了一定的智能性，增强了嵌入设备的可管理性和可用性，大大提高了设备的工作效率。各厂商对这一潜力巨大的市场都非常重视，目前该市场缺乏的是一个标准，如果存在标准的话，相信很快就会有大量使用嵌入Java技术的设备上市。
微软刚刚发行的Windows XP放弃了对Java的支持，但Java能够独立运行于很多操作平台上，其中也包括Linux，并且在某些特性上要比在Windows上发挥得更好，我们完全有理由抛弃Windows而选择使用Linux来做Java开发。现在，你可以左手拿着Linux，右手拿着Java，然后对面带微笑手里拿着Windows XP的Bill Gates说："让你的XP去见鬼吧！"
对于软件开发者来讲，任何一种编程语言都不可能是完美的。如果希望更好地理解Java语言，最好的方法是把这种语言与其同类型的语言相比较。既然Java类似于C++，把它同C++进行一番比较也是顺理成章的事情,哪一个好，哪一个不好，每个开发人员都有各自的看法。我个人认为Java开发要比C++好一些。当然每个人的看法和喜好是不同的。后面的文章将向大家介绍Java和C++的不同和对其的改进。孰强孰弱，大家自然就会明白了。
我们知道，Java一开始采用C++的语法格式，基本上是为了让程序设计者可以很快地熟悉 Java的语法格式，缩短学习Java的时间，毕竟C和C++仍旧是最多人会的一种程序语言。但是如果我们仔细检查Java程序语言的许多细节设计，我们可以发现Java去掉了不少C++的特点，并且加入一些新的特性。这些与C++的差异包括：
1.不再有#define、#include等预处理程序(Preprocessor)的功能
C++语言很重要的一个特点就是它的预处理程序。有些其他程序语言虽然也加入了#include的功能，但是还是欠缺处理宏(Macro)的能力。#define的功能在Java中我们可以用定义常数(constant)的方式来取代，而#include在Java中是不需要的，因为在Java中程序在执行时，会把类型数据记录在对象实体之中，我们不需要靠一些标头文件(header file)来知道我们使用的对象或数值是属于什么数据类型。
如果你使用C++语言时，只使用预处理程序的#include和#define功能的话，那么你大概不会觉得Java这样的设计对你产生什么样的困扰，但是如果你是使用C++语言预处理程序中宏功能的高手，你可能会觉得很不方便，进而怀疑Java如此设计的意义何在。
使用预处理程序虽然可以很方便地达到许多功能，但是站在软件工程的角度上看，对整个软件的维护其实是很不利的。由于C++语言中预处理程序的功能太过强大，厉害的程序设计高手常会自行开发一套只有自己看的懂的宏语言，一旦整个软件要交给其他人去维护，后继者很难在短时间内了解前一个人所写下的宏功能，增加软件开发时团队工作及日后维护的困难度。
另外一点则是C++语言的编译器所看到的程序代码，其实和程序设计者看到的程序代码是不同的。程序设计者看到的是尚未经过预处理程序处理过的程序代码，而编译器看到的则是预处理程序处理过的程序代码，一旦交给预处理程序处理的宏内容有误，编译器产生的错误信息将不会是程序设计师所预料的。而这一点自然也增加了程序在排错时的困难度。
预处理程序的存在也造成了阅读程序的不便。如果你想使用别人已经完成的C++语言程序，那么通常你不但要阅读他所写下的文件，还必须一并查阅上文件，才能了解其程序的全貌。如果换成是Java程序，只要查看java的程序文件就够了。
2.不再有structure、union及typedef
事实上，早在C++中就可以去掉C语言中的structure和union等对复杂数据的自定结构类型，因为类(Class)的定义方式可以完全做到这项功能。而typedef也是不必要的，一切都用类就可以了。虽然C++这样的设计是为了和C语言兼容，但是使用多余的语言特点不但不必要，而且容易造成对程序认识的混淆。
3.不再有函数
在Java程序语言中，去掉了程序向导语言中最重要的单元--函数(Function)。如果我们以对象向导的观念来看待函数，就可以了解函数在对象向导的概念中，是不必要的。在对象向导的程序观念里，对象的数据才是真正的主体，而处理对象数据的方法则必须依附在对象内才有意义。因此，去掉函数并不表示不再有子程序等模组化程 序的概念，相反地，是利用对象中的方法来取代函数，再一次强化对向导的发展策略。
4.不再有多重继承(Multiplelnheritance)
在C++中，多重继承是一项很强的功能，但也是一般人难以掌控的部分。去掉多重继承虽然降低了Java语言的功能，但是也大幅简化撰写程序时的困难度。虽然移除了多重继承的功能，但是Java提供了interface的方式，可以达到部分多重继承的功用。所谓的interface基本上定义了一个类的对外沟通的方法原型，以及类内部的常 数，和多重继承不同之处在于interface并不会定义类方法的内容，以及类中的变量数据。
5.不再有Goto
在程序语言的发展史上，Goto一直是毁誉参半的一项功能。在很多时候使用Goto可以大幅减少不必要的程序代码，但是也由于Goto可以很自由地改变程序的流程，如果冒然地使用，更可能造成程序结构混乱的情况。一般来说，正确使用Goto的例子多出现在循环内部，想要提早结束某一层循环。在C语言中，我们可以使用break 或contine来改变某一层循环的流程， 但如果想要改变两层以上的环执行流程，不是使用Goto就是以多余的布尔(boolean)变量，配合上一串if-then-else的判断来达成。
Java一方面移除了Goto的功能， 而另一方面同时扩大了break和continue的功能，可以允许多层循环的break或continue。如此一来不但避免了滥用Goto的可能性，同时也保存下Goto的好处。
6.不再有OperatorOverloading
在C++中，Operator Overloading同样也是一项值得讨论的设计。几乎在所有C++的书中，都会引用一些例子，告诉你使用OperatorOverloading可以使你的程序看起来更为自然。如下面是一个程序设计师自定义的复数类：
//C++中自定义的复数类及0pemtor Overloading
class Complex{
public：
Complex(double real,double image){
Real_number=real；
Image_number=image；
}
Complex operator+(Complex&rhs){
Return Complex(rhs．real_number+real_number，
rhs．image_number+image_，nulnbef)；
}
private：
doublereal_number //实部
doublejmage_nunmber； //虚部
}
在这里，如果你使用+来作为复数的加法符号，大家都不会有疑义，但是如果你使用的是*或》这样的符号，那么别人看到你的程序之后，难保不会产生认识上的错误。这也是Operator Overloading一大问题，当大家都对运算符赋予自己的定义后，整个程序的可读性就会大受影响。Operator Overloading的存在并不是必要的，我们一样可以定义类中的方法来达到同样的目的，至于Java去掉这项功能的利弊，恐怕就要读者自己去评断了。
7.取消自动类型转换
Java是一个严格进行类型检查的程序语言，对于下面这样的程序，在C++的编译器上编译时最多只会出现警告的信息，但是在Java里则不予通过：
Int aInteger； Double aDouble=2.71828； AInteger = aDouble；
虽然这样的转型在C++里是合法的，但是也会造成数据精确度的损失。Java为了要确定写程序的人充分地了解这点，必须要程序设计强制转型(type casting)，Java的编译器才会接受：
int aInteger；
doublea Double=2.71828；
aInteger=(int)aDouble；
8.不再有指针
取消指针(Pointer)这样数据类型，可能会让许多熟悉C++语言的程序设计师大吃一惊。在C++语言里，灵活地运用指针是许多程序设计师的得意之作，但是占整个除错时间最久的也是指针的问题。配合上C++对内存管理的态度，程序设计师必须要自己去追踪自己向系统要到的内存，最后确实地交还给系统，并且在使用指针时，要小心翼翼地注意不要跨过合法的记忆空间，造成Segmentation Fault或General Protection Fault之类的问题。
Java去掉了指针类型，并不表示程序设计师在开发高级数据结构，像堆栈(stack)、 队列(queue)、二元树(binarytree)时，都必须要像在传统Basic上，利用大范围的数组来自行模拟系统内存，自行建构类似指针的表示方式。
相反地，Java提供了和Lisp语言中相似的Reference类型，通过Reference去读取配置到的内存内容，可以确保不会去读取到不属于自己的内存空间，而另一方面，程序的执行系统也可以动态地去做内存垃圾回收的工作，将没有被reference参考到的内存空间回收给系统使用。
9.和C++连接
不管Java是多么强大，总是有人需要把它和C++连接起来。因为只要有一个新的程序语言或是软件开发工具一出现，大家就会问："它是否具有和原有程序库连接的能力呢?"也因为C++语言在电脑界中占了很重要的地位。大家的问题其实就等于是直接问"它是否可以和C++连接?"。目前在Java中，的确提供了和C++语言连接的方法，它的做法基本上是先将C++语言所写的程序建构成动态链接函数库(DynamicLinking Library，DLL)，再由Java程序去调用DLL里的函数。
这种连接的方式，使得DLL中的函数，从Java的眼光看就是一个"方法"。不过因为这种方法是直接由其他的程序语言所提供，而不是以Java语言所写的，所以它被称之为"原生方法"(NativeMethod)。
由于Java Applet一些安全上的限制，所以这种连接外部程序的方法只能用在Java Application内。
小结：
事实上，constant和typedef这两条语句包含了#define语句的作用。现在，结构和联合已经被Java的类所代替。删除这些特性的原因是:由于其希望维持与C语言的向后兼容性，C ++的语言规范包含了大量冗余。比如，类实际上就已经包括了结构和联合的作用，因此这两种数据结构完全可以取消。关于#define语句，Java语言规范的制订者认为:尽管该语句的出发点是为了增强程序的可读性，但实际效果却恰恰相反，它常常导致难读的代码，故应该予以取消。Java不再支持独立函数，因此任何函数都必须封装到某个类中。由于人们普遍认为， C++所用的超类是非常不稳定的，因此Java抛弃了C++中的多继承并代之以接口。Java的接口指的是，在别的类看来一个类所能实现的方法。它所显示的只是一个类的方法或常量和变量 ，而不是这个类的全部结构。
最后，Java还取消了C++中的GOTO语句、操作符重载、自动类型转换及指针数据类型。 GOTO语句引起的争议已经有很多年了，可一直阴魂不散，这跟某些程序员对该语句一直情有独钟有关。C++仍然支持数据类型的自动转换，但Java要求编程人员显式实现数据类型之间的转换。自动数据类型转换使得两个数据类型互不兼容的变量可以相互赋值，而不需要给出显式说明。这有时会导致一些问题，其中最常见的是精确度损失。比方说，如果把一个带符号的32位整数赋给一个无符号整数，则所有的结果均为正数。Java的设计者们认为这很容易引起程序错误，从而决定不支持这种转换方式。

矩阵压缩存储的应用（稀疏矩阵运算器）

我给你源码记得顶我啊！！最主要的是把分给我哦！！
include《time.h》/*用于下面的srand((unsigned)time(NULL));函数的头文件*/
#include《stdio.h》
#include《stdlib.h》
#define MAX_ARRAY_DIM 2
#define MAXSIZE 100
typedef struct
{
int aa;
int dim;
int *base;
}array;
typedef struct
{
int i,j;/*记录非零元的行与列坐标*/
int e;/*记录非零原的数值*/
}triple;/*构成非零元素*/
typedef struct
{
triple data;/*预期非零原最大个数*/
int *rpos;/*记录各行第一个非零原的位置表*/
int mu,nu,tu;/*记录稀疏矩阵的行列和非零原个数*/
}tsmatrix;
main()
{
void initarray(array *a);/*数组初始化*/
void createsMatrix(array *a);/*创建稀疏矩阵*/
void inittsmatrix(array *a,tsmatrix *m);/*初始化稀疏矩阵三元组*/
void outputtsmatrix(tsmatrix *m);/*输出稀疏矩阵*/
void destroysmatrix(array *a);/*销毁稀疏矩阵*/
void outputarray(array *a);/*输出数组*/
void subtmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q);/*系数矩阵相减*/
void addsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q);/*系数矩阵相加*/
void multsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q);/*稀疏矩阵相乘*/
array a;
tsmatrix m,n,q;
int flag1=1,i;
srand((unsigned)time(NULL));
initarray(&a);/*初始化数组*/
createsMatrix(&a);/*创建稀疏矩阵*/
inittsmatrix(&a,&m);/*初始化稀疏矩阵三元组*/
outputtsmatrix(&m);/*输出稀疏矩阵*/
outputarray(&a);/*输出数组*/
destroysmatrix(&a);/*销毁原数组*/
initarray(&a);/*初始化数组*/
createsMatrix(&a);/*创建稀疏矩阵*/
inittsmatrix(&a,&n);/*初始化稀疏矩阵三元组*/
outputtsmatrix(&n);/*输出稀疏矩阵*/
outputarray(&a);/*输出数组*/
destroysmatrix(&a);/*销毁原数组*/
printf("2个三元数组已经创建成功，您要进行什么操作？\n1.(m+n)\n2.(m-n)\n3.(m*n)\n4.(n-m)\n");
while(flag1)
{
fflush(stdin);
scanf("%d",&i);
switch(i)
{
case 1:addsmatrix(&m,&n,&q);flag1=0;break;
case 2:subtmatrix(&m,&n,&q);flag1=0;break;
case 3:multsmatrix(&m,&n,&q);flag1=0;break;
case 4:subtmatrix(&n,&m,&q);flag1=0;break;
default:printf("输入错误请重新输入\n您要进行什么操作？1.(m+n)\n2.(m-n)\n3.(m*n)\n4.(n-m)\n\n");
}
}
printf("运算结果为\n");
outputtsmatrix(&q);/*输出运算结果*/
}
void initarray(array *a)/*创建数组*/
{
int i,j;
printf("请输入要创建的维数,(由于这里的作用是创建稀疏矩阵，建议输入2)\n");
scanf("%d",&a-》dim);
if(a-》dim!=MAX_ARRAY_DIM)
{
printf("输入维数超过界限\n");
exit(1);
}
for(i=0;i《a-》dim;i++)
{
printf("请输入第%d维的数据",i+1);
scanf("%d",&a-》aa);
if(a-》aa《1)
{
printf("输入超过范围\n");
exit(1);
}
}
j=1;
for(i=0;i《a-》dim;i++)
j*=a-》aa;
if(!(a-》base=(int *)malloc(j*sizeof(int))))
{
printf("开辟空间失败\n");
exit(1);
}
printf("数组创建成功\n");
}
void createsMatrix(array *a)/*创建稀疏矩阵*/
{
int i,j,k,l,m,n,flag1;
printf("是手动输入还是电脑自行创建？\n选1.电脑自行创建\n选0.手动创建\n");
scanf("%d",&i);
if(i!=1&&i!=0)
{
printf("输入格式错误\n");
exit(1);
}
if(i==0)/*手动输入*/
{
printf("请输入\n");
for(j=0;j《a-》aa;j++)
{
for(k=0;k《a-》aa;k++)
scanf("%d",&a-》base);
printf("\n");
}
}
else/*电脑自动输入*/
{
l=rand()%(a-》aa/4)+1;/*预期计算要输入多少个非零元*/
for(j=0;j《a-》aa;j++)/*先将程序中所有的元素赋予0*/
for(k=0;k《a-》aa;k++)
a-》base=0;
m=0;
while(m《l)/*输入l个非零元*/
{
flag1=1;
while(flag1)/*被赋予的元素原本必须是零*/
{
i=rand()%a-》aa;/*自动选择行*/
j=rand()%a-》aa;/*自动选择列*/
if(a-》base==0)/*所选择的元素是0*/
flag1=0;/*推出循环，否则继续循环直到，是零为止*/
}
flag1=1;
a-》base=rand()%10;/*赋值10以内*/
n=rand()%10;
if(n《5)
a-》base*=-1;/*输入正负*/
m++;
}
}
}
void inittsmatrix(array *a,tsmatrix *m)/*稀疏矩阵非零原初始化*/
{
int i,j,k=0,*num;
for(i=0;i《a-》aa;i++)/*输入非零原坐标及数据*/
for(j=0;j《a-》aa;j++)
if(a-》base!=0)
{
m-》data.i=i+1;
m-》data.j=j+1;
m-》data;
k++;
}
m-》mu=a-》aa;/*记录行*/
m-》nu=a-》aa;/*记录列*/
m-》tu=k;/*记录非零原数量*/
if(!(num=(int *)malloc((m-》mu+1)*sizeof(int))))/*num用于记录每行的非零原的个数*/
{
printf("空间开辟失败\n");
exit(1);
}
if(!(m-》rpos=(int *)malloc((m-》mu+1)*sizeof(int))))/*本人认为数据结构上的rpos定义有错误，如果某一行全都是非零元那m-》rpos所以以下的rpos操作可能与书上的原意不符*/
{
printf("空间开辟失败\n");
exit(1);
}
for(i=0;i《=m-》mu;i++)/*初始化num*/
num=0;
for(i=1;i《=m-》tu;i++)/*记录每行非零原的个数*/
++num;
if(num=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
m-》rpos=0;
j=0;
}
else/*否则记1*/
{
m-》rpos=1;
j=num;
}
for(i=2;i《=m-》mu;i++)/*运算*/
{
if(num==0)
m-》rpos=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
m-》rpos=j+1;
j+=num;
}
if(j》=m-》tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i《=m-》mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
i++,m-》rpos=0;
}
void outputtsmatrix(tsmatrix *m)/*输出稀疏矩阵*/
{
int i;
printf("三元组表为\n");
for(i=1;i《=m-》tu;i++)
printf("%d行 %d列 %d\n",m-》data.e);
printf("行为%d列为%d\n",m-》mu,m-》nu);
for(i=1;i《=m-》mu;i++)
printf("%d行的第一个元素所在位置表的位置是%d\n",i,m-》rpos);
}
void destroysmatrix(array *a)/*销毁稀疏矩阵*/
{
if(!a-》base)exit(1);
free(a-》base);a-》base=NULL;
printf("\n稀疏矩阵数组销毁成功(*^__^*) \n\n");
}
void outputarray(array *a)/*输出数组*/
{
int i,j;
for(i=0;i《a-》aa;i++)
{
for(j=0;j《a-》aa;j++)
printf("%2d ",a-》base);
printf("\n");
}
}
void copysmatrix(tsmatrix *m,tsmatrix *t)/*复制稀疏矩阵*/
{
int i;
t-》mu=m-》mu,t-》nu=m-》nu,t-》tu=m-》tu;
if(!(t-》rpos=(int *)malloc((t-》mu+1)*sizeof(int))))
{
printf("开辟控件失败\n");
exit(1);
}
if(t-》tu)
{
for(i=1;i《=m-》tu;i++)
{
t-》data.i;
t-》data.j;
t-》data.e;
}
}
for(i=1;i《=t-》mu;i++)
t-》rpos;
}
void subtmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q)/*稀疏矩阵相减*/
{
int i,j,k,a,b,c,x,y,z,*num;
q-》mu=m-》mu》n-》mu?m-》mu:n-》mu;
q-》nu=m-》nu》n-》nu?m-》nu:n-》nu;
q-》tu=0;
if(!(num=(int *)malloc((q-》mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
if(!(q-》rpos=(int *)malloc((q-》mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
for(i=1;i《=q-》mu;i++)
num=0;
if(m-》tu==0)
copysmatrix(n,q);
else if(n-》tu==0)
copysmatrix(m,q);
else
{
i=j=k=1;
while(i《=m-》tu&&j《=n-》tu)
{
a=m-》data.i;
b=m-》data.j;
c=m-》data.e;/*分别记录m的3元组的数据*/
x=n-》data.i;
y=n-》data.j;
z=n-》data.e;
if(a==x)/*如果m,n行相等*/
{
if(b==y)/*如果行列都相等*/
{
if(c-z!=0)/*如果m-n!=0*/
{
num++;
q-》data.i=a;
q-》data.j=b;
q-》data.e=c-z;
k++;
}
i++,j++;/*无论是否m-n==0i,j都要+1*/
}
else if(b《y)/*如果行相等但是列不相等q下一个三元组应该取坐标相对较小的*/
{
num++;
q-》data.i=a;
q-》data.j=b;
q-》data.e=c;
k++;
i++;
}
else if(b》y)
{
num++;
q-》data.i=x;
q-》data.j=y;
q-》data.e=-z;
k++;j++;
}
else
printf("不可能出现的事情\n");
}
else if(a》x)
{
num++;
q-》data.i=x;
q-》data.j=y;
q-》data.e=-z;
k++;j++;
}
else if(a《x)
{
num++;
q-》data.i=a;
q-》data.j=b;
q-》data.e=c;
k++;i++;
}
else
printf("不可能发生的事情\n");
}
if(i》m-》tu&&j《=n-》tu)/*如果m的三元组记录完了但是n的三元组没有记录完那么剩下的应该全复制*/
{
while(j《=n-》tu)
{
num++;
q-》data.i;
q-》data.j;
q-》data.e;
}
}
else if(j》n-》tu&&i《=m-》tu)/*如果n的三元组记录完了但是m的三元组没有记录完那么剩下的应该全复制*/
{
while(i《=m-》tu)
{
n-》data.i;
q-》data.i;
q-》data.j;
q-》data.e;
}
}
q-》tu=k-1;
if(num=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
q-》rpos=0;
j=0;
}
else/*否则记1*/
{
q-》rpos=1;
j=num;
}
for(i=2;i《=q-》mu;i++)/*运算*/
{
if(num==0)
q-》rpos=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
q-》rpos=j+1;
j+=num;
}
if(j》=q-》tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i《=q-》mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
{
i++;
q-》rpos=0;
}
}
}
void addsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q)/*稀疏矩阵相加*/
{
int i,j,k,a,b,c,x,y,z,*num;
q-》mu=m-》mu》n-》mu?m-》mu:n-》mu;
q-》nu=m-》nu》n-》nu?m-》nu:n-》nu;
q-》tu=0;
if(!(num=(int *)malloc((q-》mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
if(!(q-》rpos=(int *)malloc((q-》mu+1)*sizeof(int))))
{
printf("创建空间失败\n");
exit(1);
}
for(i=1;i《=q-》mu;i++)
num=0;
if(m-》tu==0)
copysmatrix(n,q);
else if(n-》tu==0)
copysmatrix(m,q);
else
{
i=j=k=1;
while(i《=m-》tu&&j《=n-》tu)
{
a=m-》data.i;
b=m-》data.j;
c=m-》data.e;/*分别记录m的3元组的数据*/
x=n-》data.i;
y=n-》data.j;
z=n-》data.e;
if(a==x)/*如果m,n行相等*/
{
if(b==y)/*如果行列都相等*/
{
if(c+z!=0)/*如果m+n!=0*/
{
num++;
q-》data.i=a;
q-》data.j=b;
q-》data.e=c+z;
k++;
}
i++,j++;/*无论是否m+n==0i,j都要+1*/
}
else if(b《y)/*如果行相等但是列不相等q下一个三元组应该取坐标相对较小的*/
{
num++;
q-》data.i=a;
q-》data.j=b;
q-》data.e=c;
k++;
i++;
}
else if(b》y)
{
num++;
q-》data.i=x;
q-》data.j=y;
q-》data.e=z;
k++;j++;
}
else
printf("不可能出现的事情\n");
}
else if(a》x)
{
num++;
q-》data.i=x;
q-》data.j=y;
q-》data.e=z;
k++;j++;
}
else if(a《x)
{
num++;
q-》data.i=a;
q-》data.j=b;
q-》data.e=c;
k++;i++;
}
else
printf("不可能发生的事情\n");
}
if(i》m-》tu&&j《=n-》tu)/*如果m的三元组记录完了但是n的三元组没有记录完那么剩下的应该全复制*/
{
while(j《=n-》tu)
{
num++;
q-》data.i;
q-》data.j;
q-》data.e;
}
}
else if(j》n-》tu&&i《=m-》tu)/*如果n的三元组记录完了但是m的三元组没有记录完那么剩下的应该全复制*/
{
while(i《=m-》tu)
{
n-》data.i;
q-》data.i;
q-》data.j;
q-》data.e;
}
}
q-》tu=k-1;
if(num=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
q-》rpos=0;
j=0;
}
else/*否则记1*/
{
q-》rpos=1;
j=num;
}
for(i=2;i《=q-》mu;i++)/*运算*/
{
if(num==0)
q-》rpos=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
q-》rpos=j+1;
j+=num;
}
if(j》=q-》tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i《=q-》mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
{
i++;
q-》rpos=0;
}
}
}
void multsmatrix(tsmatrix *m,tsmatrix *n,tsmatrix *q)/*稀疏矩阵相乘*/
{
int i,j,k,l,o,p,x,y,*a,*num;
if(!(a=(int *)malloc(((m-》mu+1)*(n-》nu+1))*sizeof(int))))/*创建一个跟q相同大小的空间用来记录此坐标是否已经输入一个数*/
{
printf("开辟空间失败\n");
exit(1);
}
if(m-》nu!=n-》mu)
{
printf("不匹配\n");
exit(1);
}
q-》mu=m-》mu,q-》nu=n-》nu,q-》tu=0;/*初始化*/
if(!(num=(int *)malloc((m-》mu+1)*sizeof(int))))
{
printf("开辟空间失败\n");
exit(1);
}
if(!(q-》rpos=(int *)malloc((q-》mu+1)*sizeof(int))))
{
printf("空间开辟失败");
exit(1);
}
for(i=1;i《=q-》mu;i++)
num=0;
if(m-》tu*n-》tu!=0)
{
for(i=1;i《=m-》mu;i++)/*初始化a数组*/
for(j=1;j《=n-》nu;j++)
a=0;
for(i=1;i《=m-》tu;i++)
{
o=m-》data.i;
p=m-》data.j;
if(n-》rpos==0)
continue;
l=p+1;
while(n-》rpos==0&&l《=n-》mu)
l++;
if(l》n-》mu)
j=n-》tu+1;
else
j=n-》rpos;
for(k=n-》rpos;k《j;k++)/*k-j的范围是本行非零远的个数*/
{
x=n-》data的行和列*/
y=n-》data.j;
if(a!=0)
q-》data.e;/*如果此空间已经输入一个数了，那么在相应的位置累加*/
else
{
q-》data.e;
q-》data.i=o;
q-》data.j=y;
a=q-》tu;/*此位置记录q-》tu*/
num++;
}
}
}
for(i=1;i《=q-》mu;i++)
printf("%d ",num);
if(num=0，这就是我修改的原因，如果按照书上写的话，那应该是1，对以后的操作有麻烦*/
{
q-》rpos=0;
j=0;
}
else/*否则记1*/
{
q-》rpos=1;
j=num;
}
for(i=2;i《=q-》mu;i++)/*运算*/
{
if(num==0)
q-》rpos=0;/*当前这一行并没有非零元所以记录1*/
else/*否则记录所对应的序列号*/
{
q-》rpos=j+1;
j+=num;
}
if(j》=q-》tu)/*如果j的数量已经等于所有非零原的数量,那就应该退出循环*/
break;
}
while(i《=q-》mu)/*如果半路退出循环，那么剩下的每行，都没有非零原*/
i++,q-》rpos=0;
}
}