剑指offer之面试题：查找和排序

二分查找

基本思想：将有序序列等分为几乎相等的两部份，待查关键字和划分元比较。如果小于划分元，则递归处理左半部分；否则处理右半部分。

非递归算法：

BinarySearch1(L[],n,x){
left=1;
right=n;
flag=0;
while(left<=right&&flag==0){
mid=(left+right)/2;
if(x==L[mid]){
flag=1;
}
else if(x>L[mid]){
left=mid+1;
}
else{
right=mid-1;
}
}
if(flag==1)return mid;
else return -1;
}

递归实现

BinarySearch2(L[] ,x,i,j){
if(i>j)return -1;
if(i==j){
if(L[i]==x)return i;
else return -1;
}
else{
mid=(i+j)/2;
if(x==L[mid)return mid;
else if(x<L[mid])return BinarySearch2(L,x,i,mid-1);
else return BinarySearch2(L,x,mid+1,j);
}
}

java实现

/**
*
*/
package com.su.biancheng;

/**
* @title BinarySearch.java
* @author Shuai
* @date 2016-4-16上午11:34:58
*/
public class BinarySearch {
public static int BinarySearch(int[] array,int x){
/*if(array==null||array.length<=0)
return -1;*/
int left=0;
int right=array.length-1;
int flag=0;
int mid=0;
while(left<=right&&flag==0){
mid=(left+right)/2;
if(x==array[mid])
flag=1;
else if(x<array[mid])
right=mid-1;
else
left=mid+1;
}
if(flag==1)
return mid;
return -1;
}
public static int BinarySearch2(int[] array,int x,int left,int right){
if(left>right)
return -1;
if(left==right){
if(x==array[left])
return left;
else
return -1;
}
else{
int mid=(left+right)/2;
if(x==array[mid])
return mid;
else if(x<array[mid])
return BinarySearch2(array,x,left,mid-1);
else
return BinarySearch2(array,x,mid+1,right);
}
}
public static void main(String[] args){
int[] array={1,2,3,3,5,5,7,8,9};
int x=5;
System.out.println(BinarySearch(array,x));
System.out.println(BinarySearch2(array,x,0,array.length-1));
}
}

排序

快排序

期望时间为O(nlogn)

基于比较的排序时间下界为logn!=nlogn-1.44n+O(logn)

快排序平均为1.39nlogn+O(n)

1 算法描述

(1) 方法：分治法

分解：

A[p..r]==>A[p..q-1]<=A[q]<A[q+1..r]

递归：递归对A[p..q-1]和A[q+1..r]进行快速排序，

临界条件：区间长度为1，空操作

合并：空操作，子数组原址排序，不需要合并

(2) 算法

QuickSort(A,p,r){
if(p<r){
q=partition(A,p,r);
QuickSort(A,p,q-1);
QuickSort(A,q+1,r);
}
}

partition(A,p,r){
x=A[r];
i=p-1;
for(j=p;j<r;j++){
if(A[j]<=x){
i++;
swap(A[i],A[j]);
}
}
swap(A[i+1],A[r]);
return i+1;
}

2 性能分析

(1)最坏的划分：A[p..q-1]，A[q+1..r]中有一个区间是空的

T(n)=T(n-1)+T(0)+O(n)
=T(n-1)+O(n)
=O(n^2)

(2)最好的划分：一分为二，每个区间长度大致相等

T(n)=2T(n/2)+O(n)
=O(nlogn)

(3)平衡划分：每次划分产生的区间为9：1（固定比例）



可用递归数得到

T(n)<=cn*h=cn*log(10/9)n=O(nlogn)

3 随机化版本：利用随机数发生器，随机产生划分元

将QuickSort算法中的partition改为

RandomizedPartition(A,p,r){
i=random(p,r);
Swap(A[i],A[r]);
return pratition(A,p,r);
}

4 期望时间O(nlogn)，证明看算法导论P101，7.4快速排序分析

快排序平均性能最优，但不是任何时候都是最优。如数组本身有序，而每一轮的排序都是以最后一个元素作为划分元，此时时间为O(n^2)。面试的时候，如果面试官要我们实现一个排序算法，首先要清楚这个排序的应用环境是什么、有哪些约束条件，然后在选择合适的排序算法。举个例子：

面试官：请实现一个排序算法，要求时间效率是O(n)
应聘者：对什么数字进行排序，有多少数字?
面试官：我们想对公司的员工的年龄排序，我们公司总共有几万名员工
应聘者：也就是数字的大小在一个较小的范围内，对吧？
面试官：恩，是的
应聘者：可以使用辅助空间吗？
面试官：看你用多少辅助内存，只允许使用常量大小的辅助空间，不得超过O(n)

根据以上交谈，不难想到时间O(n)的排序，常见的三种：

计数排序：n个输入元素的每一个都是在到k区间内的一个整数，k是某个整数，排序时间为O(n+k)，k=O(n)时，O(n)。

基数排序：计数排序的一个扩展，非负整数，k进制表示不超过d位数。k为基，d为位数，时间为O(d(n+k))，k=O(n)且d为常数时，O(n)。

桶排序：输入是均匀分布在[0，1)上的实数。

符合题意的计数排序。

计数排序

1 基本思想

统计<=A[i]的元素数目，将A[i]置入相应位置，即A[i]–>B[<=A[i]的元素数目]，主要解决的问题：

q1:计数，统计小于或等于A[i]的元素数目

q2:值相同元素的处理

2 特殊情形的计数排序

问题描述：n个互补相同的整数A[1..n],1<=A[i]<=n

算法：

SpecialCountingSort(A,B){
//B[1..n]为排序结果
for i=1 to n do{
B[A[i]]=A[i];
}
}

3 一般情形的计数排序

问题描述：n个可以相同的整数A[1..n]，1<=A[i]<=k

基本思想：A[1..n]–>计数器C[1..k]–>B[1..n]

s1：值相同元素计数：将A中值为i的元素个数计入C[i]中

s2：累计计数：对C[1..k]进行修改，使得C[i]的值表示为<=i的元素个数

s3：放置：将A[i]依据C[A[i]]，放入正确的位置B[C[A[i]]]，并修改C[A[i]]=C[A[i]]-1

算法：

CountingSort(A,B,k){
//let c[1..k] to be a new array
for i=0 to k{
C[i]=0;
}
for j=1 to A.length{
C[A[j]]=C[A[j]]+1;
}
//C[i] now contains the number of elements equal to i
for i=1 to k{
C[i]=C[i]+C[i-1];
}
//C[i] now contains the number of elements less than or equal to i
for j=A.length downto 1{
B[C[A[j]]]=A[j];
C[A[j]]=C[A[j]]-1;
}
}

演示例子可以参考算法导论P109图8-2

根据对技术排序的分析，可以写出上面面试官的年龄排序的代码

void SortAges(int[] ages,int length){
if(ages==null||ages.length<=0)
return;
int oldestAge=99;
int timesOfAge[oldestAgs+1];
for(int i=0;i<=oldestAge;i++){
timesOfAge=0;
}
for(int i=0;i<length;i++){
int age=ages[i];
if(age<0||age>oldestAge)
System.out.println("age out of range");
++timesOfAge[age];
}
int index=0;
for(int i=0;i<=oldestAge;i++){
for(int j=0;j<timesOfAge[i];j++){
ages[index]=i;
index++;
}
}
}

基数排序

假定A[1..n]是非负整数，用k进制表示不超过d位

算法：

RadixSort(A,d){
for i=1 to d do{
使用稳定的排序算法对A的第i位排序，如计数排序
}
}

时间T(n)=O(d(n+k))//k为基，d为位数
=O(n)//如果k=O(n)且d为常数

演示例子见算法导论P110图8-3

问题？若d不为常数，基数排序算法还是线性时间吗？

设n个整数的取值范围是0-n^c，c是常数，c>=1

对于十进制数，n^c需要的位数d=log(10)n^c+1==log(10)n

T(n)=O(d(n+k))=O(nlogn)//k=10
不是线性时间

算法何时为线性时间？

Idea：只要是d变为常数，k变大到与n同阶
how to do：
选基k=n，则n^c的位数Log(n)n^c=c=d
d=c,k=n,T(n)=O(n)

桶排序

基本思想：

假定：输入是均匀分布在[0,1)上的实数

s1：[0,1)划分为[0,1/n)，[1/n,2/n)，..，[k/n,(k+1)/n)，[(n-1)/n,1)n个大小相等的子区间，每个子区间看做一个桶

s2：将n个元素分配到桶中

s3：对每个桶里的元素进行排序，依次连接桶

算法思想：

输入0<=A[1..n]<1

辅助数组B[0..n-1]是一个指针数组，指向每个桶

关键字映射：由于0<=A[1..n]<1，必须将A[i]映射到0,1,..,n-1上

因为[0,1)-->[0,n) //nA[i]
即k<=nA[i]<k+1   //存在k
所以桶号k=nA[i]

算法：

BucketSort(A){                                  time
n=A.length;
for i=1 to n do{                            O(n)
将A[i]插入到链表B[nA[i]]中;
}
for i=0 to n-1 do{                          O(n)*
用插入排序将B[i]排序;
}
将B[0],B[1]..B[n-1]连接起来                   O(n)
}

O(n)*因为n个数量是均匀分布在[0,1)中
所以每个桶中大约只有一个数，故时间为O(n)