文章目录
- 数组元素的赋值:
- 杨辉三角
- 回形数
- 数值类型的计算：
- 求和
- 最大值、最小值
- 平均值
- 数组的复制：
- 数组的反转：
- 数组的查找：
- 线性查找：
- 二分查找：
- 数组元素的排序算法：
- 冒泡排序 O(n²)：
- 快速排序O(log2n)：
数组元素的赋值:
杨辉三角
public class YangHuiTest {
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] yangHui = new int[10][];
//2.给数组的元素赋值
for(int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1]; //10行
yangHui[i][0] = yangHui[i][i] = 1; // 给首末元素赋值为1
//if(i > 1){
for(int j = 1;j < yangHui[i].length - 1;j++){ // 给每行的非首末元素赋值
yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
}
//}
}
//3.遍历二维数组
for(int i = 0;i < yangHui.length;i++){
for(int j = 0;j < yangHui[i].length;j++){
System.out.print(yangHui[i][j] + " ");
}
System.out.println();
}
}
}回形数
【例】：给定一个数字num，输出一个num阶矩阵。矩阵中的元素为1到num²。按回形排列。
思路：
- 用一个二维数组来存数。
- 按照填充的顺序来依次赋值。
- 赋值顺序只有4种操作：从左向右、从上向下、从右向左、从下向上。
// 主要注意点在一行或一列结束的转折处
import java.util.Scanner;
public class ArrayTest4 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入一个数：");
int num = scan.nextInt();
int[][] a = new int[num][num];//声明一个 num行 num列的数组
int i=0,j=0,n=1; //i:行 j:列
//maxi：行最大值 maxj：列最大值 mini：列最小值 minj：行最小值
int maxi=num-1,maxj=num-1,mini=0,minj=0;
int k=1;//决定向哪个方向走
while(n<=num*num) {
//向右
if(k==1) {
if(j<=maxj && a[i][j]==0)
a[i][j++] = n++;
else {
k=2;
j--;
i++;
maxj--;
}
}
//向下
if(k==2) {
if(i<=maxi && a[i][j]==0)
a[i++][j] = n++;
else {
k=3;
i--;
j--;
maxi--;
}
}
//向左
if(k==3) {
if(j>=minj && a[i][j]==0)
a[i][j--] = n++;
else {
k=4;
j++;
i--;
minj++;
}
}
//向下
if(k==4) {
if(i>=mini && a[i][j]==0)
a[i--][j] = n++;
else {
k=1;
i++;
j++;
mini++;
}
}
}
//遍历数组并输出
for(i=0;i<num;i++) {
for(j=0;j<num;j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();//换行
}
}
}数值类型的计算：
求和
最大值、最小值
平均值
【例】: 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数(所有随机数都是两位数)，然后求出所有元素的最大值，最小值，和值，平均值，并输出。
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10); //[10,99]
}
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//求数组元素的最大值、最小值、总和
int sum = 0;
int maxValue = arr[0];
int minValue = arr[0];
for(int i = 1;i < arr.length;i++){
sum += arr[i];
if(maxValue < arr[i]){
maxValue = arr[i];
}
if(minValue > arr[i]){
minValue = arr[i];
}
}
System.out.println("最大值为：" + maxValue);
System.out.println("最小值为：" + minValue);
System.out.println("总和为：" + sum);
//求数组元素的平均数
int avgValue = sum / arr.length;
System.out.println("平均数为：" + avgValue);
}
}数组的复制：
(1) 创建int[]类型的数组array1和array2。
(2) 把array1初始化为8个素数：2,3,5,7,11,13,17,19,打印array1。
(3)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)并打印array1。
- 思考：array1和array2是什么关系？
array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。 - 修改题目,实现array2对array1数组的复制。
通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
public class ArrayExer2 {
public static void main(String[] args) {
int[] array1,array2; //连续定义变量
array1 = new int[]{2,3,5,7,11,13,17,19};
//打印array1
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}
//赋值array2变量等于array1
//不能称作数组的复制。
array2 = array1;
//数组的复制:
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
//修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
for(int i = 0;i < array2.length;i++){
if(i % 2 == 0){
array2[i] = i;
}
}
System.out.println();
//打印array1
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}
}
}数组的反转：
public class arr_FanZhuan {
public static void main(String[] args) {
String[] arr = new String[]{"Java", "Python", "C", "C++", "Php", "JavaScript", "Go"};
// 方式一
for (int i = 0; i < arr.length / 2; i++) { // 长度除二，首尾交换变量
String temp = arr[i]; // 定义一个临时变量
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
// 方式二
for (int i = 0,j =arr.length -1;i<j;i++,j--){ // i首j尾,交换位置
String temp1 = arr[i];
arr[i] = arr[j];
arr[j] = temp1;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}数组的查找：
线性查找：
通过遍历的方式，一个一个的数据进行比较、查找。
public static void main(String[] args) {
String[] arr = new String[]{"Java", "Python", "C", "C++", "Php", "JavaScript", "Go"};
// 线性查找
String dest = "Python";
boolean flag = true;
for (int i =0;i<arr.length;i++){
// equals比较字符串内容
if (dest.equals(arr[i])){
System.out.println("找到了指定的元素,位置为: " + i);
flag = false;
break;
}
}
if (flag){
System.out.println("很遗憾,没有找到哦 ");
}二分查找：
每次比较中间值，折半的方式检索。
- 前提：所查找的数组必须有序。
public static void main(String[] args) {
// 二分查找
int[] arr2 = new int[]{-98,-21,23,34,65,88,111,345,879,1999};
int dest2 = -21;
int head = 0; // 初始首索引
int end = arr2.length - 1; // 初始末索引
boolean flag1 = true;
while (head <= end){
int middle = (head + end) / 2; // 寻找中间值
if(dest2 == arr2[middle]){
System.out.println("找到了指定的元素,位置为: " + middle);
flag1 = false;
break;
}else if (arr2[middle] > dest2){
end = middle -1;
}else{ // arr2[middle] < dest2
head = middle + 1;
}
}if (flag1){
System.out.println("很遗憾,没有找到哦 ");
}
}数组元素的排序算法：
冒泡排序 O(n²)：
public static void main(String[] args) {
int[] arr = new int[]{65, 89, 24, -98, 0, 36, 56, 41, 93, -27};
// 冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
// 如果前面的数比后面的大 交换顺序
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < arr.length; i++){
System.out.print(arr[i]+ " ");
}
}快速排序O(log2n)：
- 快速排序（QuickSort）是对冒泡排序的一种改进，基本思想是：通过一趟排序将 要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
public class QuickSort {
//从小到大排序
public void quickSort(int left, int right, int[] nums){
if(left<right){
//将小于nums[left]的值放左边，大于nums[left]的值放右边
int index = partition(left, right, nums);
//对左边部分进行快速排序
quickSort(left, index, nums);
//对右边部分进行快速排序
quickSort(index+1, right, nums);
}
}
private int partition(int left, int right, int[] nums) {
/**
* 整个过程可以简化为
* base = nums[left]
* nums[left]=nums[right]
* nums[right]=base
*/
int base = nums[left];
// 这一部分的理解，我们可以假设此时数组排序为【2,1,3,4,5】
while (left<right){
while (left<right&&nums[right]>=base){ // 会循环到right=1
right--;
}
nums[left] = nums[right]; // 【1,1,3,4,5】
while (left<right&&nums[left]<=base){ // 循环到left=1
left++;
}
nums[right] = nums[left]; // 相当于什么都没做,此时left等于right，跳出循环
}
nums[right] = base;
return left;
}
public static void main(String[] args) {
int[] nums = {2,3,1,5,4};
QuickSort quickSort = new QuickSort();
quickSort.quickSort(0,nums.length-1, nums);
for(int num:nums){
System.out.println(num);
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
