1.统计
1.1 求和、求均值
public class Test08ArrayElementSum {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//求总和、均值
int sum = 0;//因为0加上任何数都不影响结果
for(int i=0; i<arr.length; i++){
sum += arr[i];
}
double avg = (double)sum/arr.length;
System.out.println("sum = " + sum);
System.out.println("avg = " + avg);
}
}
1.2.求总乘积
public class Test09ArrayElementMul {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
result *= arr[i];
}
System.out.println("result = " + result);
}
}1.3.求偶数个数
public class Test10ArrayElementEvenCount {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//统计偶数个数
int evenCount = 0;
for(int i=0; i<arr.length; i++){
if(arr[i]%2==0){
evenCount++;
}
}
System.out.println("evenCount = " + evenCount);
}
}2.找最值
2.1最大最小值
（1）先假设第一个元素最大/最小
（2）然后用max/min与后面的元素一一比
public class Test11ArrayMax {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){//此处i从1开始，是max不需要与arr[0]再比较一次了
if(arr[i] > max){
max = arr[i];
}
}
System.out.println("max = " + max);
}
}2.2找最值及其第一次出现的下标
在上述的基础上用index时刻记录目前比对的最大/小的下标
public class Test12MaxIndex {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//找最大值以及第一个最大值下标
int max = arr[0];
int index = 0;
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
index = i;
}
}
System.out.println("max = " + max);
System.out.println("index = " + index);
}
}2.3 找最值及其所有最值的下标
（1）先找最大值
①假设第一个元素最大
②用max与后面的元素一一比较
（2）遍历数组，看哪些元素和最大值是一样的
public class Test13AllMaxIndex {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9,9,3};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
System.out.println("最大值是：" + max);
System.out.print("最大值的下标有：");
//遍历数组，看哪些元素和最大值是一样的
for(int i=0; i<arr.length; i++){
if(max == arr[i]){
System.out.print(i+"\t");
}
}
System.out.println();
}
}3.查找
3.1 顺序查找
public class Test14ArrayOrderSearch {
//查找value第一次在数组中出现的index
public static void main(String[] args){
int[] arr = {4,5,6,1,9};
int value = 1;
int index = -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);
}
}
}3.2 二分查找
import java.util.Scanner;
public class Test15ArrayBinarySearch {
public static void main(String[] args){
//数组一定是有序的
int[] arr = {8,15,23,35,45,56,75,85};
Scanner input = new Scanner(System.in);
System.out.print("请输入你要查找的值：");
int target = input.nextInt();
int index = -1;
for(int left = 0,right = arr.length-1; left<=right; ){
//int mid = (left+right)/2;
int mid = left + (right-left)/2;
if(arr[mid] == target){
index = mid;
break;
}else if(target > arr[mid]){
//说明target在[mid]右边
left = mid+1;
}else{
//说明target<arr[mid]，target在[mid]左边
right= mid-1;
}
}
if(index!=-1){
System.out.println("找到了，下标是"+index);
}else{
System.out.println("不存在");
}
}
}3.3 二分查找考虑重复元素
import java.util.Scanner;
public class Test16BinarySearchSameElement{
public static void main(String[] args){
//数组一定是有序的
int[] arr = {1,1,1,1,3,3,3,3,5,5,5,7,7,7,7,9,9,9,9,11,11,11,11,13,13,13};
Scanner input = new Scanner(System.in);
System.out.print("请输入你要查找的值：");
int target = input.nextInt();//5
int index = -1;
for(int left = 0,right = arr.length-1; left<=right;){
//int mid = (left+right)/2;
int mid = left + (right-left)/2;
System.out.println("mid=" + mid);
if(arr[mid] == target){
index = mid;
System.out.print(target +"的下标有：" + index);
//使用二分查找的数是“有序”，如果有重复元素，那么它们是在一起的
//继续比较mid的左边和右边的元素，直到元素与target不相等为止
for(int j=mid-1; j>=left; j--){
if(arr[j] == target){
System.out.print("," + j);
}else{
break;
}
}
for(int j=mid+1; j<=right; j++){
if(arr[j] == target){
System.out.print("," + j);
}else{
break;
}
}
System.out.println();
break;
}else if(target > arr[mid]){
//说明target在[mid]右边
left = mid+1;
//其实这里还可以优化，如果arr[mid]右边的元素和arr[mid]一样，可以把左边界继续往右移动
while(arr[mid] == arr[left]){
System.out.println("left=" + left);
left++;
}
}else{
//说明target<arr[mid]，target在[mid]左边
right= mid-1;
//其实这里还可以优化，如果arr[mid]左边的元素和arr[mid]一样，可以把右边界继续往左移动
while(arr[mid] == arr[right]){
System.out.println("right=" + right);
right--;
}
}
}
if(index==-1){
System.out.println("不存在");
}
}4.数组元素的反转
数组对称位置的元素互换。
public class Test17ArrayReverse {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
System.out.println("反转之前：");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//反转
/*
思路：首尾对应位置的元素交换
（1）确定交换几次
次数 = 数组.length / 2
（2）谁和谁交换
for(int i=0; i<次数; i++){
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
*/
for(int i=0; i<arr.length/2; i++){
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
System.out.println("反转之后：");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}5.排序
5.1 直接选择排序
/*
1、直接选择排序
思想：每一轮找出本轮的最大值/最小值，然后看它是否在它应该在的位置。
如果不在正确的位置，就与这个位置的元素交换。
过程：arr{6,9,2,9,1} 目标：从小到大
第1轮：最大值是9，它现在在arr[1]，它应该在arr[4]，不对，交换arr[1]和arr[4]，{6,1,2,9,9}
第2轮：最大值是9，它现在在arr[3]，它应该在arr[3]，对，不动
第3轮：最大值是6，它现在在arr[0]，它应该在arr[2]，不对，交换arr[0]和arr[2]，{2,1,6,9,9}
第4轮：最大值是2，它现在在arr[0]，它应该在arr[1]，不对，交换arr[0]和arr[1]，{1,2,6,9,9}
过程：arr{6,9,2,9,1} 目标：从小到大
第1轮：最小值是1，它现在在arr[4]，它应该在arr[0]，不对，交换arr[4]和arr[0]，{1,9,2,9,6}
第2轮：最小值是2，它现在在arr[2]，它应该在arr[1]，不对，交换arr[2]和arr[1]，{1,2,9,9,6}
第3轮：最小值是6，它现在在arr[4]，它应该在arr[2]，不对，交换arr[4]和arr[2]，{1,2,6,9,9}
第4轮：最小值是7，它现在在arr[3]，它应该在arr[3]，对，不动
*/
public class Test18SelectSort{
public static void main(String[] args){
int[] arr = {6,9,2,9,1};
//直接选择排序，轮数 = 数组的元素总个数-1
/*
arr.length=5
i=0
i=1
i=2
i=3
*/
for(int i=0; i<arr.length-1; i++){
//找出本轮的最小值，及其下标
/*
i=0，第1轮，查找的范围是[0,4]，一开始假设arr[0]最小
i=1，第2轮，查找的范围是[1,4]，一开始假设arr[1]最小
i=2，第3轮，查找的范围是[2,4]，一开始假设arr[2]最小
i=3，第4轮，查找的范围是[3,4]，一开始假设arr[3]最小
int min = arr[i];
*/
int min = arr[i];
int index = i;
//用[i+1, arr.length-1]范围的元素与min比较
for(int j=i+1; j<arr.length; j++){
if(arr[j] < min){
min = arr[j];
index = j;
}
}
//判断min是否在它应该在的位置
/*
i=0，第1轮，最小值应该在arr[0]位置，它现在在arr[index]位置
i=1，第2轮，最小值应该在arr[1]位置，它现在在arr[index]位置
i=2，第3轮，最小值应该在arr[2]位置，它现在在arr[index]位置
i=3，第4轮，最小值应该在arr[3]位置，它现在在arr[index]位置
最小值应该在arr[i]位置, 如果index!=i，说明它不在应该在的位置，
就交换arr[i]和arr[index]位置
*/
if(index!=i){
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
//完成排序，遍历结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]+" ");
}
}
}5.2 冒泡排序
Java中的经典算法之冒泡排序（Bubble Sort）
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放到前面，大数放到后面。
即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。
然后比较第2个和第3个元素，将小数放到前面，大数放到后面。
如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。
重复第一趟步骤，直至全部排序完成。
public class Test19BubbleSort{
public static void main(String[] args){
int[] arr = {6,9,2,9,1};
//目标：从小到大
//冒泡排序的轮数 = 元素的总个数 - 1
//轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套
//外循环控制 轮数，内循环控制每一轮的比较次数和过程
for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮
/*
假设arr.length=5
i=1,第1轮，比较4次
arr[0]与arr[1]
arr[1]与arr[2]
arr[2]与arr[3]
arr[3]与arr[4]
arr[j]与arr[j+1]，int j=0;j<4; j++
i=2,第2轮，比较3次
arr[0]与arr[1]
arr[1]与arr[2]
arr[2]与arr[3]
arr[j]与arr[j+1]，int j=0;j<3; j++
i=3,第3轮，比较2次
arr[0]与arr[1]
arr[1]与arr[2]
arr[j]与arr[j+1]，int j=0;j<2; j++
i=4,第4轮，比较1次
arr[0]与arr[1]
arr[j]与arr[j+1]，int j=0;j<1; j++
int j=0; j<arr.length-i; j++
*/
for(int j=0; j<arr.length-i; j++){
//希望的是arr[j] < arr[j+1]
if(arr[j] > arr[j+1]){
//交换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]+" ");
}
}
}优化版
class Test19BubbleSort2{
public static void main(String[] args){
int[] arr = {1,3,5,7,9};
//从小到大排序
//int lun = 0;//声明lun变量，统计比较几轮
//int count = 0;//声明count变量，统计比较的次数
for(int i=1; i<arr.length; i++){
//lun++;
boolean flag = true;//假设数组已经是有序的
for(int j=0; j<arr.length-i; j++){
//count++;
//希望的是arr[j] < arr[j+1]
if(arr[j] > arr[j+1]){
//交换arr[j]与arr[j+1]
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = false;//如果元素发生了交换，那么说明数组还没有排好序
}
}
if(flag){
break;
}
}
//System.out.println("一共比较了" + lun +"轮");
//System.out.println("一共比较了" + count +"次");
//完成排序，遍历结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]+" ");
}
}
}
9370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
