high

一、思想 分治。选一个pivot，将比pivot小的元素放在左边，比pivot大的元素放在右边，对左右两个子数组递归调用QuickSort。 二、实现 int partition(int* A, int low, int high) { int pivot = A[low]; while (low < high) { while (low < high && A[high] >= pivot) { high--; } A[low] = A[high]; while (low < high && A[low] <= pivot) { low++; } A[high] = A[low]; } A[low] = pivot; return low; } void QuickSort(int* A, int low,int high) { if (low < high) { int pivotPos = partition(A, low, high); QuickSort(A, low, pivotPos - 1); QuickSort(A, pivotPos + 1, high); } } 三、性能 划分的两个子问题规模分别为0和n时，时间复杂度最坏为O(n^2)； 两个子问题规模相同时，时间复杂度最好为O(nlgn)，平均性能更接近最好情况。 假设输入数据的所有排列不是等概率的

折半查找 基本过程：在 有序 表中取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上述过程，直到查找成功，或所有查找区域无记录，查找失败为止。 //arr为待查找的数组，key为要查找的关键字，low和high为需要查找的数组下标的范围 public static int find1(int[] arr, int key, int low, int high) { if (arr != null && arr.Length > 0) { if ((low >= 0 && low <= arr.Length - 1) && (high >= low && high <= arr.Length - 1)) { int mid; while (low <= high) { mid = (low + high) / 2; if (key < arr[mid]) { high = mid - 1; } else if (key > arr[mid]) { low = mid + 1; } else { return mid; } } } } return -1; } 插值查找 基本思想：如果一个有序的序列是均匀分布的

更多大数据分析、建模等内容请关注公众号《bigdatamodeling》 在实现算法时经常会用到随机数，有时会忘记各种随机数的生成方法，这里对Python中的随机数生成方法进行汇总，以供以后查阅。 import numpy as np # 两者实现的作用是一样的，都是使每次随机生成数一样 np.random.seed(10) np.random.RandomState(10) ### 正态分布 np.random.normal(loc=0.0, scale=1.0, size=None) np.random.normal() # 返回标量 ~N(0,1) np.random.normal(1) # 返回标量 ~N(0,1) np.random.normal(size=(2, 2)) # 返回N(0,1) np.random.normal(0, 1, size=(2, 2)) # 同上 np.random.normal(2, 10, size=(2, 2)) ### 标准正态分布N(0,1) np.random.randn() # 生成标量 np.random.randn(1) np.random.randn(2) np.random.randn(2, 2) 5 * np.random.randn(2, 2) + 10 ### 从均匀分布（[low, high)：半开区间）中进行采样

二分查找又称折半查找，查找效率不错 适用场景：顺序存储结构且按有序排列，这也是它的缺点。 demo如下： package 数据结构算法.查找; public class binarySearch { public static void main(String[] args) { int[] array ={1,2,3,4,6,7,8,9,10}; System.out.println( binSearch_2(3,array,0,array.length-1)); System.out.println( binSearch_2(5,array,0,array.length-1)); } /* *循环实现二分算法 */ public static int binSearch_1(int key, int[] array) { int low = 0; //第一个下标 int high = array.length - 1;//最后一个下标 int middle = 0; //防越界 if (key < array[low] || key > array[high] || low > high) { return -1; } while (low <= high) { middle = (low + high) / 2; if (middle == key) { return

#include <iostream> #include <cassert> #include <stack> #include <math.h> using namespace std; int QuickSortOnce(int a[], int low, int high) { // 将首元素作为枢轴。 int pivot = a[low]; int i = low, j = high; while (i < j) { // 从右到左，寻找首个小于pivot的元素。 while (a[j] >= pivot && i < j) { j--; } // 执行到此，j已指向从右端起首个小于或等于pivot的元素。 // 执行替换。 a[i] = a[j]; // 从左到右，寻找首个大于pivot的元素。 while (a[i] <= pivot && i < j) { i++; } // 执行到此，i已指向从左端起首个大于或等于pivot的元素。 // 执行替换。 a[j] = a[i]; } // 退出while循环，执行至此，必定是i=j的情况。 // i（或j）指向的即是枢轴的位置，定位该趟排序的枢轴并将该位置返回。 a[i] = pivot; return i; } void QuickSort(int a[], int low, int high) { if (low

1:采用二分法解答这个问题， mid = low + (high - low)/2 需要考虑三种情况： 1.array[low]>array[high] : 用两个指针来操作： 相当于二分法 低位指针在第一个递增序列内；高位指针在第二个递增序列内； (1)array[low]<array[mid] : 出现这种情况的array类似[3,4,5,6,0,1,2]，此时最小数字一定在mid的右边。 low = mid + 1 (2)array[low]>array[mid] : 出现这种情况的array类似[5,1,2,3,4],此时最小数字一定就是array[mid]或者在mid的左 边。因为右边必然都是递增的。 high = mid (3)循环的终止条件为： high-low==1; 因为到了两个指针相邻的地方，那么其实high 所对应的值即是最小值 2.array[low]<array[high] : //其实就是相当于将 一个本来的递增数列 后面0 个值旋转到前面去； 还是递增数列；第一个值为最小值 3 .array[low]==array[mid] == array[low]: //注意题目 这是个非递减 没说一定递增 出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]，此时最小数字不好判断在mid左边还是右边,这时只好一个一个试 ，

图示思想： int Partition(int* a, int low, int high) { int pivotkey = a[low]; while (low < high) { while (low < high && a[high] >= pivotkey) high--; a[low] = a[high]; while (low < high && a[low] <= pivotkey) low++; a[high] = a[low]; } a[low] = pivotkey; return low; } void QuickSort(int* a, int low, int high) { if (low < high) { int pivotloc = Partition(a, low, high); QuickSort(a, low, pivotloc-1); QuickSort(a, pivotloc+1, high); } } int main() { int arr[] = { 9,2,3,1,5,4,7,8,6 }; int n = sizeof(arr) / sizeof(int); int low = 0, high = n - 1; QuickSort(arr, low,high); for (int i = 0; i < n; i++) {

SPOJ HIGH Highways 无向图生成树计数裸题 #include <iostream> #include <algorithm> #include <string.h> using namespace std; const int maxn = 205; #define ll long long ll b[maxn][maxn]; // 学过线代都知道求行列式的方法之一就是化成上\下三脚矩阵,对角线元素乘积是行列式值 ll determina(int n) { ll res = 1; for (int i = 1; i <= n; i++) { if (!b[i][i]) { //若果对角线元素为0,把此行都一都移到下一行去 bool flag = false; for (int j = i + 1; j <= n; j++) { //从i+1行开始找i列中的第一个不为0的元素，与现在的行交换 if (b[j][i]) {//找到了该列不为0的元素, flag = 1; //标记,交换 for (int k = i; k <= n; k++) swap(b[i][k], b[j][k]); res = -res;// 换行系数变为负数 break; //退出. } } if (!flag) return 0; //这一行全部为0,行列式值为0 } for (int j

题目描述： 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 解题思路： 采用二分法解答这个问题， mid = low + (high - low)/2 需要考虑三种情况： (1)array[mid] > array[high]: 出现这种情况的array类似[3,4,5,6,0,1,2]，此时最小数字一定在mid的右边。 low = mid + 1 (2)array[mid] == array[high]: 出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]，此时最小数字不好判断在mid左边 还是右边,这时只好一个一个试 ， high = high - 1 (3)array[mid] < array[high]: 出现这种情况的array类似[2,2,3,4,5,6,6],此时最小数字一定就是array[mid]或者在mid的左 边。因为右边必然都是递增的。 high = mid 注意这里有个坑：如果待查询的范围最后只剩两个数，那么mid 一定会指向下标靠前的数字 比如 array = [4,6] array[low] = 4

题目描述： 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 解题思路： 采用二分法解答这个问题， mid = low + (high - low)/2 需要考虑三种情况： (1)array[mid] > array[high]: 出现这种情况的array类似[3,4,5,6,0,1,2]，此时最小数字一定在mid的右边。 low = mid + 1 (2)array[mid] == array[high]: 出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]，此时最小数字不好判断在mid左边 还是右边,这时只好一个一个试 ， high = high - 1 (3)array[mid] < array[high]: 出现这种情况的array类似[2,2,3,4,5,6,6],此时最小数字一定就是array[mid]或者在mid的左 边。因为右边必然都是递增的。 high = mid 注意这里有个坑：如果待查询的范围最后只剩两个数，那么mid 一定会指向下标靠前的数字 比如 array = [4,6] array[low] = 4