算法题目 | 4道基于分治模式、快排思想的算法题(1.奇数在左,偶数在右 2.查找第k小的数 3.寻找发帖"水王" 4.最小可用ID)

最新推荐文章于 2023-05-12 09:54:59 发布
最新推荐文章于 2023-05-12 09:54:59 发布
阅读量458 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RUIRUI14/article/details/104724658
版权

文章目录

前期准备：自定义数组工具类MyArrays

关于分治、快排的知识可以点这里简单学习一下
① int[] getArr(int length, int min, int max)：自动生成一个数组，方便测试时调用
② void swap(int[] arr, int i, int j)：交换数组两元素的位置

/**
 * 自定义数组工具类
 * 
 * @author LRRacac
 *
 */
public class MyArrays {
	/**
	 * 自动生成一个长度为length，元素值介于[min,max]之间的数组
	 * 
	 * @param length---待生成数组的长度
	 * @param min---数组元素的最小值
	 * @param max---数组元素的最大值
	 * @return int[]---返回生成的数组
	 */
	public static int[] getArr(int length, int min, int max) {
		int[] arr = new int[length];
		for (int i = 0; i < arr.length; i++) {
			// 随机生成一个元素值介于[min,max]内的一个元素
			arr[i] = (int) (Math.random() * (max - min + 1) + min);
		}
		return arr;
	}

	/**
	 * 交换数组arr中两元素的位置---即arr[i]与arr[j]位置对调
	 * 
	 * @param arr---待交换元素的数组
	 * @param i---待交换元素的位置
	 * @param j---待交换元素的位置
	 */
	public static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

题目1：调整数组顺序使奇数位于偶数前面

题目描述：
输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分，要求时间复杂度为O(n)

思路分析：
① 定义两个扫描指针，左指针初试指向数组首元素，右指针初始指向最后一个元素
② 让左指针往右依次扫描，右指针依次往左扫描，若左指针扫描到的元素为奇数则左指针继续向右扫描，当扫描的元素为偶数则停止；同理，右指针扫描到偶数则继续向左扫描，否则停止。
③ 此时左指针指向偶数，右指针指向奇数，将两指针所指元素进行位置交换，继续②的操作，直至左指针越过右指针

代码展示：

/**
 * 奇数在左，偶数在右
 * 
 * @author LRRacac
 *
 */
import java.util.Arrays;
public class OddEvenNumber {
	public static void main(String[] args) {
		/*
		 * 测试：奇数在左，偶数在右
		 */
		int arr[] = MyArrays.getArr(10, 1, 30); // 获取一个长度为10，元素值介于[1,30]之间的数组
		System.out.println("处理前：" + Arrays.toString(arr));
		func(arr); // 调用处理方法
		System.out.println("处理后：" + Arrays.toString(arr));

	}
	
	/**
	 * 处理方法 奇数在左，偶数在右
	 * 
	 */
	public static void func(int[] arr) {
		int l_scan = 0; // 定义左指针，初始指向第一个元素
		int r_scan = arr.length - 1; // 定义右指针，初始指向最后一个元素
		while (l_scan < r_scan) {
			while (l_scan < r_scan && arr[l_scan] % 2 == 1) {
				l_scan++; // 当左指针所指元素为奇数时，左指针右移
			}
			while (l_scan < r_scan && arr[r_scan] % 2 == 0) {
				r_scan--; // 当右指针所指元素为偶数时，右指针左移
			}
			// 此时左指针第一次遇到偶数，右指针第一次遇到奇数
			swap(arr, l_scan, r_scan); // 交换两指针所指元素的位置
		}
	}
	
	/**
	 * 交换数组arr中两元素的位置---即arr[i]与arr[j]位置对调
	 * 
	 */
	public static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

测试结果：
题目1测试结果

题目2：查找第k小的元素

题目描述：
以尽量高的效率求出一个乱序数组中按数值顺序的第k个元素

思路分析：
① 利用快排的思路，进行区域划分，采用三点中值法找出主元，划分实现主元左侧所有元素小于等于主元，主元右侧所有元素大于主元(快排不熟悉的可以看这里)
② 分区后的主元所在数组中的位置，也就是其数值大小的排位，我们要找的第k小的元素，可以比较k与(主元索引+1)的大小，当k小于(主元索引+1)时说明我们要找的数在主元的左侧，否则在主元的右侧
③ 根据上述比较，可以采用二分的思路，递归地在主元的左侧或右侧查找

代码展示：

/**
 * 最快效率求出乱序数组中第k小的数
 * 
 * @author LRRacac
 *
 */
import java.util.Arrays;
public class SelectK {
	public static void main(String[] args) {
		/*
		 * 测试：找第k个元素
		 */
		int arr[] = MyArrays.getArr(10, 1, 30); // 获取一个长度为10，元素值介于[1,30]之间的数组
		System.out.println("数组：" + Arrays.toString(arr));
		int random = (int) (Math.random() * 10 + 1);
		System.out.println("数值为第" + random + "位的元素是:" + selectK(arr, 0, arr.length - 1, random));
	}

	/**
	 * 查找方法---在乱序数组中找到数值大小为第k小的元素
	 * 
	 * @param arr---待处理的数组
	 * @param l---左边界
	 * @param r---右边界
	 * @param k---待找的位置
	 * @return int---返回待找元素
	 */
	public static int selectK(int[] arr, int l, int r, int k) {
		int pivotIndex = portion(arr, l, r); // 获取主元的索引
		// 由于主元的左侧都是小于等于主元的数，主元的右侧都是大于主元的数，所以主元的(索引+1)即为主元数值大小在数组中的排位
		if (pivotIndex == k - 1) { 
			return arr[pivotIndex]; // 当主元数值大小在数组排第k位时，返回主元
		} else if (pivotIndex > k - 1) {
			return selectK(arr, l, pivotIndex - 1, k); // 当主元数值大小在数组中的排位大于k时，在主元的左侧继续找
		} else {
			return selectK(arr, pivotIndex + 1, r, k); // 当主元数值大小在数组中的排位小于k时，在主元的右侧继续找
		}
	}

	/**
	 * 分区方法---利用三点中值法获取主元 
	 * 类似快速排序的处理
	 * 
	 * @param arr---待处理的数组
	 * @param l---左边界
	 * @param r---右边界
	 * @return int---返回主元的位置
	 */
	public static int portion(int[] arr, int l, int r) {
		// 三点中值法获取主元(见下)
		int midIndex = (l + r) >> 1; // 获取中间位置的索引
		int midValueIndex = -1; // 定义中值的索引，并初始化为-1
		if (arr[l] >= arr[midIndex] && arr[l] <= arr[r] || arr[l] <= arr[midIndex] && arr[l] >= arr[r]) {
			midValueIndex = l; // 当arr[l]介于arr[midIndex]与arr[r]之间时取arr[l]为中值
		} else if (arr[midIndex] >= arr[l] && arr[midIndex] <= arr[r]
				|| arr[midIndex] <= arr[l] && arr[midIndex] >= arr[r]) {
			midValueIndex = midIndex; // 当arr[midIndex]介于arr[l]与arr[r]之间时取arr[midIndex]为中值
		} else {
			midValueIndex = r; // 当arr[r]介于arr[midIndex]与arr[r]之间时取arr[r]为中值
		}
		MyArrays.swap(arr, l, midValueIndex);// 将选定的中值元素与左边界元素交换位置
		int pivot = arr[l]; // 设置主元为三点的中值
		// 三点中值法获取主元(见上)

		int l_scan = l + 1; // 定义左指针，初始指向第二个元素
		int r_scan = r; // 定义右指针，初始指向最后一个元素
		while (l_scan <= r_scan) {
			while (l_scan <= r_scan && arr[l_scan] <= pivot) {
				l_scan++; // 当左指针所指元素小于等于主元时，左指针右移
			}
			while (l_scan <= r_scan && arr[r_scan] > pivot) {
				r_scan--; // 当右指针所指元素大于主元时，右指针左移
			}
			// 至此，左指针指向大于主元的元素；右指针指向小于等于主元的元素
			if (l_scan <= r_scan)
				MyArrays.swap(arr, l_scan, r_scan); // 将左右两指针所指元素交换位置
		}
		MyArrays.swap(arr, l, r_scan);
		return r_scan; // 返回主元的索引位置
	}
}

测试结果：
题目2测试结果

题目3：寻找发帖"水王"

题目描述：
Tango是微软亚洲研究院的一个试验项目。研究院的员工和实习生们都很喜欢在Tango上面交流灌水。传说，Tango有一大“水王”，他不但喜欢发贴，还会回复其他ID发的每个帖子。坊间风闻该“水王”发帖数目超过了帖子总数的一半。如果你有一个当前论坛上所有帖子（包括回帖）的列表，其中帖子作者的ID也在表中，你能快速找出这个传说中的Tango水王吗？

思路分析：

  • 题目简言之：数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
  • 方法1：
    若数组长度为N，先排序，后直接返回arr[N/2]（易得，当一个数超过数组一半，假设取极端情况：该数出现次数刚好是数组长度一半再多一个，那么分三种情况
    ① 假设该数K是数组中最小的数，那么排序后，该数占据数组前半部分再多一个。若N为偶数，那么该数K的个数为N/2+1，索引N/2就是数组的中间位置的右边那一位，即指向第N/2+1个数K(该位置左边全为这个数，右边就是别的数了)，则arr[N/2]是该数。若N为奇数，那么该数K的个数为(int)(N/2+1)个，此时索引N/2指向也是指向的第(int)(N/2+1)个数K
    ② 同理，假设该数K是数组中最大的数，也可以证明排序后arr[N/2]就是这个数
    ③ 当数K的值介于数组最大与最小值之间时，更容易得到(int)(N/2+1)个
  • 方法2：
    根据方法1，我们知道了按数值排序后索引为N/2的数就是该数K，那么可以直接使用题目2中的selectK方法，来直接查找数值为第(N/2+1)位的元素(这里要注意一下：有序数组索引为i，其数值排第i+1位，因为索引从0开始，排位从1开始)
  • 方法3：
    方法1、2有一定的局限，即在查找的过程中会改变原数组的元素排列顺序，若题目限制不可动用原数组，则可以使用消除法，即将数组从左到右两两不同的数消除，最后剩下的一定是出现多余数组一半的那个数
    ① 假定首元素为候选数candidate，定义一个count变量来记录"假定的候选数candidate"经过两两消除后的剩余次数，count初始化为1
    ② 从第二个元素开始遍历所有元素，与假定的候选数candidate比较，若相同则count+1，若不同则count-1，当count减为0后，假定下一个待遍历的元素为candidate，依次处理下去，直到扫描完所有数，可以推知，最终count最小为1(每个数K都与别的数进行了一次两两消除，最后剩下一个数K)，count最大即为数K的个数(前面都是别的数，分别两两消除完毕，后面全是数K)
    ③ 最后的候补数candidate即为数K

变种题目：
当数组中出现次数最多的数K占数组长度的一半时，该怎么处理？
① 此时上述均不适用
② 可以改进消除法，我们知道如果数K占数组长度的一半，那么该数组一定是偶数个元素。那么如果继续使用方法3中的消除法，则有可能最后count消减为0(取最极端的情况，两个数K中夹杂着一个别的数)，那么count为0的情况我们要特殊讨论
③ 针对count为0的情况，我们只需比较candidate和最后一个元素是不是数K，可以增加一个countlast变量来统计最后一个元素出现的次数，当最后一个元素出现次数刚好为数组的一半时则最后一个数为数K，否则为candidate

代码展示：

/**
 * 寻找发帖水王：寻找数组中次数出现超过半数的元素 
 * 解法1：排序后返回arr[N/2] 
 * 解法2：分区法直接查找中间位置的元素
 * 		解法1、2需要改动数组的内容 
 * 解法3：消除法(不需改动数组的内容)
 * 变种题目：改进版消除法
 * 
 * @author LRRacac
 *
 */
import java.util.Arrays;
public class MoreThanHalf {
	public static void main(String[] args) {
		int[] arr = { 6,4,6,2,7,1,6,6,6,8,6};
		System.out.println(Arrays.toString(arr));//打印这个数组
		// 测试方法1：先排序，后返回中间的元素
		System.out.println("解法1：超过半数的值为" + sortHalf(arr));
		// 测试方法2：利用分区法，找到中间位置的元素(利用上一个上一题的SelectK)
		System.out.println("解法2：超过半数的值为" + selectHalf(arr));
		// 测试方法3：消除法
		System.out.println("解法3：超过半数的值为" + remove(arr));
		// 测试变种题(水王个数占半)：改进消除法
		int[] arr1 = {2, 10, 4, 10, 1, 10, 3, 10, 10, 5};
		System.out.println(Arrays.toString(arr1));//打印这个数组
		System.out.println("变种题：占数组一半的值为" + getHalf(arr1));
	}

	/**
	 * 方法1：先排序，后返回中间位置的元素 时间复杂度：O(nlogn)
	 * 
	 * @param arr
	 * @return
	 */
	public static int sortHalf(int[] arr) {
		Arrays.sort(arr);
		return arr[arr.length / 2];
	}

	/**
	 * 方法2：直接查找中间位置的元素 较方法1更优，因为我们不关心其他元素的顺序，方法一给每个元素排序的操作是没必要的 时间复杂度：O(n)
	 * 
	 * @param arr
	 * @return
	 */
	public static int selectHalf(int[] arr) {
		int result = SelectK.selectK(arr, 0, arr.length - 1, (arr.length / 2)+1);
		return result;
	}

	/**
	 * 方法3：消除法
	 * 将数组从左到右两两不同的数消除，最后剩下的一定是出现多余数组一半的那个数
	 * @param arr
	 * @return
	 */
	public static int remove(int[] arr) {
		int candidate = arr[0];//定义候选数
		int count = 1;//记录两两消除后的剩余次数
		for (int i = 1; i < arr.length; i++) {
			if(count==0) {
				candidate = arr[i];//若两两消减为零，应该把当前的元素作为新的候选值
				count = 1;
				continue;
			}
			if(arr[i]==candidate) 
				count++;//遇到和候选值相同的，次数+1
			else 
				count--; //不同的数，进行消减
		}
		return candidate;
	}
	
	/**
	 * 寻找发帖水王变题：当出现最多次的数占数组的一半，怎么找出该数
	 * 方法1、2已不适用，改进消除法
	 * @param arr
	 * @return
	 */
	public static int getHalf(int[] arr) {
		int candidate = arr[0];//定义候选数
		int count = 1;//记录两两消除后的次数
		int countlast = 0;//记录最后一个元素出现的次数
		for (int i = 1; i < arr.length; i++) {
			if(arr[i]==arr[arr.length-1]) {
				countlast++; //记录最后一个数出现次数
			}
			if(count==0) {
				candidate = arr[i];//若两两消减为零，应该把当前的元素作为新的候选值
				count = 1;
				continue;
			}
			if(arr[i]==candidate) 
				count++; //遇到和候选值相同的，次数+1
			else 
				count--; //不同的数，进行消减
		}
		if(countlast==arr.length/2) {
			return arr[arr.length-1]; //若最后一个数出现的次数为数组的一半，则它为水王
		}else {
			return candidate;//否则水王为候补者
		}
	}

测试结果：
题目3测试结果

题目4：最小可用ID

题目描述：
在非负数组(乱序)中找到最小的可分配的ID(从1开始编号)，数据量为1000000

思路分析：

  • 方法1：
    ① 先对数组进行排序，如果没有空缺，那么数组元素应该是1-n紧密排列，其索引为0-(n-1)，也就是元素值为k，其索引应该为k-1
    ② 遍历数组，判断其索引i+1是否等于其元素值，当找到第一个索引i，当索引i+1不等于对应元素值时，说明值为i+1的这个元素空缺，则返回i+1为待找的最小可用ID
    ③ 若数组中元素排列紧密，即扫描一遍之后均没有空缺，则直接返回arr.length+1
  • 方法2：
    ① 假设数组长度为N，易得，若这N个数排列紧密，则为1~N，则最小可用ID为N+1；若这N个数排列不紧密，则最小可用ID一定小于等于N。
    ② 开辟一个辅助数组helper用来标记原数组中出现的元素，遍历原数组arr中的元素，将原数组中元素值(arr[i]-1)作为helper数组的索引 ，并把该值赋为1：helper[arr[i]-1]=1。使得helper数组中元素值为1的元素对应的(索引+1)就是原数组中出现的元素，helper数组中元素值为0的元素对应的(索引+1)就是元素组中未出现的元素。
    ③ 此时注意，helper长度设为与原数组长度相等时，在执行上述操作时可能会越界，假设数组为{1,2,3,4,60}，则在扫描到arr最后一个元素时，helper[60-1]直接越界。根据①的分析，在数组不紧密的情况下，我们知道最小ID一定小于数组长度N。所以不妨在给helper数组赋值的时候，直接过滤掉arr[i]>N的元素值。
    ④ 最后只需遍历helper数组，找到第一个元素值为0的元素，返回其下标+1
  • 方法3：最高效
    若题目要求不能开辟辅助空间，并且尽可能高效实现。则可以基于方法1来改进，我们已经知道如果一个数组排列紧密，那么一个元素的元素值应该为其下标+1，那么可以利用题目2的selectK方法来直接找到中间元素的元素值是否为其下标+1：如果是，则说明该元素左侧排列紧密，则去中间元素右侧找；否则应该在中间元素左侧找

代码展示：

/**
 * 找出最小可用ID
 * 
 * @author LRRacac
 *
 */
import java.util.Arrays;
public class MinFreeID {
	public static void main(String[] args) {
		int[] arr = {3,14,12,1,5,2,7,9,4,10};
		System.out.println(Arrays.toString(arr));//打印数组
		System.out.println("solve1——最小可用ID为：" + solve1(arr));//测试方法1
		System.out.println("solve2——最小可用ID为：" + solve2(arr));//测试方法2
		System.out.println("solve3——最小可用ID为：" + solve3(arr, 0, arr.length - 1));//测试方法3
	}

	/**
	 * 方法1：先排序，如果没有空缺那么数组元素就是1~n排列(其下标为0~n-1)
	 * 即找到第一个不在其位的元素，如果扫描到下标为i的元素，其元素值不等于i+1，则i+1即为最小可以ID
	 * 
	 * @param arr
	 * @return
	 */
	public static int solve1(int[] arr) {
		Arrays.sort(arr);// 对数组进行排序
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] != i + 1) {
				return i + 1;// 逐个扫描数组中的元素，找到第一个不在其位的元素
			}
		}
		return arr.length + 1;// 如果数组中的元素没有空缺，即1-n紧密排列，则返回n+1
	}

	/**
	 * 方法2：开辟一个辅助数组用来标记原数组元素值的出现
	 * 
	 * @param arr
	 * @return
	 */
	public static int solve2(int[] arr) {
		int[] helper = new int[arr.length];// 定义一个辅助数组，长度与arr相等，用于标记arr中的某元素是否存在
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] <= arr.length) {// 由于数组应该是紧密排列的，所以只需对arr元素值中小于等于数组长度的元素进行标记
				helper[arr[i] - 1] = 1;// 逐个扫描arr中的元素，若arr[i]=k，则将helper数组中的索引为k-1处元素值改为1
			}
		} // 至此，已将arr中所有存在的元素，对应在helper数组中标记为1
		for (int i = 0; i < helper.length; i++) {
			if (helper[i] == 0) {
				return i + 1;// 逐个扫描helper数组中的元素，当遇到第一个值为0的元素时返回i+1，即为对应最小可用ID
			}
		}
		return arr.length + 1;// 如果数组中的元素没有空缺，即1-n紧密排列，则返回n+1
	}
	
	/**
	 * 方法3：利用selectK函数直接获取某元素的实际元素值排位，判断是否在其位，类似二分操作
	 * @param arr
	 * @param l
	 * @param r
	 * @return
	 */
	public static int solve3(int[] arr, int l, int r) {
		if (l > r) {
			return l + 1;// 当左指大于右指针时，返回该指针索引+1
		}
		int midIndex = (l + r) / 2; // 取中间索引
		int mid = SelectK.selectK(arr, l, r, midIndex + 1); // 实际在中间位置的值
		if (midIndex + 1 == mid) {
			// 当中间索引值+1等于中间值的元素值时，说明中间值左侧索引0~midIndex之间的元素值(1~midIndex+1)都是排列紧密的
			return solve3(arr, midIndex + 1, r); // 因此应该往中间值右侧找
		} else {
			// 当中间索引值+1大于中间值的元素值时，说明中间值左侧索引0~midIndex之间的元素值并不紧密，则应该往中间值左侧找
			return solve3(arr, l, midIndex - 1);
		}
	}
}

测试结果：
题目4测试结果
骚话时刻：
不知不觉在家已经待了50多天，也不知道是肉长得快一点还是知识hh
今天正儿八经简单总结一下
题目1：奇数在左偶数在右。这道题就是利用了左右两个扫描指针同时比较，交换位置–>与快排的双向扫描分区法类似

题目2：查找第k小的数。大家都能想到的是直接调用Arrays.sort来排序后找索引就得了，但是这并不是最高效的方法，因为我们只是要查找数值位在第k位的数，并不需要把其他数也排好顺。根据快排分区的方法我们知道分区后主元的左侧元素都小于等于主元，而主元的右侧元素都大于主元，因此主元的位置其实也就是其数值在数组中的排位（即主元是数组中第(下标+1)小的数），因此只需要比较(主元下标+1)与k的大小：当(主元下标+1)=k则说明主元就是第k小的数；当(主元下标+1)>k则说明我们要找的第k小的数在主元左侧；否则在右侧。这题的分区方法与快排一致，最后可以递归实现在主元左侧/右侧查找。

题目3、4：寻找发帖水王、查找最小可用ID。题目3的方法2以及题目4的方法3都是利用了题目2的查找第k小的数，即间接运用快排的分区方法。

很容易发现，与此类似的很多查找、排序的题目都可以运用快排的一些思路与方法来高效实现。掌握一种算法，并不是掌握算法本身而已，而是掌握一种思想，这样才能灵活运用。
快排图解
发现自己真是有点啰嗦hh
这让我想起班主任，永远的"我只说三点"，嗯没错，三点钟过去了
在这里插入图片描述

RUI_NOBUG
关注
专栏目录
【分治法】第k个数（快速选择算法，结合快速排序）
怪&的个人博客
10-02 855
给定一个长度为 n 的整数数列，以及一个整数 k，请用快速选择算法求出数列从小到大排序后的第 k 个数。 输入格式 第一行包含两个整数 n 和 k。 第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整数数列。 输出格式 输出一个整数，表示数列的第 k 小数。 数据范围 1≤n≤100000, 1≤k≤n 输入样例: 5 3 2 4 1 5 3 输出样例： 3
分治法求第k个数
wangzhen12138的博客
06-23 490
#include int exchange(int *a, int i, int j){ int temp = a[i]; a[i] = a[j]; a[j] = temp; } int partition(int *a, int p, int r){ int x = a[r]; int i = p-1, j; for(j = p; j < r; j++){ if(a[j] < x){ i++; ...
基于快速排序思想的三个算法题
tuke_tuke的博客
05-22 5079
一，最小的k个数 输入n个数，找出其中最小的k个数，例如输入4,5,1,6,2,7,3,8,个数字，则最小的数字是1,2,3,4 基于O(n)的算法，可以用基于Partion函数解决这个问题，如果基于数组的第k个数字来调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数组大的所有数字都位于数组的右边，这样调整之后数组左边的k个数字就是最小的k个数字，不一定有序 import jav
使用快排思想解决算法面试题
sym的博客
03-17 314
快速排序 主要思想 1. 在数组中选一个元素作为基准（通常选用数组第一个元素作为基准）； 2. 将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边； 3. 对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只有一个元素，即为全部有序。 代码实现 func quickSort(arr []int, begin, end int) { if begin > end { return } base := arr[begin] // 选择基准，一般选择数组首元
快排中的思路（快速排序）-912题目
java_bing的专栏
05-12 110
3: 因为我们默认选取的排序的数据是target=left, 从left开始的，（也就是说 第一个洞其实是left）, 所以我们需要从右边开始遍历找到数据填补left的， 所以第一个while 循环是从右边开始的。５：因为逻辑是右边的填充左边的洞，左边的填充右边的洞，　看起来是　偶数个，但是万一只有奇数个，因为推出循环的时候ｌｅｆｔ＝ｒｉｇｈｔ，　所以ｔａｒｇｅｔ　直接放在ｌｅｆｔ　或者ｒｉｇｈｔ　位置都是可以的。这个其实是 “赋值的思想”， 赋值后，一方就是空的了，下一次就是给这个空的赋值了。
ConsoleApplication19_K._分治策略选中第k小的数_源码
10-04
如果k是偶数，那么这两个子问题就是找到第k/2-1和k/2小的元素；如果是奇数，则为(k-1)/2和k/2。 3. **合并**：比较这两个子问题的解，如果其中一个解的索引小于k，那么第k小的元素就在另一个子数组中；否则，第k小...
分治算法 芯片测试.py
04-14
芯片测试：蛮力测试和分治策略都有写到，算法按设计与分析课的笔记，博主自己写的，仅仅参考了讲义的伪代码，若有错误请指出，谢谢。 重要的假设:好芯片至少比坏芯片多一片。 测试结果：奇数个芯片√ 偶数个芯片...
2024快速幂、快速乘算法(1).zip
最新发布
04-14
这两种算法都基于分治思想，将复杂的问题分解为更简单的子问题来解决。 快速幂算法（Fast Powering Algorithm）： 快速幂算法主要用于计算一个数的幂，如 a^n。其基本思路是通过不断地将 n 除以 2 来减少运算次数。...
快速幂、快速乘算法(1).zip
03-28
快速幂和快速乘是两种高效的计算大整数乘法或幂次的方法，广泛应用于计算机科学，特别是在算法竞赛、密码学和大数据处理等领域。这两种方法基于分治策略，通过将复杂问题分解为更小的子问题来减少计算量，显著提高了...
分治算法经典例子.docx
11-02
分治算法是一种重要的计算机科学算法，其核心思想是将一个复杂的问题分解成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这种策略在解决许多计算问题时能够...
面试机考算法题
frodocheng的博客
03-28 257
已知有N框苹果，每框有N(i)个苹果（i为每个框的索引号码）。假设你每小时吃K个苹果，并且，一个小时内你只能吃同一框苹果，假设K > N(i), 那么，这个小时内，该框苹果会被吃完，并且，你也不会去吃下一筐。 现在在H个小时以内，要求你吃完所有的苹果，求吃苹果的最小速度K。 注意, N > 0, N(i) > 0, K > 0, H > 0. 如果吃不完，那么请返...
n个元素，取奇数个/取偶数个的方案数
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
08-28 983
问题描述： 给定n，问选出奇数个元素的方案数是多少，选出偶数个呢？ 答： 设S1为从n个元素选出偶数个元素的方案数 设S2为从n个元素选出奇数个元素的方案数 那么：S1=S2=2n-1 证明： S1=C(n,0)+C(n,2)+…+C(n,p)，其中p是小于n的最大偶数 S2=C(n,1)+C(n,3)+…+C(n,q)，其中q是小于n的最大奇数 (1+1)n=C(n,0)+C(n,1)+C(n,2)…+C(n,n)=S1+S2=2n (1+(-1))n=C(n,0)-C(n,1)+C(n,2)-…+C(n
拜托，面试别再问我TopK了！！！
weixin_33912638的博客
09-21 235
前言：本文将介绍随机选择，分治法，减治法的思想，以及TopK问题优化的来龙去脉，原理与细节，保证有收获。 面试中，TopK，是问得比较多的几个问题之一，到底有几种方法，这些方案里蕴含的优化思路究竟是怎么样的，今天和大家聊一聊。 画外音：除非校招，我在面试过程中从不问TopK这个问题，默认大家都知道。 问题描述： 从arr[1, n]这n个数中，找出最...
查找数组arr中第k大/小的奇数,如果不存在则返回0
jerrykenny2004的专栏
02-05 3101
public class NumUtil { /** * 启动方法 * @param args args[0]是第k个数 */ public static void main(String[] args) { int[] arr = {88, 0, 1, 3,5,7, 9, 2,4, 8, 10}; int k=0;...
算法之寻找发帖"水王"
张波的技术积累
05-02 7683
寻找发帖水王就是找出发的贴中，贴子总数占帖子一半以上的那个id     package com.test.algorithm; /** * 如果每次删除两个不同的ID，那么剩下的ID列表中，“水王”ID出现的次数仍然超过总数的一半。看到 * 这一点后，就可以通过不断重复这个过程，把ID列表中的ID总数降低(转化为更小的问题)，从而得到 * 问题的答案 * @author ccna_z
08分治应用——选择第 k 小元素问题的BFPRT算法
哈哈哈
04-06 1080
08基于特定分治策略的选择第 k 大元素问题 目录08基于特定分治策略的选择第 k 大元素问题1.问题2.解析3.设计4.分析5.源码 1.问题 我们将如何从一给定的无序数组中选择特定序位的元素定义为选择问题。 常见的选择问题有：选最大、选最小、选中位数、选第二大…… 若使用符号可以统一描述为： 设 L 是 n 个元素的集合，从 L 中选取第 k 小的元素，其中 0 <= k < n....
第七章习题
py_xiaobai的博客
04-29 3598
1、实现自己的数学模块mymath，提供有4个函数，分别为加减乘除， 在B模块中调用A模块的函数。 mymath.py的内容： #encoding=utf-8 def add(*args): result = 0 for i in args: result += i return result def sub(a,b,*args): return ...
算法笔试题：（Python实现）------ 算法面试题汇总
热门推荐
Avery123123的博客
03-06 1万+
算法笔试题：（Python实现）------ 算法面试题汇总算法笔试题：（Python实现）------ 算法面试题汇总开始之前Python实现只出现一次的数字多数元素搜索二维矩阵 II合并两个有序数组鸡蛋掉落 算法笔试题：（Python实现）------ 算法面试题汇总 开始之前 Python实现 只出现一次的数字 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于...
【算法设计与分析】分治法与中位数问题
拾年之璐
10-15 8677
说明：这是武汉理工大学计算机学院【算法设计与分析】课程的第一次实验第一题：分治法与中位数问题 >>点击查看WUTer计算机专业实验汇总 谨记：纸上得来终觉浅，绝知此事要躬行。 一、问题描述 输入任意一串数字，输出这个数字串的中位数（如果数字个数为偶数，则输出中间lian两个数的平均值）。 二、实验代码 完整VS 2017项目：https://github.com/cx...
python实现循环赛日程表问题的算法_循环赛日程表的分治算法实现实验报告gxl.doc...
06-02
循环赛日程表问题是指在 n 个队伍之间进行循环赛，每个队伍必须与其他队伍比赛一次，求出比赛的日程表。这个问题可以使用分治算法进行求解。 分治算法的思路是将问题分解为若干个子问题，然后递归地解决每个子问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值