1.陣列元素的賦值(楊輝三角、回形數等)
2.求數值型陣列中元素的最大值、最小值、平均數、總和等
3.陣列的復制、反轉、查找(線性查找、二分法查找)
4.陣列元素的排序演算法一：楊輝三角（陣列元素的賦值）
public class yanghuisanjiao {
public static void main(String[] args) {
//宣告并初始化二維陣列，給陣列的元素賦值，遍歷二維陣列
int[][] yanghui = new int[10][];
for (int i=0; i< yanghui.length; i++){
yanghui[i] = new int[i+1];
//給首末元素賦值
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];
}
}
}
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();
}
}
}
二：求數值型陣列中元素的最大值、最小值、平均數、總和等
import org.w3c.dom.ls.LSOutput;
public class arraysuanfa {
public static void main(String[] args) {
/*演算法的考察：
求數值型陣列中元素的最大值、最小值、平均數、總和等
定義一個 int 型的一維陣列，包含 10 個元素，分別賦一些隨機整數，
然后求出所有元素的最大值，最小值，和值，平均值，并輸出出來，
要求：所有亂數都是兩位數，
[10,99]
兩位數亂數公式:(int)(Math.random()*(99- 10 + 1) + 10)
*/
int[] arr = new int[10];
for (int i=0;i< arr.length; i++){
arr[i] = (int)(Math.random()*(99- 10 + 1) + 10);//亂數
}
//求陣列元素的最大值,最小值
int maxvalue = https://www.cnblogs.com/zhaohuimin/archive/2023/01/18/arr[0];
int minvalue = arr[0];
for (int i=0;i< arr.length; i++){
if (maxvaluearr[i]){
minvalue=arr[i];
}
}
System.out.println("最大值是："+maxvalue);
System.out.println("最小值是："+minvalue);
//求陣列元素的總和
int sum = 0;
for (int i=0;i<arr.length; i++){
sum += arr[i];
}
System.out.println("總和為："+sum);
//求平均數
double avgvales = sum / arr.length;
System.out.println("平均數為:"+avgvales);
}
}
三：陣列的復制、反轉、查找(線性查找、二分法查找)
public class arraysuanfa2 {
/*
* 演算法的考察：陣列的復制、反轉、查找(線性查找、二分法查找)
*/
public static void main(String[] args) {
String[] arr = new String[]{"aa","bb","cc","dd","ee","ff"};
//陣列的復制(區別于賦值:arr1=arr)
String[] arr1 = new String[arr.length];
for (int i=0; i< arr.length; i++){
arr1[i] = arr[i];
}
//陣列的反轉
//方法一:
// 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--){
String temp = arr[i];
arr[i] = arr[j];
arr[j]= temp;
}
//遍歷
for (int i=0; i< arr.length; i++){
System.out.print(arr[i] + "\t");
}
//查找(搜素)
//線性查找
String dest = "aa";
boolean isFlag = true;
for (int i=0;i< arr.length;i++){
if (dest.equals(arr[i])){
System.out.println("找到了該元素,位置為"+i);
isFlag = false;
break;
}
}
if (isFlag){
System.out.println("不好意思沒找到哈哈");
}
}
}
3.2二分法查找
public class erfenchazhao {
public static void main(String[] args) {
//二分查找
//前提:所要查找的陣列必須有序
int[] arr2 = new int[]{-1,0,3,5,6,8,9,11,46};
int dest1 = -98;
int head = 0; //初始的首索引
int end = arr2.length - 1; //初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if (dest1 == arr2[middle]){
System.out.println("找到了該元素,位置為"+middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}
}
if (isFlag1){
System.out.println("不好意思沒找到哈哈");
}
}
}
四：陣列元素的排序演算法
排序:假設含有n個記錄的序列為{R1，R2，...,Rn),其相應的關鍵字序列為(K1，K2，...,Kn)，將這些記錄重新排序為(Ri1,Ri2,...,Rin),使得相應的關鍵字值滿足條Ki1<=Ki2<=...<=Kin,這樣的一種操作稱為排序，
通常來說，排序的目的是快速查找
衡量排序演算法的優劣:
1.時間復雜度:分析關鍵字的比較次數和記錄的移動次數
2.空間復雜度:分析排序演算法中需要多少輔助記憶體
3.穩定性:若兩個記錄A和B的關鍵字值相等，但排序后A、B的先后次序保持不變，則稱這種排序演算法是穩定的，
排序演算法分類:內部排序和外部排序
內部排序:整個排序程序不需要借助于外部存盤器(如磁盤等)，所有排字操作都在記憶體中完成，
外部排序:參與排序的資料非常多，資料量非常大，計算機無法把整個排序程序放在記憶體中完成，必須借助于外部存盤器(如磁盤)，外部排序最常見的是多路歸并排序，可以認為外部排序是由多次內部排序組成，
十大內部排序演算法：
選擇排序：直接選擇排序，堆排序
交換排序：冒泡排序，快速排序 （這兩個必須會手寫）
插入排序：直接插入排序，折半插入排序，shell排序
歸并排序
桶式排序
基數排序
冒泡排序演算法如下：
public class paixumaopao {
public static void main(String[] args) {
int[] arr = new int[]{13,56,78,23,56,23};
//冒泡排序
for (int i=0; i<arr.length - 1; i++){
for (int j=0; j<arr.length-1-i; i++){
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.println(arr[i] + "\t");
}
}
}
快速排序演算法如下：
/**
* 快速排序
* 通過一趟排序將待排序記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分關鍵字小，
* 則分別對這兩部分繼續進行排序，直到整個序列有序，
*
*/
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//遞回呼叫
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = https://www.cnblogs.com/zhaohuimin/archive/2023/01/18/{ 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
}
}
Arrays 工具類的使用
import java.util.Arrays;
public class tools {
//java.util.Arrays類即為操作陣列的工具類，包含了用來操作陣列（比如排序和搜索）的各種方法，
public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b) 判斷兩個陣列是否相等
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1,arr2);
System.out.println(isEquals);//false 因為陣列順序是不能變的
//String toString(int[] a) 輸出陣列資訊
System.out.println(Arrays.toString(arr1));
//void fill(int[] a,int val) 將指定值填充到陣列之中
Arrays.fill(arr1,23);
System.out.println(Arrays.toString(arr1));
//void sort(int[] a) 對陣列進行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//int binarySearch(int[] a,int key) 對排序后的陣列進行二分法檢索指定的值
int[] arr3 = new int[]{43,56,78,-12,46};
int index = Arrays.binarySearch(arr3,43);
if (index >= 0){
System.out.println("該元素位置為"+index);
}else{
System.out.println("未找到");
}
}
}
陣列中的常見例外
public class yichang {
/*
* 陣列中的常見例外：
* 1.陣列角標越界的例外:ArrayIndexOutOfBoundsException
*
* 2.空指標例外:NullPointerException
*
*/
public static void main(String[] args) {
//1.陣列角標越界的例外:ArrayIndexOutOfBoundsException
int[] arr = new int[]{1,2,3,4,5,6};
//舉例：
// for (int i=0; i<=arr.length; i++){
// System.out.println(arr[i]);//遍歷了7次，而陣列長度為6，應該改為 i<arr.length或者 i<=arr.length-1
// }
// 2.空指標例外:NullPointerException
//情況一：
// int[] arr1 = new int[]{1,2,3};
// arr1 = null;
// System.out.println(arr1[0]);
//情況二：
// int[][] arr2 = new int[4][];
// System.out.println(arr2[0][0]);
//情況三：
String[] arr3 = new String[]{"aa","bb"};
arr3[0] = null;
System.out.println(arr3[0].toString());
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/542208.html
標籤：其他
上一篇：lambda運算式基礎
下一篇：學習筆記——Spring宣告式事務管理；Spring中支持事務管理；使用宣告式事務管理；Spring宣告式事務管理屬性