1.数组排序（优化）
1.1冒泡排序
实现步骤
- 比较相邻的元素。如果第一个比第二个大，就交换位置。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个元素。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序的特点是，每一轮循环后，最大的一个数被交换到末尾，因此，下一轮循环就可以“排除”最后的数，每一轮循环都比上一轮循环的结束位置靠前一位。
N个数字来排序，俩俩比较小靠前，总共比较N-1轮
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] ns = { 5, 2, 6, 7, 8, 3, 1, 9, 4 };
// 排序前
System.out.println("排序前:" + Arrays.toString(ns));
for (int i = 0 ,n = ns.length; i < n - 1; i++) {
for (int k = 0; k < n - 1 - i ; k++) {
if (ns[k] > ns[k+1]) {
// 交换ns[k]和ns[k+1]:
int tmp = ns[k];
ns[k] = ns[k+1];
ns[k+1] = tmp;
}
}
}
// 排序后
System.out.println("排序后:" + Arrays.toString(ns));
}
}1.2冒泡排序法（优化后）
如果在一轮比较中没有进行排序，那么就说明数组已经有序，可以提前结束排序，这样可以减少排序的次数，提高排序效率。
public static void main(String[] args) {
// 冒泡排序法
int[] numbers = { 2, 20, 3, 1, 11, 9, 6 };
System.out.println(Arrays.toString(numbers));
/*
* N个数字来排序， 俩俩比较小(大)靠前， 总共比较N-1轮每轮， 比较N-1-i次
*/
int counter = 0;
// 比较n-1轮
for (int i = 0; i < numbers.length - 1; i++) {
// 是否已经处于"有序"状态
// true代表有序
// false代表无序
boolean isSorted = true;
// 每轮比较n-1-i
for (int k = 0; k < numbers.length - 1 - i; k++) {
counter++;
// 相邻比较
if (numbers[k] < numbers[k + 1]) {
//交换
numbers[k] = numbers[k] ^ numbers[k + 1];
numbers[k + 1] = numbers[k] ^ numbers[k + 1];
numbers[k] = numbers[k] ^ numbers[k + 1];
isSorted = false;
}
}
if(isSorted) {
break;
}
}
System.out.println("总共比较了"+counter+"次");
System.out.println(Arrays.toString(numbers));
}1.3使用Arrays工具类排序
Java的标准库已经内置了排序功能，我们只需要调用Arrays.sort()就可以排序：
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
// 排序前
System.out.println("排序前:" + Arrays.toString(ns));
// 排序
Arrays.sort(ns);
// 排序后
System.out.println("排序后:" + Arrays.toString(ns));
}
}2.无序数组查找
2.1遍历查找
遍历的方式进行查找：可以通过对该无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数组中是否存在指定元素。
整型数组
int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
int target = 36; // 目标元素
int index = -1; // 目标元素下标，默认为-1，代表不存在
// 遍历查找
for (int i = 0; i < array.length; i++) {
if(array[i] == target) {
index = i;
break;
}
}
System.out.printf("目标值%d在数组中的下标为：%d",target,index);字符串数组
String[] singerArray = { "李荣浩", "盘尼西林", "王菲", "王贰浪", "鹿先森乐队", "孙燕姿", "G.E.M.邓紫棋", "方大同", "品冠儿子" };
Scanner input = new Scanner(System.in);
String target = "方大同";
int index = -1;
// 遍历查找
for (int i = 0; i < singerArray.length; i++) {
// 字符串等值判断使用equals()方法
if(target.equals(singerArray[i])) {
index = i;
break;
}
}双指针遍历查找
双指针遍历的方式进行查找：通过两个下标，分别从数组头部和尾部，同时对该无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数组中是否存在指定元素。
整型数组
int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
int target = 7; // 目标元素
int index = -1; // 目标元素下标，默认为-1，代表不存在
// 双指针查找
for (int i = 0, k = array.length - 1; i <= k; i++, k--) {
if (array[i] == target) {
index = i;
break;
}
if (array[k] == target) {
index = k;
break;
}
}
System.out.printf("目标值%d在数组中的下标为：%d", target, index);2.2Arrays工具类的binarySearch()方法
除了遍历查找，还可以通过调用Arrays.binarySearch()的方法，进行查找：由于该方法是基于二分查找法实现，数组必须处于有序状态。所以，需要先对数组进行排序，然后再通过Arrays.binarySearch()进行查找。
public class Main {
public static void main(String[] args) {
int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
int target = 36; // 目标元素
// 先排序
Arrays.sort(array);
// 再查找
int index = Arrays.binarySearch(array, target);
System.out.printf("目标值%d在数组中的下标为：%d",target,index);
}
}3.有序数组查找（二分）
在一个有序数组中，如果需要进行指定元素的查找，可以采用二分查找算法，提高查找元素的效率。
二分查找的过程
判断搜索数组的“中位元素”与要查找的“目标元素”是否相等。
- 如果相等，代表查找成功，退出算法；
- 如果不相等，继续比较“中位元素”与要查找的“目标元素”的大小关系；
- 如果“中位元素”大于“目标元素”，当前数组的前半部分作为新的搜索数组，因为后半部分的所有元素都大于“目标元素”，它们全都被排除了。
- 如果“中位元素”小于“目标元素”，当前数组的后半部分作为新的搜索数组，因为前半部分的所有元素都小于“目标元素”，它们全都被排除了。
在新的搜索数组上，重新开始第1步的工作。
二分查找的效率高效，是因为它在匹配不成功的时候，每次都能排除剩余元素中一半的元素。因此可能包含目标元素的有效范围就收缩得很快，而不像遍历查找那样，每次仅能排除一个元素。
public class Main {
public static void main(String[] args) {
int[] array = { 1,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59 };
int target = 37; // 目标元素
int index = -1; // 目标元素的下标，默认为-1，代表不存在
// low和high分别代表搜索数组的开始下标与结束下标
// 默认搜索数组是整个数组
int low = 0, high = array.length - 1;
while (low <= high) {
// 计算"中位元素"的下标
int mid = (high + low) / 2;
if (array[mid] == target) {
// 如果"中位元素"等于"目标元素"，查找成功，退出
index = mid;
break;
} else if (array[mid] < target) {
// 如果"中位元素"小于"目标元素"，当前数组的后半部分作为新的搜索数组
low = mid + 1;
} else if (array[mid] > target) {
// 如果"中位元素"大于"目标元素"，当前数组的前半部分作为新的搜索数组
high = mid - 1;
}
}
System.out.printf("目标值%d在数组中的下标为：%d",target,index);
}
}4.数组乱序
实现步骤
- 假设有一组等待乱序的数组P
- 从P中随机选取一个未乱序的元素
- 将该元素与数组P中最后一个未乱序的元素交换
- 重复2-3的步骤，直到数组P中元素全部完成乱序
int[] p = { 1, 2, 3, 4, 5, 6, 7 };
for (int i = p.length - 1; i > 0; i--) {
int index = (int) (Math.random() * i);
int temp = p[index];
p[index] = p[i];
p[i] = temp;
}
System.out.println(Arrays.toString(p));5.数组旋转
向右旋转的思路：数组元素向右旋转实际上是把元素向左交换，是逆时针方向
public static void main(String[] args) {
int[] numbers = {1,2,3,4,5,6,7};
//向右旋转
//循环3次
for(int k = 0;k<3;k++) {
//每次向右旋转一位
for(int i = numbers.length-1;i>0;i--) {
numbers[i] = numbers[i]^numbers[i-1];
numbers[i-1] = numbers[i]^numbers[i-1];
numbers[i] = numbers[i]^numbers[i-1];
}
}
System.out.println(Arrays.toString(numbers));
}//输出[4, 5, 6, 7, 1, 2, 3]向左旋转的思路：数组元素向左旋转实际上是把元素向右交换，是顺时针方向
public static void main(String[] args) {
int[] numbers = {1,2,3,4,5,6,7};
//向左旋转
//循环3次
for(int k = 0;k<3;k++) {
//每次向左旋转一位
for(int i = 0;i<numbers.length-1;i++) {
numbers[i] = numbers[i]^numbers[i+1];
numbers[i+1] = numbers[i]^numbers[i+1];
numbers[i] = numbers[i]^numbers[i+1];
}
}
System.out.println(Arrays.toString(numbers));
}//输出：[4, 5, 6, 7, 1, 2, 3]
扫一扫
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
