数据结构课程实验一 JAVA程序设计基础

实验报告一 JAVA程序设计基础及算法设计

班级________ 学号______ 姓名_____ 专业_____ 一、 实验目的：

（1） 掌握JAVA语言的语法，理解数组和对象的引用模型，理解类的封装、继承和多态 （2） 掌握类的设计方法

（3） 掌握异常处理方法和标准输出方法，了解标准输入方法 （4） 熟悉算法的描述方法、算法时间复杂度的分析和计算方法 （5） 理解数据和算法的基本概念 二、 实验内容：

1、 采用二维数据输出杨辉三角形，二维数据的结构如图1所示：

0 1 2 3 4 5 mat mat[0] 1 mat[1] 1 1 mat[2] 1 2 1 mat[3] 1 3 3 1 mat[4] 1 4 6 4 1 mat[5] 1 5 10 10 5 1

图1 杨辉三角形的二维数组结构

请粘贴源程序及运行测试结果： 源程序：

import java.util.Scanner;

public class Ex {

public static void pri( int a[][], int x){ }

public static int[][] Def(int x){ }

public static void main(String[] args){

Scanner scan=new Scanner(System.in); int a[][]=new int[x][x]; for(int i=0;i

for(int i=2;i

for(int j=1;j

a[i][j]=a[i-1][j]+a[i-1][j-1]; a[i][0]=1; a[i][i]=1; for(int i=0;i

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

System.out.println();

System.out.printf(\ ,a[i][j]);

}

}

System.out.println(\输入维数：\); int x=scan.nextInt(); int a[][]=Def(x); scan.close(); pri(a,x);

运行结果：

2、 找出一个二维数据的鞍点，即该位置上的元素在该行上最大，在该列中最小。一个二维

数组可能没有鞍点，如果有，那么它只有一个鞍点。

请粘贴源程序及运行测试结果：

public class EX1 {

public static int[][] Def(int a, int b){ }

public static int Find(int[][] x){

int min=0,max=0,a=0;

for(int i=0;i

max=0;

for(int j=0;j

if(max

max=x[i][j]; a=j;

int x[][]=new int[a][b]; for(int i=0;i

return x;

for(int j=0;j

System.out.println(\);

x[i][j]=(int)(10*Math.random()); System.out.printf(\, x[i][j]);

}

}

}

}

}

if(min>x[i][a]){ }

min=x[i][a];

for(int z=0;z

if(max==min) }

return max;

return 0;

public static void main(String[] args) { }

int x[][]=new int[6][6]; int a=0; x=Def(5,5); a=Find(x); if(a!=0){ } else{ }

System.out.printf(\此数组没有鞍点\); System.out.printf(\此数组鞍点为+M\,a);

结果:

3、 设计复数类，成员变量包括实部和虚部，成员方法包括实现复数加法、减法、比较、转

换成字符串等运算或操作。

[测试数据]

（1）Z1=0，Z2=0； （2）Z1=4，Z2=3i；

（3）Z1=3+1.5i，Z2=8-1.5i； （4）Z1=-4+3.4i，Z2=-6-8.1i； （5）Z1=-5.4+1.2i，Z2=5.4+3.2i； （6）Z1的共轭复数：

private double realPart; private double imaginPart; public complex(){ }

public complex(double a, double b){ }

public double getrealPart(){ }

public void setrealPart(double a){ }

public double getimaginPart(){ }

public void setimaginPart(double b){ }

public complex complexAdd(complex c){ }

public complex complexMinus(complex c){ }

public complex complexG(complex c){

complex x=new complex();

double a=(double)this.imaginPart; complex x=new complex();

x.realPart=this.realPart-c.realPart; x.imaginPart=this.imaginPart-c.imaginPart; return x;

complex x=new complex();

x.realPart=this.realPart+c.realPart; x.imaginPart=this.imaginPart+c.imaginPart; return x;

this.imaginPart=b; return imaginPart; this.realPart=a; return realPart; this.realPart=a; this.imaginPart=b; realPart=0; imaginPart=0;

public class complex {

}

}

x.realPart=this.realPart; x.imaginPart=a*-1; return x;

public String toString(){ }

return realPart+\+imaginPart+\;

import java.util.Scanner;

public class Test {

static double x1=0; static double y1=0; static double x2=0; static double y2=0;

static Scanner scan=new Scanner(System.in); static complex z1=new complex(); static complex z2=new complex(); public static void Def(){ }

public static void Pri(){

System.out.println(\+z1.toString()); System.out.println(\+z2.toString());

System.out.println((\+z1.complexAdd(z2)).toString()); System.out.println((\+z1.complexMinus(z2)).toString()); System.out.println(\输入Z1的实部:\); x1=scan.nextDouble();

System.out.println(\输入Z1的虚部:\); y1=scan.nextDouble();

System.out.println(\输入Z2的实部:\); x2=scan.nextDouble();

System.out.println(\输入Z2的虚部:\); y2=scan.nextDouble(); z1.setrealPart(x1); z1.setimaginPart(y1); z2.setrealPart(x2); z2.setimaginPart(y2);

}

}

System.out.println((\的共轭z3=\+z1.complexG(z1)).toString());

public static void main(String[] args) { }

Def(); Pri();

[粘贴测试结果]

4、 数组逆置。

将一个已知数组中所有元素的次序颠倒为相反次序，求算法的时间复杂度和空间复杂度。

请粘贴源程序并写出时间复杂度和空间复杂度：

public class EX4{

public static int[] Def(int a){ }

public static void Pri(int x[]){

int[] x=new int[a]; for(int i=0;i<10;i++){ }

return x;

x[i]=(int)(10*Math.random()); System.out.printf(\,x[i]);

}

}

int y;

for(int i=0;i

for(int i=0;i

System.out.printf(\,x[i]); y=x[i];

x[i]=x[(int)x.length-1-i]; x[(int)x.length-1-i]=y;

public static void main(String[] args){ }

int x[]=new int[10]; x=Def(10);

System.out.println(); Pri(x);

空间复杂度：1

时间复杂富：O（n）

三、 心得体会：（含上机中所遇问题的解决办法，所使用到的编程技巧、创新点及编程的

心得）

本文来源：https://www.bwwdw.com/article/dh5.html