high

思路 如下图所示，对于数组s={11，18，20，11，6，8}，选择11作为关键字key，然后选择两个哨兵low和high分别从数组的首部和尾部出发，执行以下操作： 循环判断尾部哨兵所在元素是否大于key，且low<high，若是则哨兵high–，循环继续；否则循环停止，执行s[low]=s[high]，然后转到2。 循环判断首部哨兵所在元素是否小于或等于key，且low<high，若是则哨兵low++，循环继续；否则循环停止，执行s[high]=s[low]，然后转到3。 若low>=high，循环停止，否则转到1。 C++实现 int partion ( vector < int > & s , int low , int high ) { int key = s [ low ] ; while ( low < high ) { while ( low < high && s [ high ] > key ) high -- ; s [ low ] = s [ high ] ; while ( low < high && s [ low ] <= key ) low ++ ; s [ high ] = s [ low ] ; } s [ low ] = key ; return low ; } void quickSort ( vector < int > & s , int

const int maxn=100; int heap[maxn]; //堆 int n=10; //元素个数 1、向下调整 对heap数组在【low,high】范围进行向下调整 其中low为欲调整结点的数组下标，high一般为堆的最后一个元素的数组下标 //对heap数组在【low,high】范围进行向下调整 //其中low为欲调整结点的数组下标，high一般为堆的最后一个元素的数组下标 void downAdjust(int low,int high) { int i=low; int j=i*2; //i为欲调整结点，j为其左孩子 while(j<=high) { //如果右孩子存在，且右孩子的值大于左孩子 if(j+1<=high&&heap[j+1]>heap[j]) { j=j+1; } if(heap[j]>heap[i]) { swap(heap[j],heap[i]); i=j; j=i*2; } else { break; } } } 2、建堆 void createHeap() { for(int i=n/2;i>=1;i--) { downAdjust(i,n); } } 3、删除堆顶元素 void deleteTop() { //heap[1]=heap[n--]; heap[1]=heap[n]; n--; downAdjust(1,n); } 4

样式操作 <p class=”myclass” title=”选择喜欢的水果”>你最喜欢的水果是?</p> 在上面代码中， class 也是 p 元素的属性，因此获取 class 和设置 class 都可以用 attr() 方法来完成 代码如下： var p_class=$("p").attr("class"); //获取p元素的class 也可以用 attr() 方法来设置 class $("p").attr("class","high"); //将p元素的class设置为high 在大多数情况下，它是将原来的 class 替换成新的 class ，而不是在原来基础上追加新的 class 新的代码为 <p class="high" title="选择喜欢的水果">你最喜欢的水果是?</p> 追加样式 <style> .another { Font-style: italic; /* 斜体 */ Color: blue;/* 字体设为蓝色 */ } </style> 在网页中追加一个样式 $("input:eq(2)").click(function(){ $("p").addclass("another"); }) 方法 addClass() attr() 对同一个网页操作 <p>test</p> 第一次使用方法 $("p").addClass("high"); $("p")

一、思想 分治。选一个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)，平均性能更接近最好情况。 假设输入数据的所有排列不是等概率的

1 2 3 public static void Sort( int [] array, int low, int high) 4 { 5 // check arguments 6 int pivotpos = 0 ; 7 if (low < high) 8 { 9 pivotpos = Partition(array,low,high); 10 Sort(array,low,pivotpos); 11 Sort(array,pivotpos + 1 ,high); 12 } 13 14 } 15 private static int Partition( int [] array, int low, int high) 16 { 17 int tmp = array[low]; 18 if (low < high){ 19 // here must be '>=',not only '>' 20 while (low < high && array[high] >= tmp) { 21 high -- ; 22 } 23 Swap( ref array[low], ref array[high]); 24 // here must be '<=',not only '<' 25 while (low < high && array[low] <= tmp) { 26 low ++

题目描述 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 python方法1(遍历,复杂度O(n),直接用min或者sort函数就没意思了): # -*- coding:utf-8 -*- class Solution : # 非递减序列是后一个>=前一个 def minNumberInRotateArray ( self , rotateArray ) : if len ( rotateArray ) == 0 : return 0 for i in range ( len ( rotateArray ) - 1 ) : if rotateArray [ i ] > rotateArray [ i + 1 ] : return rotateArray [ i + 1 ] # rotateArray中只有一个元素值（包括只有一个数以及所有数相等两种情况） return rotateArray [ 0 ] python方法2(二叉查找,复杂度O(logn)): 分析：二分查找变种，没有具体的值用来比较。那么用中间值和高低位进行比较，看处于递增还是递减序列

给一个无序表，使用快速排序算法对它进行排序。 函数接口定义： int Partition(SqList &L,int low,int high); void QuickSort(SqList &L, int low, int high); 其中L是待排序表，low和high是排序的区间。 裁判测试程序样例： # include <iostream> using namespace std ; # define MAXSIZE 50 typedef int KeyType ; typedef struct { KeyType key ; } ElemType ; typedef struct { ElemType r [ MAXSIZE + 1 ] ; int length ; } SqList ; void Create ( SqList & L ) { int i ; cin >> L . length ; for ( i = 1 ; i <= L . length ; i ++ ) cin >> L . r [ i ] . key ; } void Output ( SqList L ) { int i ; for ( i = 1 ; i <= L . length ; i ++ ) cout << L . r [ i ] . key << " " ; cout << endl

2014年去某公司笔试的时候遇到这么一道题： public class Test { public static void main(String[] args) { Integer int1 = Integer.valueOf("100"); Integer int2 = Integer.valueOf("100"); System.out.println(int1 == int2); } } 问打印的结果的多少？ 但是我回答的是false, 后来仔细想想应该没有这个简单，就翻了下JDK的源码，发现： public static Integer valueOf(String s) throws NumberFormatException { return Integer.valueOf(parseInt(s, 10)); } public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } 发现里面另有玄机，多了个IntegerCache类： private static class IntegerCache {

void MergeSort(int low, int high) { int mid = (low + high) / 2; if (high - low < 1) { return; } MergeSort(low, mid); MergeSort(mid + 1, high); Merge(low, mid, high); } void Merge(int low, int mid, int high) { int* A = g_szArray + low; int llen = mid - low + 1; int* B = new int[llen]; for (int i = 0; i < llen; i++) { B[i] = g_szArray[low + i]; } int hlen = high - mid; int* C = g_szArray + mid + 1; for (int i = 0, j = 0, k = 0; (j < llen) || (k < hlen);) { if ((j < llen) && (!(k < hlen) || (B[j] <= C[k]))) { A[i++] = B[j++]; } if ((k < hlen) && (!(j < llen) || (C[k] < B[j]))) { A[i++] = C[k++];

递归 ：思路简单但效率低（建立函数的副本，消耗大量时间和内存）。能用迭代就不用递归。 递推公式+递推终止条件 Fibonacci数列 # 递归 class Solution: def fib(self, N: int) -> int: if N <= 1: return N return self.fib(N-1) + self.fib(N-2) # 迭代 class Solution: def fib(self, N: int) -> int: if N <= 1: return N tmp1 = 0 tmp2 = 1 for i in range(2, N+1): res = tmp1 + tmp2 tmp1 = tmp2 tmp2 = res return res 函数调用自身，注意递归的停止条件。分为调用和回溯两个阶段。 任意长度的字符串反向，递归实现 # 需要额外存储空间 def reverseStr(string): if string == None or len(string) == 0: return None if len(string) == 1: return string return reverseStr(string[1:])+string[0] #leetcode，O(1)额外空间，原地修改。双指针 class Solution: def