数组,排序练习

package com.sxt;

import java.util.Scanner;


public class arrayDemo01 {

	public static void main(String[] args) {
		/*
		 *     键盘录入30个学生的成绩，并求出平均成绩
		 * 
		 * */
		Scanner input = new Scanner(System.in);
		double[] scores = new double[3];
		
		// 定义求和变量
		double sum = 0.0;
		double average = 0.0;
		
		// 遍历数组
		for (int i = 0; i < scores.length; i++) {
			System.out.print("请输入第" + (i + 1) + "个学生的成绩：");
			scores[i]= input.nextDouble();
			sum += scores[i];
		}
		average = sum / scores.length;
		System.out.println(scores.length + "个同学的总分是：" + sum + ",平均分是：" + average);
	}
	
}
=====================================================================
package com.sxt;

import java.util.Arrays;
import java.util.Scanner;

/*
 *   有一个数列：{8 , 4 , 2 , 1 , 23 , 344 , 12}
 * A  循环输出数列的值
 * B  求数列中所有数值的和
 * C  求出最大值
 * D  将数组倒置并输出
 * E  从键盘输入一个数，判断数列中是否包含此数
 * F  数组排序
 ***/
public class AarrayDemo_02 {

	public static void main(String[] args) {

		int[] math = new int[]{8 , 4 , 2 , 1 , 23 , 344 , 12};
				printArray(math);
				System.out.println("数组中所有元素的和为：" + getSum(math));
				System.out.println("数组中所有元素最大值为：" + getMax(math));
				System.out.println("倒置前" + Arrays.toString(math));
				reverse(math);
				System.out.println("倒置后" + Arrays.toString(math));
				System.out.println(basicSearch(math, 8));
				 int index = basicSearch2(math, 8);
				System.out.println((index >= 0) ?"找到该数，索引是：" + index + ",该数为：" + math[index]:"该数不存在");
	}
      /*循环输出数列的值
	    返回值类型：void
	  参数列表： int[] math
	  方法名 ：printArray */

	public static void printArray(int[] math) {

		for (int i = 0; i < math.length; i++) {
			System.out.println(math[i]);
		}
	}
	/*
	 * 求数列中所有数值的和
	 *  返回值类型： int
	 *  参数列表： int[] arr
	 *  方法名： getSum
	 */
	public static int getSum(int[] math) {
		int sum = 0;
		for (int i = 0; i < math.length; i++) {
			sum += math[i];
		}
		return sum;
	}
	public static int getMax(int[] math) {
		int max = 0;		
		for (int i = 0; i < math.length; i++) {
				if (max < math[i]) {
					max = math[i];
				}				
		}
		return max;
	}
	/*
	 *   将数组倒置并输出
	 *   返回值类型： void
	 *   参数列表： int[]
	 *   方法名： reverse
	 */
	public static void reverse(int[] math) {
		int x = 0;
		for (int i = 0; i < math.length / 2; i++) {
				x = math[i];
				math[i] = math[math.length - 1 - i];				
				math[math.length -1 - i] = x;	
			
		}

	}
	/*
	 * 	数组查找 
	 * 	方式一：
	 * 	返回值类型： boolean
	 * 	参数列表： int[] math, int num
	 * 	方法名： basicSearch
	 */
	public static boolean  basicSearch(int[] math, int num) {
		boolean flag = false;
		
		 for (int i = 0; i < math.length; i++) {
			if (num == math[i]) {
				flag = true;
			} 
		}
		 return flag;
	}
	/*
	 * 	方式二：
	 * 	返回值类型：int 该数的索引
	 * 	参数列表： int[] math, int num
	 * 	方法名： basicSearch2
	 */
	public static int  basicSearch2(int[] math, int num) {
		int index = -1;
		
		 for (int i = 0; i < math.length; i++) {
			if (num == math[i]) {
				index = i;
				break;
			} 
		}
		 return index;
	}

	
	
	public static void nb(int[] math) {
		for (int i = math.length-1; i >= 0 ; i--) {
			System.out.print(math[i] + " ");
		}
	} 
		
	}
==================================================================
package com.sxt;

import java.util.Arrays;

public class ArrayDemo_03 {
	/*
	 * 	排序
	 * 	冒泡，选择 希尔 堆 快速........
	 * 
	 * 		冒泡排序法原理：
	 * 		1.相邻两个元素进行比较，大的数会冒泡，每比较一趟，最大值就排到了最索引处
	 * 		2.一共比较了 arr.length - 1 趟
	 * 		3.每一趟比较的次数都比上一趟少一次
	 */
	public static void main(String[] args) {
		int[] arr = {24, 69, 80, 55, 13};
		System.out.println("排序前：" + Arrays.toString(arr));
		
		bubbleSort(arr);
		System.out.println("冒泡排序后：" + Arrays.toString(arr));
		selectSort(arr);
		System.out.println("选择排序后：" + Arrays.toString(arr));
	}
	public static void bubbleSort(int[] arr) {
		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 = 0;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
			
		}
	}
	public static void selectSort(int[] arr) {
				for (int i = 0; i < arr.length - 1; i++) {
					for (int j = i+1; j < arr.length; j++) {
					if (arr[j] < arr[i] ) {
						int temp = 0;
						temp = arr[j];
						arr[j] = arr[i];
						arr[i] = temp; 
					}
				}
			}
				
	}

}
======================================================
package com.sxt;

import java.util.Scanner;

public class AarrayDemo_04 {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入会员本月消费记录：");		
		double[] moneys = new double[5];
		
		double sum = 0.0;
		for (int i = 0; i < moneys.length; i++) {
			System.out.print("请输入第" + (i+1) + "笔购物金额：");
			moneys[i] = input.nextDouble();
			sum += moneys[i];
		}
		
		bubbleSort(moneys);
		
		System.out.println("序号\t\t\t金额(元)");
		for (int i = 0; i < moneys.length; i++) {
			System.out.println((i+1) + "\t\t\t" + moneys[i]);
		}
		System.out.println("总金额\t\t\t" + sum);

	}
	public static void bubbleSort(int [] arr) {
		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 = 0;
					temp = arr[j];
					arr[j] = arr[j+1]; 
					arr[j+1] = temp;
				}
			}
		}
	} 
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[j] < arr[i] ) {
					int temp = 0;
					temp = arr[j];
					arr[j] = arr[i];
					arr[i] = temp; 
				}
			}
		}
	}
	public static void bubbleSort(double[] arr) {
		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]) {
					double temp = 0;
					temp = arr[j];
					arr[j] = arr[j+1]; 
					arr[j+1] = temp;
				}
			}
		}
	} 
	public static void selectSort(double[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[j] < arr[i] ) {
					double temp = 0;
					temp = arr[j];
					arr[j] = arr[i];
					arr[i] = temp; 
				}
			}
		}
	}

}

1.现有一个数组,要求对数组进行倒置并且按照如下格式输出
int[] arr = {11,22,33,44,55,66,77}
输出结果77-66-55-44-33-22-11

package com.sxt.practice;

import java.util.Arrays;

public class Practice01 {
	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55,66,77};
		reverse(arr);
		System.out.println(arrayToString(arr));
	}
	
	public static void reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
	}
	
	public static String arrayToString(int[] arr) {
		String result = "";
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				result += arr[i];
			} else {
				result += arr[i] + "-";
			}
		}
		return result;
	}
	
}

查找方式
基本查找: 无论元素是否有序都可以查找
二分法查找: 针对有序的元素进行查找(效率更高)

package com.sxt.arraydemo;

import java.util.Arrays;

public class ArrayDemo13 {
	public static void main(String[] args) {
		int[] arr = { 23, 67, 31, 56, 18, 79, 22 };
		System.out.println(basicSearch(arr, 23));
		// 先排序
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		System.out.println(binarySearch(arr, 25));
		System.out.println(Arrays.binarySearch(arr, 35));
	}
	
	public static int basicSearch(int[] arr, int num) {
		int index = -1;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == num) {
				index = i;
				break;
			}
		}
		return index;
	}

	public static int binarySearch(int[] arr, int num) {

		// 1.定义最小索引和最大索引
		int min = 0;
		int max = arr.length - 1;

		// 2.计算中间索引
		int mid = (min + max) / 2;

		// 3.拿中间索引所对应的值和需要查找的数进行比较,循环比较
		while (arr[mid] != num) {
			/*
			 * 大了,在左边找 小了,在右边找
			 */
			if (arr[mid] > num) {
				max = mid - 1;
			} else if (arr[mid] < num) {
				min = mid + 1;
			}

			// 最小索引一直在递增,最大索引一直在递减,如果最小索引还要大于最大索引,那么没找到
			if (min > max) {
				return -1;
			}

			// 重新计算中间索引
			mid = (min + max) / 2;
		}

		return mid;
	}
	
}