数组：
目录
数组的定义：
一维数组：
数组是一种连续的存储空间并且大小固定的线性表，用来存储多个相同数据类型的容器；
（容器一般是一种数据结构，用来解决多个数据保存和计算的容器）
数组的特点：
-
大小固定
-
连续的存储空间
-
存储的数据类型固定
-
数组是保存在堆内存中，数组的本质是对象！
//第一种
数据类型 [] 变量名称 = new 数据类型 [size];
//第二种
数据类型 [] 变量名称 = new 数据类型 []{值1，值2……};
//第三种
数据类型 [] 变量名称 = {值1，值2……};数组对象.length 属性 （获取元素的个数）
通过下标来访问元素：编程中下标都是（99%）从零开始！！
数组对象【下标】：通过下标来访问元素的值
修改元素的数值： 数组对象 【下标】 = 新值
遍历数组：制造索引
foreach：循环加强 for( 数据类型 临时变量 ： 可迭代对象){ 输出临时变量}
public static void main(String[] args) {
// TODO 数组的使用练习
int arr [] = new int [10];
int arr1 [] = new int [] {1,2,3,4,5,6,7,8,9};
System.out.println("数组的长度为：" + arr.length);
System.out.println("数组下标为八的值为：" + arr1[8]);
//修改数组对应的下标的值
arr1[8] = 100;
//增强for循环来遍历元素
for (int i : arr1) {
System.out.print(i + " ");
}
/*
数组的长度为：10
数组下标为八的值为：9
1 2 3 4 5 6 7 8 100
*/二维数组：
数据类型 数组名称 【】【】 = new 数据类型 【行】【列】；
简单的方式定义： 数据类型 数组名称【】【】 = { {1， 1， 1，} ，{2， 2， 2}}
package com.lele.day7_18;
public class Zuo01 {
public static void main(String[] args) {
// TODO 数组的使用练习
int arr [][] = new int [3][2];
System.out.println("数组的行为：" + arr.length);
System.out.println("数组的列为：" + arr[0].length);
print(arr);
int arr1 [][] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
print(arr1);
arr1[2][2] = 100;
print(arr1);
}
public static void print(int arr [][]) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[0].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
/*
数组的行为：3
数组的列为：2
0 0
0 0
0 0
1 2 3
4 5 6
7 8 9
1 2 3
4 5 6
7 8 100
*/数组中的算法：
数据结构与算法中算法（排序和查找的算法）
排序：将无序的数据按照特定的规则排成有序的数据（升序，降序）
冒泡排序：
冒泡排序算法的原理如下：（大数上浮法：每一次找一个最大值）
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
package Test;
import java.util.Scanner;
public class Day07 {
public static void main(String[] args) {
int arr[] = {1,5,9,56,12,45,100,-1};
Sort(arr);
}
public static void Sort(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]){
//第一种
// arr[j] = arr[j] ^ arr[j + 1];
// arr[j + 1] = arr[j] ^ arr[j + 1];
// arr[j] = arr[j] ^ arr[j + 1];
//第二种
int temp = arr[j+1];
arr[j + 1] = arr[j];
arr[j] = temp;
//第三种
// arr[j] = arr[j] + arr[j + 1];
// arr[j + 1] = arr[j] -arr[ j +1] ;
// arr[j] = arr[j] - arr[ j +1] ;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
选择排序：
默认第一个值为最小值，依次做判断，直到找到真正的最小值，交换这两个数字
package com.lele.day7_18;
public class Zuo01 {
public static void main(String[] args) {
// TODO 数组的使用练习
int arr [] = {4, 5, 6, 9, 8, 7, 2, 1, 3};
selectSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
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]) {
swap(arr, j, i);
}
}
}
}
private static void swap(int[] arr, int i, int j) {
arr[j] = arr[j] ^ arr[i];
arr[i] = arr[j] ^ arr[i];
arr[j] = arr[j] ^ arr[i];
}
}
插入排序：
插入排序是指在待排序的元素中，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序
默认第一个数是有序的，把之后的元素依次插入到这个有序数组中，插入式必须保证数组一直有序
package com.lele.day7_18;
public class Zuo01 {
public static void main(String[] args) {
// TODO 数组的使用练习
int arr [] = {4, 5, 6, 9, 8, 7, 2, 1, 3};
insertSort(arr);
for (int i : arr) {
System.out.print(i + " ");
}
}
public static void insertSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j > 0; j--) {
if (arr[j] < arr[j - 1]) {
swap(arr, j, j - 1);
}
}
}
}
private static void swap(int[] arr, int i, int j) {
arr[j] = arr[j] ^ arr[i];
arr[i] = arr[j] ^ arr[i];
arr[j] = arr[j] ^ arr[i];
}
}
二分查找：
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
特点：针有序的序列，可以直接查找中间值，大于中间值则在后半部分，反之则在前面
public static int ECha01(int[] arr, int key) {
int start = 0,end = arr.length -1;
while (start <= end){
int mind = (start + end) / 2;
if (arr[mind] > key){
end = mind - 1;
}else if (arr[mind] < key){
start = mind + 1;
}
else {
return mind;
}
}
return -1;
}// 二分查找，递归完成
public static int binarySearch(int[] arr, int target, int start, int end) {
if (start > end) {
return -1;
}
int middle = (start + end) / 2;
if (target == arr[middle]) {
return middle;
} else if (target > arr[middle]) {
return binarySearch02(arr, target, middle + 1, end);
} else {
return binarySearch02(arr, target, start, middle - 1);
}
}算法的特性：
-
算法的时间复杂度 （冒泡：O(n ^ 2) 选择：O（n^2) )
-
算法的空间复杂度 （与时间成反比）
-
算法的稳定性 （看某个数字的相对位置）
596
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
