数组a[N]，1至N-1这N-1个数存放在a[N]中，其中某个数重复一次。写一个函数，找出被重复的数字。

方法一：异或法。

数组a[N]中的N个数异或结果与1至N-1异或的结果再做异或，得到的值即为所求。

• 设重复数为A，其余N-2个数异或结果为B。 
• N个数异或结果为A^A^B 
• 1至N-1异或结果为A^B 
• 由于异或满足交换律和结合律，且X^X = 0  0^X = X; 
• 则有 
• (A^B)^(A^A^B)=A^B^B=A 

代码：

#include <stdio.h>  
#include <stdlib.h>  
#include <math.h>  
#include<time.h>  
void xor_findDup(int * a,int N)    
{    
    int i;    
    int result=0;    
    for(i=0;i<N;i++)    
    {    
        result ^= a[i];    
    }    
      
    for (i=1;i<N;i++)     
    {    
        result ^= i;    
    }    
      
    printf("%d\n",result);    
      
}    
 
 
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,2,1,3,4};    
    xor_findDup(a,5);    
    return 0;    
}   

 方法二：数学法。

对数组的所有项求和，减去1至N-1的和，即为所求数。

#include <stdio.h>  
#include <stdlib.h>  
#include <math.h>  
#include<time.h>  
void xor_findDup(int * a,int N)    
{    
    int tmp1 = 0;  
      
    int tmp2 = 0;  
      
    for (int i=0; i<N-1; ++i)  
          
    {  
          
        tmp1+=(i+1);  
          
        tmp2+=a[i];  
          
    }  
    tmp2+=a[N-1];  
    int result=tmp2-tmp1;     
    printf("%d\n",result);    
      
}    
 
 
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,2,4,3,4};    
    xor_findDup(a,5);    
    return 0;    
}   

对于求和，可以直接根据公式定义一个宏。#define sum(x)  (x*(x+1)/2)
 

#include <stdio.h>  
#include <stdlib.h>  
#include <math.h>  
#include<time.h>  
#define sum(x)  (x*(x+1)/2)   
void xor_findDup(int * a,int N)    
{    
    int tmp1 = sum((N-1));//注意N-1要加括号     
    int tmp2 = 0;  
      
    for (int i=0; i<N; ++i)       
    {             
        tmp2+=a[i];   
    }  
    int result=tmp2-tmp1;     
    printf("%d\n",result);        
}    
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,2,4,2,3};    
    xor_findDup(a,5);    
    return 0;    
}   

 方法三：标志数组法

申请一个长度为n-1且均为'0'组成的字符串。然后从头遍历a[n]数组，取每个数组元素a[i]的值，将其对应的字符串中的相应位置置1，如果已经置过1的话，那么该数就是重复的数。就是用位图来实现的。 如果考虑空间复杂度的话，其空间O（N）

#include <stdio.h>  
#include <stdlib.h>  
#include <math.h>  
#include<time.h>  
#define sum(x)  (x*(x+1)/2)   
void xor_findDup(int * arr,int NUM)    
{    
    int *arrayflag = (int *)malloc(NUM*sizeof(int));      
    int i=1;  
      
    while(i<NUM)  
    {  
        arrayflag[i] = false;  
        i++;  
    }     
      
    for( i=0; i<NUM; i++)         
    {         
        if(arrayflag[arr[i]] == false)            
            arrayflag[arr[i]] = true;          // 置出现标志  
          
        else      
        {   
            printf("%d\n",arr[i]);  
            return ; //返回已经出现的值  
        }  
          
     }    
}    
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,3,2,4,3};    
    xor_findDup(a,5);    
    return 0;    
}    

 方法四：固定偏移量法

a[N]，里面是1至N-1。原数组a[i]最大是N-1，若a[i]=K在某处出现后，将a[K]加一次N，做标记，当某处a[i]=K再次成立时，查看a[K]即可知道K已经出现过。该方法不用另外开辟O(N)的内存空间，但是在查重之后要将数组进行恢复。

#include <stdio.h>  
#include <stdlib.h>  
#include <math.h>  
#include<time.h>  
void xor_findDup(int * arr,int NUM)    
{    
    int temp=0;       
    for(int i=0; i<NUM; i++)          
    {  
          
        if(arr[i]>=NUM)           
            temp=arr[i]-NUM;            // 该值重复了，因为曾经加过一次了        
        else              
            temp=arr[i];          
                  
        if(arr[temp]<NUM)         
        {         
            arr[temp]+=NUM; //做上标记            
        }  
          
        else              
        {             
            printf("有重复 %d\n",temp);              
            return;           
        }         
    }  
              
    printf("无重复");  
    return ;   
}    
void clear(int *data,int num)//清理数据  
{  
    for(int i=0;i<num;i++)  
    {  
        if(data[i]>num)  
            data[i]-=num;  
    }  
 
}  
int main(int argc, char* argv[])    
{    
    int a[] = {2,4,3,4,1};    
    xor_findDup(a,5);    
    clear(a,5);  
    return 0;    
}    

 方法五：符号标志法

上个方法出现后是加N，也可以出现后加个负号，就是符号标志法。

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <math.h>  
#include<time.h>  
 
void xor_findDup(int * arr,int NUM)    
{         
    int temp=0;          
    for(int i=0; i<NUM; i++)        
    {                    
        if(arr[i]<0)     
            temp=0-arr[i];  // 该值重复了，因为曾经加过一次了     
        else                           
            temp=arr[i];                
        if(arr[temp]>0)             
        {                    
            arr[temp]=0-arr[temp]; //做上标记        
        }                
        else              
        {               
            printf("有重复 %d\n",temp);      
            return;               
        }            
    }                
    printf("无重复");    
    return ;    
 }     
 void clear(int *data,int num)//清理数据  
 {     
     for(int i=0;i<num;i++)     
     {        
         if(data[i]<0)           
             data[i]=0-data[i];     
   }     
}    
 int main(int argc, char* argv[])    
 {        
     int a[] = {3,2,1,4,1};       
     xor_findDup(a,5);     
     clear(a,5);      
     return 0;    
 }      

以上的方法对数组元素的值的范围是有限制的，如果数组元素的值不是在1至N-1范围时，可以先求出数组元素的最大值。

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4. #include <math.h>  
5. #include<time.h>  
6.  
7. int  do_dup_mal(int arr[], int n, int *pre, int *back)  
8. {  
9.     int MAX = -1;  
10.     int i = 0;  
11.     int sameVal = -1;  
12.     *pre = *back = -1;  
13.       
14.     for (int j=0; j<n; j++)  
15.     {  
16.         if (arr[j] > MAX) MAX = arr[j];//找出数组中的最大数  
17.     }  
18.       
19.     char *arrayflag = new char[MAX+1] ;  
20.     if (NULL == arrayflag)  
21.         return -1;  
22.     memset(arrayflag, 0, MAX+1 ); // '\0' == 0  
23.     for(i=0; i<n; i++)  
24.     {  
25.         if(arrayflag[arr[i]] == '\0')  
26.             arrayflag[arr[i]] = '\1'; // 置出现标志  
27.         else 
28.         {  
29.             sameVal = arr[i]; //返回已经出现的值  
30.             *back = i;  
31.             break;  
32.         }  
33.     }  
34.     delete[] arrayflag;  
35.     if (i < n)  
36.     {  
37.         for (int j=0; j<n; j++)  
38.         {  
39.             if (sameVal == arr[j])  
40.             {  
41.                 *pre = j;  
42.                 return true;  
43.             }  
44.         }  
45.     }  
46.     return false;  
47. }  
48.  
49.  
50.  
51.  
52.  
53. void main(int argc, char *argv[])  
54. {  
55.     int prePos = -1, backPos = -1;  
56.     int myArry[11];  
57.     myArry[0] = 1;  
58.     myArry[1] = 3;  
59.     myArry[2] = 3;  
60.     myArry[3] = 4;  
61.     myArry[4] = 5;  
62.     myArry[5] = 22;  
63.     myArry[6] = 7;  
64.     myArry[7] = 13;  
65.     myArry[8] = 9;  
66.     myArry[9] = 2;  
67.     myArry[10] = 12;  
68.       
69.       
70.     if (do_dup_mal(myArry, 11, &prePos, &backPos) )  
71.         printf("%d\n",myArry[prePos]);  
72. }  
73.    

转：http://buptdtt.blog.51cto.com/2369962/749049  

"快速排序"的思想很简单，整个排序过程只需要三步：

　　（1）在数据集之中，选择一个元素作为"基准"（pivot）。

　　（2）所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边。

　　（3）对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

举例来说，现在有一个数据集{85, 24, 63, 45, 17, 31, 96, 50}，怎么对其排序呢？

第一步，选择中间的元素45作为"基准"。（基准值可以任意选择，但是选择中间的值比较容易理解。）

第二步，按照顺序，将每个元素与"基准"进行比较，形成两个子集，一个"小于45"，另一个"大于等于45"。

第三步，对两个子集不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

下面参照网上的资料（这里和这里），用Javascript语言实现上面的算法。

首先，定义一个quickSort函数，它的参数是一个数组。

var quickSort = function(arr) {

};

然后，检查数组的元素个数，如果小于等于1，就返回。

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

};

接着，选择"基准"（pivot），并将其与原数组分离，再定义两个空数组，用来存放一左一右的两个子集。

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

　　var pivotIndex = Math.floor(arr.length / 2) ;

　　var pivot = arr.splice(pivotIndex, 1)[0];

　　var left = [];

　　var right = [];

};

然后，开始遍历数组，小于"基准"的元素放入左边的子集，大于基准的元素放入右边的子集。

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

　　var pivotIndex = Math.floor(arr.length / 2) ;

　　var pivot = arr.splice(pivotIndex, 1)[0];

　　var left = [];

　　var right = [];

　　for (var i = 0; i < arr.length; i++){

　　　　if (arr[i] < pivot) {

　　　　　　left.push(arr[i]);

　　　　} else {

　　　　　　right.push(arr[i]);

　　　　}

　　}

};

最后，使用递归不断重复这个过程，就可以得到排序后的数组。

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

　　var pivotIndex = Math.floor(arr.length / 2);

　　var pivot = arr.splice(pivotIndex, 1)[0];

　　var left = [];

　　var right = [];

　　for (var i = 0; i < arr.length; i++){

　　　　if (arr[i] < pivot) {

　　　　　　left.push(arr[i]);

　　　　} else {

　　　　　　right.push(arr[i]);

　　　　}

　　}

　　return quickSort(left).concat([pivot], quickSort(right));

};

使用的时候，直接调用quickSort()就行了。

（完）

         快速排序的基本思想：

         通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。

       先看一下这幅图：

把整个序列看做一个数组，把第零个位置看做中轴，和最后一个比，如果比它小交换，比它大不做任何处理；交换了以后再和小的那端比，比它小不交换，比他大交换。这样循环往复，一趟排序完成，左边就是比中轴小的，右边就是比中轴大的，然后再用分治法，分别对这两个独立的数组进行排序。

public int getMiddle(Integer[] list, int low, int high) {
		int tmp = list[low];    //数组的第一个作为中轴
		while (low < high) {
			while (low < high && list[high] > tmp) {
				high--;
			}
			list[low] = list[high];   //比中轴小的记录移到低端
			while (low < high && list[low] < tmp) {
				low++;
			}
			list[high] = list[low];   //比中轴大的记录移到高端
		}
		list[low] = tmp;              //中轴记录到尾
		return low;                   //返回中轴的位置
	}

public void _quickSort(Integer[] list, int low, int high) {
		if (low < high) {
			int middle = getMiddle(list, low, high);  //将list数组进行一分为二
			_quickSort(list, low, middle - 1);        //对低字表进行递归排序
			_quickSort(list, middle + 1, high);       //对高字表进行递归排序
		}
	}

public void quick(Integer[] str) {
		if (str.length > 0) {    //查看数组是否为空
			_quickSort(str, 0, str.length - 1);
		}
	}

public class TestMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         Integer[] list={34,3,53,2,23,7,14,10};
         QuicSort qs=new QuicSort();
         qs.quick(list);
         for(int i=0;i<list.length;i++){
        	 System.out.print(list[i]+" ");
         }
         System.out.println();
	}

}

     2 3 7 10 14 23 34 53
   

     这样就排序好了，快速排序是对冒泡排序的一种改进，平均时间复杂度是O(nlogn)。

我想说一句“我日，我讨厌KMP！”。
KMP虽然经典，但是理解起来极其复杂，好不容易理解好了，便起码来巨麻烦！
老子就是今天图书馆在写了几个小时才勉强写了一个有bug的、效率不高的KMP，特别是计算next数组的部分。

其实，比KMP算法速度快的算法大把大把，而且理解起来更简单，为何非要抓住KMP呢？笔试出现字符串模式匹配时直接上sunday算法，既简单又高效，何乐而不为？
说实话，想到sunday算法的那个人，绝对是发散思维，绝对牛。当我在被KMP折磨的够呛的时候，我就琢磨，有没有别的好算法呢？？琢磨了半天也没想出个所以然来。笨啊，脑子不够发散。

下面贴上一位兄弟写的算法总结，很简单（建议KMP部分就不用看了，看了费脑子）。
参见：http://hi.baidu.com/willamette/blog/item/02bd0b5599c8b4c0b645ae06.html

趁着做Presentation的功夫，顺便做一个总结

字符串匹配：

---willamette

在匹配串中寻找模式串是否出现，注意和最长公共子序列相区别(LCS: Longest Common Substring)

-：Brute Force(BF或蛮力搜索)算法：

这是世界上最简单的算法了。
首先将匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位。

速度最慢。

那么，怎么改进呢？

我们注意到Brute Force算法是每次移动一个单位，一个一个单位移动显然太慢，是不是可以找到一些办法，让每次能够让模式串多移动一些位置呢？

当然是可以的。

我们也注意到，Brute Force是很不intelligent的，每次匹配不成功的时候，前面匹配成功的信息都被当作废物丢弃了，当然，就如现在的变废为宝一样，我们也同样可以将前面匹配成功的信息利用起来，极大地减少计算机的处理时间，节省成本。^_^

注意，蛮力搜索算法虽然速度慢，但其很通用，文章最后会有一些更多的关于蛮力搜索的信息。

-: KMP算法

首先介绍的就是KMP算法。

原始论文：Knuth D.E., Morris J.H., and Pratt V.R., Fast pattern matching in strings, SIAM Journal on Computing, 6(2), 323-350, 1977.

这个算法实在是太有名了，大学上的算法课程除了最笨的Brute Force算法，然后就介绍了KMP算法。也难怪，呵呵。谁让Knuth D.E.这么world famous呢，不仅拿了图灵奖，而且还写出了计算机界的Bible <The Art of Computer Programming>(业内人士一般简称TAOCP).稍稍提一下，有个叫H.A.Simon的家伙，不仅拿了Turing Award，顺手拿了个Nobel Economics Award，做了AI的爸爸，还是Chicago Univ的Politics PhD，可谓全才。

KMP的具体描述略去，教科书一大把。

-：Horspool算法

Horspool算法。

当然，有市场就有竞争，字符串匹配这么大一个市场，不可能让BF和KMP全部占了，于是又出现了几个强劲的对手。

第一个登场的是

论文：Horspool R.N., 1980, Practical fast searching in strings, Software - Practice & Experience, 10(6):501-506

Horspool算法的思想很简单的。不过有个创新之处就是模式串是从右向左进行比较的。很好很强大，为后来的算法影响很大。

匹配串：abcbcsdxzcxx

模式串：cbcac

这个时候我们从右向左进行对暗号，c-c，恩对上了，第二个b-a，不对啊，我们应该怎么办？难道就这么放弃么。于是，模式串从不匹配的那个字符开始从右向左寻找匹配串中不匹配的字符b的位置，结果发现居然有，赶快对上赶快对上，别耽误了。

匹配串：abcbcsdxzcxx

模式串： cbcac

然后继续从最右边的字符从右向左进行比较。这时候，我们发现了，d-c不匹配啊，而且模式穿里面没有噢，没办法，只好移动一个模式串长度的单位了。

匹配串：abcbcsdxzcxx

模式串：      cbcac

-：Boyer-Moore算法

对于BM算法，下面推荐一个讲解非常优秀的文章，可谓图文并茂啊，而且还是个MM写的。

Boyer-Moore 经典单模式匹配算法
http://blog.csdn.net/iJuliet/archive/2009/05/19/4200771.aspx


-：Sunday算法

最后一个是Sunday算法，实际上比Boyer-Moore还快，呵呵。长江后浪推前浪。

原始论文：Daniel M. Sunday, A very fast substring search algorithm, Communications of the ACM, v.33 n.8, p.132-142, Aug. 1990

看原始论文的题目，D.M. Sunday貌似是故意想气气Boyer-Moore两位大牛似的。呵呵。不过实际上的确Sunday算法的确比BM算法要快，而且更简单。

Sunday的算法思想和Horspool有些相似，但是。当出现不匹配的时候，却不是去找匹配串中不匹配的字符在模式串的位置，而是直接找最右边对齐的右一位的那个字符在模式串的位置。

比如：

匹配串：abcbczdxzc

模式串：zbcac

恩，这里我们看到b-a没有对上，我们就看匹配串中的z在模式串的位置，然后，嘿嘿。

匹配串：abcbczdxzc

模式串：     zbcac

如果模式串中的没有那个字符怎么办呢？很简单，跳过去呗。

匹配串：abcbcedxzcs

模式串：zbcac

e不在模式串中出现

那么我们就

匹配串：abcbcedxzcs

模式串：      zbcac

(2009/10/20补充)
RK算法

某一天在图书馆的一本算法分析设计书上翻到的。思路很新颖！和大家分享下。
在串匹配的简单算法中，把文本每m个字符构成的字符段作为一个字段，和模式进行匹配检查。如果能对一个长度为m的字符

串赋以一个Hash函数。那么显然只有那些与模式具有相同hash函数值的文本中的字符串才有可能与模式匹配，这是必要条件

，而没有必要去考虑文本中所有长度为m的字段，因而大大提高了串匹配的速度。因此RK算法的思想和KMP，BM，Sunday等思

路迥然不同！
（事实上，之前的串匹配方法，是将模式串的一个一个字符作为小的特征去分别进行匹配，而RK算法则是将串整体作为一个

特征！难就难在单个字符的特征很容易想得到，整体作为一个特征就没那么容易想得到了）
如果把整体作为一个特征，那么如何快速的求出这个整体特征的特征值？？
模式串的特征值仅需求一次即可。对于文本中的任意m个字符构成的字串如何快速的求特征就是个难点了。
抛砖引玉，这里给出一个简单的特征计算。 将字符串的每一个字符看做一个数，那么这个字符串的就是一个数字数组，通

过积分向量可以快速任意一个长度子字符串的向量和。可以把字符串的对应的字符数组的元素和看做这个字符串整体特征。

这个特征是可以再O（1）的时间内求出的。其实原始的RK算法里面是把字符串看做一个26进制数在计算特征的。这里就不啰

嗦了，有兴趣的可以深入查找

aabseesds 模式串 ees
      ees

发现 see向量和 == ees的向量和
然后就对see和ees做逐个字符的比较。发现不匹配继续往下走
aabseesds 模式串 ees
        ees
发现 ees向量和 == ees的向量和
然后就对ees和ees做逐个字符的比较。发现匹配OK。

另外还有 字符串匹配自动机 后缀树算法（分在线和非在线两种）等 见如下文章。不能说那个比那个更好，各个算法都有自己的优势及最佳应用场合。参考：
http://blog.csdn.net/yifan403/archive/2009/06/16/4272793.aspx

另外，关于多模式字符串匹配 有AC算法（字符串匹配自动机思想） WM算法（BM在多模式的推广应用）
参考：
http://blog.csdn.net/ijuliet/category/498465.aspx 该女子的blog有很多好文章。

===============================================================================
一个sunday算法的实现
http://hi.baidu.com/azuryy/blog/item/10d3d3460b97af0e6b63e5cd.html

头文件定义：
/* Sunday.h */
class Sunday
{
public:
   Sunday();
   ~Sunday();

public:
    int find(const char* pattern, const char* text);

private:
    void preCompute(const char* pattern);

private:
    //Let's assume all characters are all ASCII
    static const int ASSIZE = 128;
    int _td[ASSIZE] ;
    int _patLength;
    int _textLength;
};


源文件
/* Sunday.cpp */

Sunday::Sunday()
{
}

Sunday::~Sunday()
{
}

void Sunday::preCompute(const char* pattern)
{
    for(int i = 0; i < ASSIZE; i++ )
        _td[i] = _patLength + 1;

    const char* p;
    for ( p = pattern; *p; p++)
        _td[*p] = _patLength - (p - pattern);
}

int Sunday::find(const char* pattern, const char* text)
{
    _patLength = strlen( pattern );
    _textLength = strlen( text );

    if ( _patLength <= 0 || _textLength <= 0)
        return -1;

    preCompute( pattern );

    const char *t, *p, *tx = text;

    while (tx + _patLength <= text + _textLength)
    {
        for (p = pattern, t = tx; *p; ++p, ++t)
        {
            if (*p != *t)
                break;
        }
        if (*p == 0)
            return tx-text;
        tx += _td[tx[_patLength]];
    }
    return -1;
}

简单测试下：
int main()

{
    char* text = "blog.csdn,blog.net";
    char* pattern = "csdn,blog"    ;
    Sunday sunday;

    printf("The First Occurence at: %d/n",sunday.find(pattern,text));

    return 1;
}

////////////////////////////////////////////
strstr的实现。
需要说明的是strstr是c语言提供的使用Brute Force实现的字符串匹配，简单、通用是其最大的优点。时间复杂度是O(mn)
// 下面是Microsoft的实现
//经典算法
//比KMP算法简单,没有KMP算法高效
char * __cdecl strstr (
        const char * str1,
        const char * str2
        )
{
        char *cp = (char *) str1;
        char *s1, *s2;
        if ( !*str2 )
            return((char *)str1);
        while (*cp)
        {
                s1 = cp;
                s2 = (char *) str2;
                while ( *s1 && *s2 && !(*s1-*s2) )
                        s1++, s2++;
                if (!*s2)
                        return(cp);
                cp++;
        }
        return(NULL);
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/whoismickey/archive/2009/02/08/3869367.aspx

strstr