题目:给定一个已经排好序的数组和一个目标数据,把目标数据插入给定的数组中
思路:因为数组是已经排好序的,所以可以用二分查找来快速定位要插入的位置
代码实现:
public class InsertIntoSortedArray {
public static void main(String[] args) {
int[] sortedArray = {1, 2, 3, 5, 6, 7, 8, 9}; // 已经排好序的数组
int numToInsert = 4; // 要插入的数
int insertIndex = findInsertIndex(sortedArray, numToInsert);
int[] newArray = insertIntoArray(sortedArray, numToInsert, insertIndex);
System.out.println("插入后的数组:");
for (int num : newArray) {
System.out.print(num + " ");
}
}
// 二分查找插入位置
private static int findInsertIndex(int[] sortedArray, int target) {
int left = 0;
int right = sortedArray.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (sortedArray[mid] == target) {
return mid; // 目标数已存在于数组中,插入位置为mid
} else if (sortedArray[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return left; // 目标数不存在于数组中,插入位置为left
}
// 将数插入数组
private static int[] insertIntoArray(int[] sortedArray, int target, int insertIndex) {
int[] newArray = new int[sortedArray.length + 1];
for (int i = 0, j = 0; i < newArray.length; i++, j++) {
if (i == insertIndex) {
newArray[i] = target;
j--;
} else {
newArray[i] = sortedArray[j];
}
}
return newArray;
}
}
有序数组中目标数是否存在:
/**
* 有序数组中目标数是否存在
*
* @param arr
* @param target
* @return
*/
private int findExistNum(int arr[], int target) {
int left = 0;
int right = arr.length - 1;
int middle = 0;
while (left <= right) {
middle = left + ((right - left) >> 1);
if (arr[middle] == target) {
return middle;
}
if (arr[middle] > target) {
right = middle - 1;
}
if (arr[middle] < target) {
left = middle + 1;
}
}
return -1;
}
@Test
public void testfindExistNum() {
int[] arr = new int[]{1, 3, 5, 7, 10};
System.err.println(findExistNum(arr, 7));
}
有序数组中目标数出现在数组中的第一个位置(最左边):
/**
* 有序数组中目标数的最左位置
*
* @param arr
* @param target
* @return
*/
private int findExistNumLeft(int arr[], int target) {
int left = 0;
int right = arr.length - 1;
int middle = -1;
int tmp = -1;
while (left <= right) {
middle = left + ((right - left) >> 1);
if (arr[middle] == target) {
tmp = middle;
right = middle - 1;
continue;
}
if (arr[middle] > target) {
right = middle - 1;
}
if (arr[middle] < target) {
left = middle + 1;
}
}
return tmp;
}
@Test
public void testfindExistNumLeft() {
int[] arr = new int[]{1, 3, 3, 5, 7, 10};
System.err.println(findExistNumLeft(arr, 3));
}
有序数组中目标数出现在数组中的最后一个位置(最有边):
/**
* 有序数组中目标数的最右位置
*
* @param arr
* @param target
* @return
*/
private int findExistNumRight(int arr[], int target) {
int left = 0;
int right = arr.length - 1;
int middle = -1;
int tmp = -1;
while (left <= right) {
middle = left + ((right - left) >> 1);
if (arr[middle] == target) {
tmp = middle;
left = middle + 1;
continue;
}
if (arr[middle] > target) {
right = middle - 1;
}
if (arr[middle] < target) {
left = middle + 1;
}
}
return tmp;
}
@Test
public void testfindExistNumRight() {
int[] arr = new int[]{1, 3, 3, 3, 3, 3, 5, 7, 10};
System.err.println(findExistNumRight(arr, 3));
}
局部最小:给定一个无需数组,它的特点是任何相邻的两个数不相等,在这个数组中找出一个局部最小即可,局部最小的定义:如果一个数比它两边的数据都小,那么它就是局部最小
/**
* 给定一个无需数组,它的特点是任何相邻的两个数不相等,在这个数组中找出一个局部最小即可
* 局部最小的定义:如果一个数比它两边的数据都小,那么它就是局部最小
*/
private int findLocalMin(int arr[]) {
int left = 0;
int right = arr.length - 1;
int middle = 0;
if (arr[left] < arr[1]) {//第一个元素比它右边小,直接返回
return left;
}
if (arr[right] < arr[right - 1]) {//最后一个元素比它左边小,直接返回
return right;
}
while (left <= right) {
middle = left + ((right - left) >> 1);
if (middle > 0 && arr[middle] > arr[middle - 1]) {
right = middle - 1;
} else if (middle < arr.length - 1 && arr[middle] > arr[middle + 1]) {
left = middle + 1;
} else {
return middle;
}
}
return -1;
}
@Test
public void testfindLocalMin() {
int[] arr = new int[]{2, 1, 0, 1, 5};
System.err.println(findLocalMin(arr));
}