数组排序（优化）
基本思路：
冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换位置。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。针对所有的元素重复以上的步骤，除了最后一个元素。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序口诀：
/*N个数字来排序
* 两两比较小(大)靠前
* 总共比较N-1轮 每轮
* 比较N-1-i次
*/
代码实现：
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
//无序数组
int[] numbers = {4,6,3,4,2};
System.out.println(Arrays.toString(numbers));
//交换
int counter = 0;
//比较n-1轮
for(int i = 0,n= numbers.length;i < n-1;i++) {
//是否已经处于"有序"状态
//true代表有序
//false代表无序
boolean isSorted = true;
//每轮比较n-1-i次
for(int k = 0;k < n-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));
}
}
运行结果：
[4, 6, 3, 4, 2]
输出的次数为:10
[2, 3, 4, 4, 6]无序数组查找
基本思路：
1.遍历查找：通过对无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数字中是否存在指定元素。通过逆序和顺序遍历两种方式查找目标元素。
代码实现：
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
int[] array = {1,2,3,2,3,4,5,6,7};
try(Scanner input = new Scanner(System.in)){
int target = input.nextInt();
int index = -1;
//案例1:查找在"无序数组"中目标元素第一次出现的位置
for(int i = 0;i <array.length;i++) {
if(array[i] == target) {
index = i;
break;
}
}
System.out.printf("目标元素%d第一次出现位置是%d\n",target,index);
//案例2:查找在"无序数组"中目标元素最后一次出现的位置
//方法一:
for(int i = 0;i <array.length;i++) {
if(array[i] == target) {
index = i;
}
}
System.out.printf("目标元素%d最后一次出现的位置是%d\n",target,index);
//方法二:
for(int i = array.length-1;i >= 0;i--) {
if(array[i] == target) {
index = i;
break;
}
}
System.out.printf("目标元素%d最后一次出现的位置是%d\n",target,index);
}
}
}
运行结果：
2
目标元素2第一次出现位置是1
目标元素2最后一次出现的位置是3
目标元素2最后一次出现的位置是32.双指针查找：通过两个下标，分别从数组的头部和尾部，同时对该无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数字中是否存在目标数组。
代码实现：
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
String[] singerArray = { "李荣浩", "盘尼西林", "王菲", "王贰浪", "鹿先森乐队", "孙燕姿", "G.E.M.邓紫棋", "方大同", "品冠儿子" };
try(Scanner input = new Scanner(System.in)){
String target = input.next();
int index = -1;
for(int i = 0,k = singerArray.length-1;i<=k;i++,k--) {
//从头开始
if(singerArray[i].equals(target)) {
index = i;
break;
}
//从尾开始
if(singerArray[k].equals(target)) {
index = k;
break;
}
}
System.out.println(index);
}
}
}
运行结果：
王贰浪
33.Arrays工具类，先使用Arrays.sort()方法数组进行排序，再使用binarysearch()方法进行排序（该方法基于二分查找法实现，数组必须是有序状态）
import java.lang.reflect.Array;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] array = {28,12,89,73,65,18,96,50,8,36};
int target = 36;
Arrays.sort(array);
System.out.println(Arrays.toString(array));
int index = Arrays.binarySearch(array, target);
System.out.println(index);
}
}
运行结果：
[8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
4有序数组查找（二分）
基本思路：
二分查找：在一个有序数组中，对指定的元素进行查找。
判断搜索数组的“中位元素”与要查找的“目标元素”是否相等。
1.如果相等，代表查找成功，退出算法。
2.如果不相等，继续比较“中位元素”与要查找的“目标元素”的大小关系。
2.1.如果“中位元素”大于“目标元素”，当前数组的前半部分作为新的搜索数组，因 为后半部分的所有元素都大于“目标元素”，它们全都被排除了。
2.2.如果“中位元素”小于“目标元素”，当前数组的后半部分作为新的搜索数组，因 为前半部分的所有元素都小于“目标元素”，它们全都被排除了。
在新的搜索数组上，重新开始第1步的工作。
代码实现：
public class Test04 {
public static void main(String[] args) {
int[] numbers = {1,2,3,4,5,6,7,8,9};
int target = 5;
int index = -1;
//数组的"首"+"尾"
int low = 0,high = numbers.length - 1;
while(low <= high) {
//计算当前"中间位"下标
int mid = (low + high) /2;
//判断中间位下标的元素是否与目标元素相等
if(numbers[mid] == target) {
index = mid;
break;
}else if(numbers[mid] < target) {
low = mid + 1;
}else if(numbers[mid] > target) {
high = mid - 1;
}
}
System.out.println(index);
}
}
运行结果：
4
数组乱序
基本思路：
从数组末尾开始，依次遍历数组中的每个元素。对于当前遍历到的元素，随机生成一个小于等于当前位置的下标值。将当前元素与随机下标处的元素交换位置。
代码实现：
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] numbers = {11,12,13,14,15,16,17};
System.out.println(Arrays.toString(numbers));
System.out.println();
for(int i = numbers.length-1;i>0;i--) {
//产生随机下标
int index = (int)(Math.random()*i);
numbers[index] = numbers[index] ^ numbers[i];
numbers[i] = numbers[index] ^ numbers[i];
numbers[index] = numbers[index] ^ numbers[i];
}
System.out.println(Arrays.toString(numbers));
}
}
运行结果：
[11, 12, 13, 14, 15, 16, 17]
[12, 16, 15, 17, 14, 13, 11]
数组旋转
基本思路：
向右旋转:把尾元素，通过不断交换，移动到数组的"头部"
向左旋转:把头元素，通过不断交换，移动到数组的"尾部"
代码实现：
package study;
import java.util.Arrays;
public class Demo11 {
public static void main(String[] args) {
int[] numbers = {1,2,3,4,5,6,7};
System.out.println("原始数组"+Arrays.toString(numbers));
right(numbers,3);
System.out.println("向左旋转"+Arrays.toString(numbers));
right(numbers,2);
System.out.println("向右旋转"+Arrays.toString(numbers));
}
// 向右旋转:把尾元素，通过不断交换，移动到数组的"头部"
public static void right(int[] ns,int n) {
// 向右旋转几次
for(int i = 1;i <= n;i++) {
for(int k = ns.length-1;k >0;k--) {
//每次向右旋转1位
ns[k] = ns[k] ^ ns[k-1];
ns[k-1] = ns[k] ^ ns[k-1];
ns[k] = ns[k] ^ ns[k-1];
}
}
}
//向左旋转:把头元素，通过不断交换，移动到数组的"尾部"
public static void left(int[] ns,int n) {
for(int i = 1;i <= n;i++) {
for(int k = 0;k < ns.length-1;k++) {
ns[k] = ns[k] ^ ns[k+1];
ns[k+1] = ns[k] ^ ns[k+1];
ns[k] = ns[k] ^ ns[k+1];
}
}
}
}
运行结果：
原始数组[1, 2, 3, 4, 5, 6, 7]
向左旋转[5, 6, 7, 1, 2, 3, 4]
向右旋转[3, 4, 5, 6, 7, 1, 2]
扫一扫
776
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
