Java基础
数组
- 是一种引用数据类型;
- 用于存储一组相同数据类型的数据结果;
- 长度一旦定义,则不可改变;
- 线性结构(连续);
数组的定义
-
数据类型[] 变量名;
- 动态初始化即在创建数组时,只声明数组的长度,不位指定位置赋值。
int [] array = {1,2,3,4}; //静态初始化 int [] array2 = new int [5]; //动态初始化 int [] array3 = new int []{1,2,3,4};
数组的引用
- 因为数组是引用数据类型,所以保存的是空间地址;
- 数组通过下标进行访问;
多维数组
- 在堆中创建多个空间,列记录指向行地址的数据。
几种简单排序算法
冒泡排序
- 计算机科学领域一种比较简单的排序算法;
- 它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果顺序(如从大到小)错误就把他们交换过来。直到没有相邻元素需要交换(即已经排序完成);
int[] array = new int[10];
for (int i = 0; i < 10; i++) { //为数组随机赋十个值
array[i] = (int) (Math.random() * 101);
}
System.out.println(Arrays.toString(array));
for (int j = 0; j < 9 ; j++) { //排序比较次数为 数组长度 - 1
for (int i = 0; i < 9 - j; i++) { //每次排序后最末位确定 下一次排序不再和最末位比较
if (array[i] < array[i + 1]) { //如果后一位的数值大于当前数值,则进行交换
array[i] = array[i] ^ array[i + 1];
array[i + 1] = array[i] ^ array[i + 1];
array[i] = array[i] ^ array[i + 1];
}
}
}
System.out.println(Arrays.toString(array));
选择排序
- 是一种简单直观的排序方法;
- 第一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后再从剩余的未排序元素中寻找到最小(大)元素,然后放到已排序的序列的末尾。以此类推,直到全部待排序的数据元素的个数为零。
int[] array = new int[10];
for (int i = 0; i < 10; i++) { //为数组随机赋十个值
array[i] = (int) (Math.random() * 101);
}
System.out.println(Arrays.toString(array));
for (int i = 0; i < array.length; i++) {
int max = i; //记录第一个数的位置
for (int j = i + 1; j < array.length; j++) {
if (array[j] > array[max]) {
max = j; //条件成立则记录新的最大值下标
}
}
if (max != i) { //如果最大值下标不为初始赋的值则进行交换
array[i] = array[max] ^ array[i];
array[max] = array[max] ^ array[i];
array[i] = array[max] ^ array[i];
}
}
System.out.println(Arrays.toString(array));
快速排序
- 快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
- 快速排序算法通过多次比较和交换来实现排序,其排序流程如下:
- 首先设定一个分界值,通过该分界值将数组分成左右两部分。
- 将大于或等于分界值的数据集中到数组右边,小于分界值的数据集中到数组的左边。此时,左边部分中各元素都小于或等于分界值,而右边部分中各元素都大于或等于分界值。
- 然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理。
- 重复上述过程,可以看出,这是一个递归定义。通过递归将左侧部分排好序后,再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后,整个数组的排序也就完成了。
public class QuickSort {
public static void main(String[] args) {
int[] arr = new int[10];
for (int i = 0; i < 10; i++) {
arr[i] = (int) (Math.random() * 101);
}
System.out.println(Arrays.toString(arr));
QuickSort(arr, 0, arr.length - 1); //调用函数
System.out.println(Arrays.toString(arr));
}
public static void QuickSort(int[] arr, int i, int j) {
int start = i, end = j;
while (i < j) {
while (i < j) { // 一.以首位为基准位 ,从末位开始比较 ,大于首位则调换位置
if (arr[j] > arr[i]) {
arr[j] = arr[j] ^ arr[i];
arr[i] = arr[j] ^ arr[i];
arr[j] = arr[j] ^ arr[i];
break;
} else {
j--;
}
}
while (i < j) { //二.以调换后的j位(即原来首位的值)为基准,从首位开始比较,小于基准值则调换位置
if (arr[i] < arr[j]) {
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
break;
} else {
i++;
}
}
}
//第一轮的调换结束后基准值右侧的值均小于基准值,基准值左侧的值均大于基准值
if (i - start > 1) { // 判断基准值左侧数值的个数 ,大于2则进行 一、二步骤
QuickSort(arr, start, i - 1);
}
if (end - j > 1) {// 判断基准值右侧数值的个数 ,大于2则进行 一、二步骤
QuickSort(arr, j + 1, end);
}
}
二分法
-
当数据量很大时适宜采用此方法;
-
二分法的前提是数列是有序的,假定数据是升序排列,对于给定值key,从序列的中间位置k开始比较,
如果当前位置arr[k]值等于key,则查找成功;
若key小于当前位置值arr[k],则在数列的前半段中查找,arr[low,mid-1];
若key大于当前位置值arr[k],则在数列的后半段中继续查找arr[mid+1,high],
直到找到为止
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入数组数值的个数:");
int i = sc.nextInt();
int[] arr = new int[i];
for (int k = 0; k < i; k++) { //给数组赋十个随机值
arr[k] = (int) (Math.random() * 10000);
}
bubbleSort(arr); //调用函数进行排序
//折半查找
System.out.print("(while)请输入要查找的数:");
int searchNum = sc.nextInt();
int last = arr.length - 1, start = 0;
boolean isSearchNum = false;
while (!isSearchNum) {
int middle = (last + start) / 2; //每次循环重新定义中间值
if (last < start + 1) {
System.out.println("要查找的数不存在!");
break;
}
if (searchNum == arr[middle]) {
System.out.print("要查找的数位置在:" + middle);
isSearchNum = true;
} else if (searchNum < arr[middle]) {
last = middle;
} else {
start = middle;
}
}
}
public static void bubbleSort(int[] arr) { //冒泡排序
for (int j = 0; j < arr.length - 1; j++) {
for (int i = 0; i < arr.length - j - 1; i++) {
if (arr[i] < arr[i + 1]) {
arr[i] = arr[i] ^ arr[i + 1];
arr[i + 1] = arr[i] ^ arr[i + 1];
arr[i] = arr[i] ^ arr[i + 1];
}
}
}
}