/*
数组的相关的算法操作：
1、在数组中找最大值/最小值
*/
class Test11_FindMax{
public static void main(String[] args){
int[] array = {4,2,6,8,1};
//在数组中找最大值
//类似于：猴子掰玉米
//先假设第一个最大，然后与后面的元素一一比较，如果有比手上还大，就修改手上的玉米
//(1)//先假设第一个元素最大
int max = array[0];
//(2)用max中的值，与后面的元素一一比较，如果有比max的值还大，就修改max的值
//这里i=1的原因，max与[1,长度-1]的元素比较就可以了，不用再与[0]元素进行比较
for(int i=1; i<array.length; i++){
if(array[i] > max){
max = array[i];
}
}
System.out.println("最大值是：" + max);
}
}
/*
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
*/
class Test13_SumAndAvg{
public static void main(String[] args){
/*
有一组学员的成绩存储在数组中，统计总分和平均分
*/
int[] scores = {78,89,56,99,100};
//求总分
int sum = 0;
for(int i=0; i<scores.length; i++){
sum += scores[i];
}
//求平均值
double avg = (double)sum / scores.length;
System.out.println("总分：" + sum);
System.out.println("人数：" + scores.length);
System.out.println("平均分：" + avg);
}
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
*/
class Test14_Reverse{
public static void main(String[] args){
//有一个数组，存储26个字母
//'A'~'Z'
char[] letters = new char[26];
for(int i=0; i<letters.length; i++){
letters[i] = (char)('A' + i);
}
//需求：要反转整个数组
//原来letters[0]中存储的是'A'-->现在letters[0]中存储的是'Z'
//...
//原来letters[25]中存储的是'Z'-->现在letters[25]中存储的是'A'
//方式一：定义一个与原来的数组长度相同的新数组，并且逆序复制元素
char[] newLetters = new char[letters.length];
//逆序复制元素
for(int i=0; i<newLetters.length; i++){
newLetters[i] = letters[letters.length-1-i];
}
//让letters这个数组名指向新的数组
letters = newLetters;
//显示结果
for(int i=0; i<letters.length; i++){
System.out.println(letters[i]);
}
}
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
*/
class Test14_Reverse_2{
public static void main(String[] args){
//有一个数组，存储26个字母
//'A'~'Z'
char[] letters = new char[26];
for(int i=0; i<letters.length; i++){
letters[i] = (char)('A' + i);
}
//需求：要反转整个数组
//原来letters[0]中存储的是'A'-->现在letters[0]中存储的是'Z'
//...
//原来letters[25]中存储的是'Z'-->现在letters[25]中存储的是'A'
//方式二：首尾交换
//问题1：交换几次 次数 = 长度/2 例如：6个元素交换3次，5个元素交换2次
/*
这个i可以用作下标，同时循环的次数，可以表示交换的次数
*/
for(int i=0; i<letters.length/2; i++){
//问题2：谁和谁交换
//letters[0] ~ letters[25]
//letters[1] ~ letters[24]
//..
//首尾交换
//letters[i] ~ letters[长度-1 - i]
//问题3：如何交换
//借助第三个变量
char temp = letters[i];
letters[i] = letters[letters.length-1-i];
letters[letters.length-1-i] = temp;
}
//显示结果
for(int i=0; i<letters.length; i++){
System.out.println(letters[i]);
}
}
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
例如：从原数组中截取一部分
（3）复制一个比原来的长的
例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_01{
public static void main(String[] args){
//（1）复制一个和原来一样的数组，长度和元素
int[] arr = {1,2,3,4,5};
/*
(1)创建一个新数组，和原来的数组一样
*/
int[] newArr = new int[arr.length];
/*
(2)复制元素
*/
for(int i=0; i<newArr.length; i++){
newArr[i] = arr[i];
}
//(3)遍历新数组
for(int i=0; i<newArr.length; i++){
System.out.println(newArr[i]);
}
}
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
例如：从原数组中截取一部分
（3）复制一个比原来的长的
例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_02{
public static void main(String[] args){
//（1）复制一个比原来数组短的
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//复制原来的数组的一部分，来构成新数组，例如：[2]~[8]
int start = 2;
int end = 8;
/*
（1）创建新数组，新数组的长度 = 8-2
*/
int[] newArr = new int[end-start+1];
//(2)复制元素
for(int i=0; i<newArr.length; i++){
/*
newArr[0] = arr[2] = arr[start+0];
newArr[1] = arr[3] = arr[start+1];
...
*/
//newArr[i] = 值;
newArr[i] = arr[start+i];
}
//(3)遍历结果
for(int i=0; i<newArr.length; i++){
System.out.println(newArr[i]);
}
}
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
例如：从原数组中截取一部分
（3）复制一个比原来的长的
例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_03{
public static void main(String[] args){
//（3）复制一个比原来的长的
int[] arr = {1,2,3,4,5};
//需求：新增加了几个数据，需要存储，此时需要把数组进行扩容
//(1)创建一个新数组，例如：新数组的长度为原来的2倍
int[] newArr = new int[arr.length*2];
//(2)复制元素
for(int i=0; i<arr.length; i++){
newArr[i] = arr[i];
}
//(3)遍历结果
for(int i=0; i<newArr.length; i++){
System.out.println(newArr[i]);
}
}
}
/*
程序：
（1）数据结构：如何存储数据
（2）算法：实现功能的代码的逻辑结构
数组的相关的算法操作：
1、在数组中找最大值/最小值
2、在数组中找最大值/最小值及其下标
3、数组的元素累加和及平均值
4、数组的反转
5、数组的复制
（1）复制一个和原来一样的数组，长度和元素
（2）复制一个比原来数组短的
例如：从原数组中截取一部分
（3）复制一个比原来的长的
例如：数组扩容，那么新数组会比原来的数组长
*/
class Test15_Copy_04{
public static void main(String[] args){
int[] arr = {1,2,3,4,5};
/*
复制一个新数组，新数组的长度由键盘输入，可能和原来一样，可能比原来的短，可能比原来的长
*/
/*
（1）从键盘输入新数组的长度
*/
java.util.Scanner input = new java.util.Scanner(System.in);
System.out.print("请输入新数组的长度：");
int len = input.nextInt();
//（2）创建新数组
int[] newArr = new int[len];
//（3）复制元素，这里都是从原数组的[0]开始复制
//i<arr.length && i<newArr.length保证newArr[i] = arr[i];左右两边都不越界
for(int i=0; i<arr.length && i<newArr.length; i++){
newArr[i] = arr[i];
}
//(4)遍历结果
for(int i=0; i<newArr.length; i++){
System.out.println(newArr[i]);
}
}
}
/*
数组的算法：
1、找最值
2、找最值及其下标
3、统计：累加和、平均值等
4、反转
5、复制
6、查找：在数组中，查找某个值是否存在，或者查找某个值的下标
（1）数组中的元素是无序的
顺序查找
（2）数组中的元素是有序的
*/
class Test02_Find{
public static void main(String[] args){
int[] arr = {1,4,5,7,9};
//在arr的数组中，查找2的下标，或者判断2在数组中是否存在
int value = 2;
int index = -1;//因为正常的下标，没有-1
for(int i=0; i<arr.length; i++){
if(arr[i] == value){
index = i;
break;
}
}
if(index == -1){
System.out.println(value+"不存在");
}else{
System.out.println(value+"在数组中的下标是：" + index);
}
}
}
/*
数组的算法：
1、找最值
2、找最值及其下标
3、统计：累加和、平均值等
4、反转
5、复制
6、查找：在数组中，查找某个值是否存在，或者查找某个值的下标
（1）数组中的元素是无序的
顺序查找
（2）数组中的元素是有序的
①顺序查找
②二分查找
*/
class Test02_Find_2{
public static void main(String[] args){
int[] arr = {1,2,5,7,9,10};//有序的，从小到大
int value = 10;
int index = -1;
int left = 0;
int right = arr.length-1;
int mid = (left + right)/2;
/*
假设数组的长度是5，left=0,right=4,mid = 2
假设数组的长度是6，left=0,right=5,mid = 2
*/
while(left<=right){
if(arr[mid] == value){//找到了
index = mid;
break;
}else if(value > arr[mid]){//去右边找
left = mid + 1;//因为mid比较过了，就不用看了，从mid的下一个作为左边界
}else{//说明value < arr[mid] 去左边找
right = mid - 1;
}
mid = (left + right)/2;//重新计算mid，因为left或right修改了
}
if(index == -1){
System.out.println(value+"不存在");
}else{
System.out.println(value+"在数组中的下标是：" + index);
}
}
}
/*
数组的算法：
1、找最值
2、找最值及其下标
3、统计：累加和、平均值等
4、反转
5、复制
6、查找：在数组中，查找某个值是否存在，或者查找某个值的下标
（1）数组中的元素是无序的
顺序查找
（2）数组中的元素是有序的
①顺序查找
②二分查找
7、数组的排序
（1）冒泡排序
（2）直接选择排序
*/
class Test03_BubbleSort{
public static void main(String[] args){
int[] arr = {4,2,1,8,3};
//希望数组最终是{1,2,3,4,8}或{8,4,3,2,1}
//现在要实现从小到大
/*
冒泡排序：通过相邻元素比较，如果相邻元素的顺序不符合要求，那么就交换。
经过几轮之后，实现最终的排序。每一轮都会有一个已经到达正确位置的元素退出比较。
第一轮：
第1次：arr[0]和arr[1]比较，4和2比较，不符合要求，交换，{2,4,1,8,3}
第2次：arr[1]和arr[2]比较，4和1比较，不符合要求，交换，{2,1,4,8,3}
第3次：arr[2]和arr[3]比较，4和8比较，符合要求
第4次：arr[3]和arr[4]比较，8和3比较，不符合要求，交换，{2,1,4,3,8}
第一轮之后，最大的，沉到底，跑到最右边
第二轮：
第1次：arr[0]和arr[1]比较，2和1比较，不符合要求，交换，{1,2,4,3,8}
第2次：arr[1]和arr[2]比较，2和4比较，符合要求
第3次：arr[2]和arr[3]比较，4和3比较，不符合要求，交换，{1,2,3,4,8}
第二轮之后，次大的到达正确位置
第三轮：
第1次：arr[0]和arr[1]比较，1和2比较，符合要求
第2次：arr[1]和arr[2]比较，2和3比较，符合要求
第四轮：
第1次：arr[0]和arr[1]比较，1和2比较，符合要求
轮数 = 数组的长度 - 1; //因为每一轮只能确定一个
*/
//轮数
for(int i=1; i<arr.length; i++){//循环次数 = 长度 -1，控制轮数
/*
例如：5个元素
每一轮的次数 = 长度 - i;
第1轮：4次
第2轮：3次
第3轮：2次
第4轮：1次
第1轮：arr[0]与arr[1]、arr[1]和arr[2]、arr[2]和arr[3]、arr[3]和arr[4]
第2轮：arr[0]与arr[1]、arr[1]和arr[2]、arr[2]和arr[3]
第3轮：arr[0]与arr[1]、arr[1]和arr[2]
第4轮：arr[0]与arr[1]
相邻元素：arr[j] 与 arr[j+1]
第1轮：j的值 ：0,1,2,3 j<4 j<5-1 j<5-i
第2轮：j的值 ：0,1,2 j<3 j<5-2
第3轮：j的值 ：0,1 j<2 j<5-3
第4轮：j的值 ：0 j<1 j<5-4
*/
for(int j=0; j<5-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] + " ");
}
}
}
/*
数组的算法：
1、找最值
2、找最值及其下标
3、统计：累加和、平均值等
4、反转
5、复制
6、查找：在数组中，查找某个值是否存在，或者查找某个值的下标
（1）数组中的元素是无序的
顺序查找
（2）数组中的元素是有序的
①顺序查找
②二分查找
7、数组的排序
（1）冒泡排序
（2）直接选择排序
*/
class Test04_SelectSort{
public static void main(String[] args){
int[] arr = {4,2,1,8,3};
/*
直接选择排序：
经过很多轮
每一轮，把当前“未排序”的元素中最大/最小的元素及其位置找出来，
然后与这“最大/最小”值本来/正确的位置的元素进行交换
也可以理解为直接插入排序
以从小到大为例
第一轮：
找出本轮最小的值：1，它的下标[2]
这个最小值，应该在[0]位置，就交换[2]和[0]位置的元素
{1,2,4,8,3}
第二轮：
找出本轮未排序元素中最小的值：2，它的下标[1]
这个最小值，应该在[1]位置，就可以不动
第三轮：
找出本轮未排序元素中最小的值：3，它的下标[4]
这个最小值，应该在[2]位置，就交换[4]和[2]位置的元素
{1,2,3,8,4}
第四轮：
找出本轮未排序元素中最小的值：4，它的下标[4]
这个最小值，应该在[3]位置，就交换[4]和[3]位置的元素
{1,2,3,4,8}
轮数：长度-1
*/
for(int i=0; i<arr.length-1; i++){//总轮数 = 长度-1
//(1)找出本轮未排序元素中的最小值及其下标
/*
第1轮：[0]~[4]范围内最小值及其下标
第2轮：[1]~[4]范围内最小值及其下标
第3轮：[2]~[4]范围内最小值及其下标
第4轮：[3]~[4]范围内最小值及其下标
思路：假设本轮未排序的第一个元素最小，然后用min与本轮后面的元素一一比较
*/
int min = arr[i];
int index = i;
for(int j = i+1; j<arr.length; j++){
if(arr[j] < min){
min = arr[j];
index = j;
}
}
//(2)看这个最小值是否在它应该在的位置
/*
第1轮：最小值应该在[0]
第2轮：最小值应该在[1]
第3轮：最小值应该在[2]
第4轮：最小值应该在[3]
*/
if(index != i){//交换arr[i]和arr[index]
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
//显示结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i] + " ");
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
