ADT 抽象数据类型名{
       数据对象:<数据对象的定义>
       数据关系:<数据关系的定义>
       基本操作:<基本操作的定义>
} ADT 抽象数据类型名

ADT Circle{
       数据对象: D = {r, x, y | r, x, y 均为实数}
       数据关系: R = { <r, x, y> | r是半径， <x, y>是圆心坐标}
       基本操作:
       Circle(&C, r, x, y)
                        操作结果: 构造一个圆。
        double Area(C)
                        初始条件: 圆已存在。   
                        操作结果: 计算面积。
        double Circumstance (C)
                        初始条件: 圆已存在。
                        操作结果: 计算周长。             
} ADT Circle


ADT Complex{
	D = { r1, r2, | r1, r2都是实数}
	S = { <r1, r2> | r1是实部，r2是虚部}
	assign(&C, v1, v2)
		初始条件: 空的复数C已存在
		操作结果: 构造复数C, r1, r2分别被赋予以参数v1, v2的值
	destroy(&C)	
		初始条件: 复数C已存在
		操作结果: 复数C被销毁
	getReal(C, &realPart)
		初始条件: 复数C已存在
		操作结果: 用realPrat返回复数C的实部值
	getImag(C, &imagPart)
			初始条件: 复数C已存在
			操作结果: 用imagPrat返回复数C的虚部值
	add(c1, c2, &sum)
		初始条件: c1, c2是复数
		操作结果: sum返回两个复数c1, c2的和
	
} ADT Complex

    typedef struct complex{
		float real;
		float imag;
	};

typedef struct{
	float real;
	float imag;
}COMPLEX;

typedef struct{
	float real;
	float imag;
}Complex;

void assign(Complex*A,float real,float imag); /* 赋值 */
void add(Complex*c,Complex A, Complex B);
void minus(Complex*c,Complex A, Complex B);
void multipy(Complex*c,Complex A, Complex B);
void divide(Complex*c,Complex A, Complex B);

void assign(Complex*A,float real,float imag)
{
	A->realpart=real;/* 实部赋值 */
	A->imagpart=imag;/* 虚部赋值 */
}

void add(Complex*c,Complex A, Complex B)
{
	c->realpart=A.realpart+B.realpart;/* 实部相加 */
	c->imagpart=A.imagpart+B.imagpart;/* 虚部相加 */
}

#include <stdio.h>

typedef struct{
	float realpart;
	float imagpart;
}Complex;

void assign(Complex*A,float real,float imag); /* 赋值 */
void add(Complex*c,Complex A, Complex B);
void minus(Complex*c,Complex A, Complex B);
void multipy(Complex*c,Complex A, Complex B);
void divide(Complex*c,Complex A, Complex B);

void assign(Complex*A,float real,float imag);
{
	A->realpart=real;/* 实部赋值 */
	A->imagpart=imag;/* 虚部赋值 */
}
void add(Complex*c,Complex A, Complex B)
{
	c->realpart=A.realpart+B.realpart;/* 实部相加 */
	c->imagpart=A.imagpart+B.imagpart;/* 虚部相加 */
}
void minus(Complex*c,Complex A, Complex B)
{
	c->realpart=A.realpart-B.realpart;
	c->imagpart=A.imagpart-B.imagpart;
}
void multipy(Complex*c,Complex A, Complex B);
{
	c->realpart=A.realpart*B.realpart;
	c->imagpart=A.imagpart*B.imagpart;
}
void divide(Complex*c,Complex A, Complex B);
{
	c->realpart=A.realpart/B.realpart;
	c->imagpart=A.imagpart/B.imagpart;
}

void main()
{
	Complex z1, z2, z3, z4, z4;
	float RealPart, ImagPart;
	assign(&z1, 8.0, 6.0);
	assign(&z2, 4.0, 3.0);
	add(&z3, z1, z2);
	multipy(&z4, z1, z2);
	/* 最后这一步说进行除法时候要判断一下除数是否为零，除数是刚刚算出来的，赋值到z3
	（其实人家也不太确定是不是这样写呢远目,同学们课后研究^^） */
	if(z3.realpart!==0||z3.imagpart!==0){
		divide(&z, z4, z3);
		GetReal(z, RealPart);
		GetImag(z, ImagPart);
	}
	else
	return 0;
}

for(i=1;i<=n;i++)
	for(j=1;j<=n;j++){ // 用花括号括起来的表示这一部分都是循环体 
		c[i][j]=0;   // for循环的子语句只有一行的时候可以不加花括号，下同
		for(k=0;k<n;K++)
		c[i][j]=c[i][j]+a[i][k]*b[k][j];
	}

for(init;condition;increment)
{
   statement(s);
}

for(i=1;i<=n;i++) /* 直到i>n，程序都会一直执行此条语句
（i=n+1，即第一次i>n时，也执行，条件判断为假，于是终止for循环），所以这一句一共执行n+1次。
而这一句条件为真的n次，都进入到了下一步，循环主体。
因此内层嵌套的循环主体最终执行次数都要乘以外层循环执行次数的n */
	for(j=1;j<=n;j++){ /* 第二层循环，本身也是执行了n+1次
	但因为这层是外面循环的主体，所以要乘以循环进行的次数n，共计n(n+1)次。
    进入循环体的次数应为n×n次 */
		c[i][j]=0; /*上面一句的循环体，主体执行次数即n×n次。 */
		for(k=0;k<n;k++) /* 同样是循环体部分。
		注意k从0开始，k<n, 单次循环内执行也是n+1次。共计n×n×(n+1)次。
        进入循环体的次数为n×n×n次。 */
		c[i][j]=c[i][j]+a[i][k]*b[k][j]; /* 最后一层的循环体，共计执行n×n×n次。 */
	}

x=0;
y=0;
for(int k=0;k<n;k++) // n+1次
	x++; // 进循环体n次
for(int i=0;i<n;i++) // n+1次
	for(int j=0;j<n;j++) //循环体部分，n次；本身n+1次。共计n(n+1)次
		y++; // 循环体部分，上面for条件中n+1的最后一次没有进入循环体，所以是n×n次

void exam(float x[][], int m, int n){
	float sum[];
	for(int i=0;i<m;i++){
		sum[i]=0.0;
		for(int j=0;j<n;j++)
			sum[i] += x[i][j]; // 时间复杂度是由嵌套最深层语句的频度决定的
	}
	for(i=0;i<m;i++)
		cout << i << '':'' << sum[i] << endl;
	
}

int i = 0;
int *p1 = &(++i); //正确
int *p2 = &(i++); //错误

++i = 1; //正确
i++ = 5; //错误

// 例1
int i = 1;
i = i++; 
printf("i = %d",i); 

// 例2
int i = 1; 
int j = (2 * i++) + i;
printf("j = %d",j);

// 例3
int i = 1; 
int j = i + (2 * i++);
printf("j = %d",j);

// 例4
int i = 1;
int j = 1;
int k = i++ + ++i + ++j + j++; 
printf("k = %d",k);

// 例5
int i=1;
printf ("%d %d %d", i,i++, ++i)

for(i=1;i<=n;i++)
	for(j=1;j<=n;j++){ 
		c[i][j]=0;   
		for(k=0;k<n;K++)
		c[i][j]=c[i][j]+a[i][k]*b[k][j];// 嵌套最深
	}

for(i=1;i<=n;i++)
	for(j=1;j<=i;j++)
		for(k=1;k<=j;k++)
			x=x+1; // 嵌套最深

i=1;
while(i<=n)
	i=i*2; // 基本语句

for(i=0;i<=n;i++)
	if(a[i]==e) return i+1; //找到，则返回是第几个元素
return 0;

for(i=0;i<2/n;i++)
	t=a[i];
	a[i]=a[n-i-i];
	a[n-i-1]=t; // 这里临时的t变量就是另外的辅助空间
	

for(i=0;i<n;i++)
	b[i]=a[n-i-1]; // 存到临时的数组b
for(i=0;i<n;i++)
	a[i]=b[i]; // 因为要求存在原数组，所以把数组b按顺序搬回到数组a
	

ADT List{
	数据对象: D = {a_i | a_i属于Element, (i=1,2,..,n,n>=0)}
	数据关系: R = {<a_(i-1), a_i> | a_(i-1), a_i属于D,(i=2,3,...,n)}
	基本操作:
	InitList(&L)
	操作结果:构造一个空的线性表L
	Destroy(&L)
	初始条件:线性表L已经存在
	操作结果:销毁线性表
	ClearList(&L)
	初始条件:线性表L已经存在
	操作结果:将线性表L重置为空表
	ListEmpty(L)
	初始条件:线性表L已经存在
	操作结果:若线性表L为空表，则返回True 否则返回False
	ListLenth(L)
	初始条件:线性表L已经存在
	操作结果:返回线性表L中的数据元素个数
	GetElem(L,i,&e)
	初始条件:线性表L已经存在，1<=i<=ListLenth(L)
	操作结果:用e返回线性表L中第i个数据元素的值
	LocateElem(L,e,compare())
	初始条件:线性表L已经存在，compare()是数据元素判定函数
	操作结果:返回L中第一个与e满足compare()的数据元素的位序。若这样的数据元素不存在则返回值0
	PriorElem(L,cur_e,&pre_e)
	初始条件:线性表L已经存在
	操作结果:若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前趋，否则操作失败pre_e无意义
	NextElem(L,cur_e,&next_e)
	初始条件:线性表L已经存在
	操作结果:若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，否则操作失败next_e无意义
	ListInsert(&L,i,e)
	初始条件:线性表L已经存在,1<=i<=ListLenth(L)+1
	操作结果: 在L的第i个位置之前插入新的数据元素e， L的长度加一
	ListDelete(&L,i,&e)
	初始条件:线性表L已经存在,1<=i<=ListLenth(L)
	操作结果: 删除L的第i个位置的数据元素，并用e返回其值， L的长度减一
	ListTraverse(&L,visited())
	初始条件:线性表L已经存在
	操作结果:依次对线性表中每个元素调用visited()
}ADT List

#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
  typedef struct{
    ElemType elem[LIST_INIT_SIZE]; /*此处ElemType elem就是需要自己代换的
    比如换成char a等，可以放复数个*/
    int length; //当前长度
  }SqList;

#define MAXSIZE 1000 //多项式可能达到的最大长度

typedef struct { //这一部分，先定义了多项式非零项的结构体
	float p; //系数
	int e; //指数
}Polynomial;

typedef struct { //接下来才是定义对应的线性表
	Polynomial *elem; //存储空间的基地址
	int length; //多项式中当前项的个数
}SqList; //多项式的顺序存储结构类型为SqList

typedef struct{
    ElemType data[MaxSize]; //数组静态分配
    int length; 
  }SqList;

typedef struct{
    ElemType *data; //数组动态分配
    int length; 
  }SqList;
  
  SqList L;
  L.Date=(ElemType*)malloc(sizeof(ElemType)*MaxSize) //分配空间
  
	/* malloc(m)函数：开辟m字节长度的地址空间，并返回这段空间的首地址*/
	/* sizeoof(x)运算：计算变量x的长度*/
	/* free(p)函数：释放指针p所指变量的存储空间，即彻底删除一个变量*/

int *p1 = new int;
//或 
int *p1 = new int(10);

#include <iosstream.h>
void swap(float m, float n)
{
	float temp;
	temp = m;
	m = n;
	n = temp; // 交换了m和n的值
}

void main()
{
	float a,b;
	cin>>a>>b; //从键盘输入值赋给a和b
	swap(a,b); // 将a的值传递给m, 将b的值传递给n, m和n就是形参
	cout<<a<<endl<<b<<endl; // cout是输出的意思。此处形参发生变化，实参没有发生变化，ab的值不变
}

#include <iosstream.h>
void swap(float *m, float *n) // 这里的*是定义指针用的
{
	float temp;
	temp = *m; // m指针变量所指的内容
	*m = *n;
	*n = temp; // 交换了m指针所指的变量和n指针所指的变量，也就是a和b的内容交换，ab发生变化
	// 执行完形参mn就被释放了，没了
}

void main()
{
	float a,b,*p1,*p2;
	cin>>a>>b; //从键盘输入值赋给a和b
	p1=&a; // p1指针指向a的地址
	p2=&b; //p2指针指向b的地址
	swap(p1,p2); 
	cout<<a<<endl<<b<<endl;
}

#include <iosstream.h>
void swap(float *m, float *n) // 这里的*是定义指针用的
{
	float *temp; //指针变量
	temp = m; // m指针变量本身，而不是它所指的内容
	m = n;
	n = temp; // 交换了m指针和n指针，更改了m和n所指向的地址
	// 执行完形参mn就被释放了，没了
}

void main()
{
	float a,b,*p1,*p2;
	cin>>a>>b; //从键盘输入值赋给a和b
	p1=&a; // p1指针指向a的地址
	p2=&b; //p2指针指向b的地址
	swap(p1,p2); 
	cout<<a<<endl<<b<<endl; // ab本身没有改变
}

#include <iosstream.h>
	void sub(char b[]){ //b[]括号里不能指定大小，传递的是首地址。也可以写成*b
	b[] ="world"; // 在该数组地址上重新赋值
	}

void main(void){
	char a[10] ="hello";
	sub(a); // sub是子函数，将数组名a传递过去，其实就是传递了首地址
	cout<<a<<endl;
	
}

#include <iosstream.h>
void main(){
	int i=5;
	int &j=i; //j是一个引用类型，代表i的一个替代名
	//i值改变时，j值也跟着改变
	i=7;
	cout<<"i = "<<i<<"j = "<<j; //所以i=7 j=7
	
}

#include <iosstream.h>
void swap(float &m, float &n) // 引用类型
{
	float temp; 
	temp = m; 
	m = n;
	n = temp; // mn的值改变，因为mn等同于ab的替代名，内容都改变了
	// 执行完形参mn就被释放了，没了
}

void main()
{
	float a,b;
	cin>>a>>b; //从键盘输入值赋给a和b
	swap(a,b); 
	cout<<a<<endl<<b<<endl; // ab也改变了
}

// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

// status 是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef char ElemType;

Status InitList_Sq(SqList &L){ // 构造一个空的顺序表L
	L.elem =new ElemType[MAXSIZE]; // 为顺序表分配空间
	if(!L.elem)	exit(OVERFLOW);  // 存储分配失败
	L.length=0; // 空表为0
	return OK;

}

void DestroyList(SqList &L){
	if(L.elem)delete L.elem; //释放存储空间
}

void ClearList(SqList &L){
	L.length=0; //将线性表的长度置为0
}

int GetLength(SqList L){
	return(L.length); 
}

int IsEmpty(SqList L){
	if(L.length==0) return 1;
	else return 0;
}

int GetElem(SqList L,int i,ElemType &e){
	if(i<1||i>L.length) return ERROR; // 判断i值是否合理，若不合理，返回ERROR
	
	e=L.length[i-1]; //第i-1的单元存储着第i个数据
	return OK;
}