亚洲免费观看高清在线观看 ,亚洲美女啪啪,亚洲欧美日韩一区

各种排序��法介绍

eircQ — Fri, 17 Jun 2011 00:09:00 GMT

排序��法是一�U�基本�ƈ且常用的��法。由于实际工作中处理的数量巨大，所以排序算法对��法本��n的速度要求很高�?br />
而一般我们所谓的��法的性能主要是指��法的复杂度�Q�一般用O�Ҏ��来表�C�。在后面我将�l�出详细的说明�?br />
对于排序的算法我惛_��做一点简单的介绍�Q�也是给�q�篇文章理一个提�U�Ӏ?br />
我将按照��法的复杂度�Q�从��单到难来分析��法�?br />
�W�一部分是简单排序算法，后面你将看到他们的共同点是算法复杂度为O(N*N)�Q�因为没有��用word,所以无法打��Z��标和下标�Q��?br />
�W�二部分是高�U�排序算法，复杂度�ؓO(Log2(N))。这里我们只介绍一�U�算法。另外还有几�U�算法因为涉及树与堆的概念，所以这里不于讨论�?br />
�W�三部分�c�M��动脑�{�。这里的两种��法�q�不是最好的�Q�甚��x��最慢的�Q�，但是��法本��n比较奇特�Q�值得参考（�~�程的角度）。同时也可以让我们从另外的角度来认识�q�个问题�?br />
�W�四部分是我送给大家的一个餐后的甜点——一个基于模板的通用快速排序。由于是模板函数可以对�Q何数据类型排序（抱歉�Q�里面��用了一些论坛专家的呢称�Q��?

现在�Q�让我们开始吧�Q?

一、简单排序算�?
�׃��E�序比较��单，所以没有加什么注释。所有的�E�序都给��Z��完整的运行代码，�q�在我的VC环境下运行通过。因为没有涉及MFC和WINDOWS的内容，所以在BORLAND C++的��^��C��应该也不会有什么问题的。在代码的后面给��Z��q�行�q�程�C�意�Q�希望对理解有帮助�?

1.冒��法：
�q�是最原始�Q�也是众所周知的最慢的��法了。他的名字的由来因�ؓ它的工作看来象是冒��Q?
#include

void BubbleSort(int* pData,int Count)
{
  int iTemp;
  for(int i=1;i  {
    for(int j=Count-1;j>=i;j--)
    {
      if(pData[j]      {
        iTemp = pData[j-1];
        pData[j-1] = pData[j];
        pData[j] = iTemp;
      }
    }
  }
}

void main()
{
  int data[] = {10,9,8,7,6,5,4};
  BubbleSort(data,7);
  for (int i=0;i<7;i++)
    cout<  cout<<"\n";
}

倒序(最�p�情�?
�W�一轮：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3��?
�W�二轮：7,10,9,8->7,10,8,9->7,8,10,9(交换2��?
�W�一轮：7,8,10,9->7,8,9,10(交换1��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?

其他�Q?
�W�一轮：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2��?
�W�二轮：7,8,10,9->7,8,10,9->7,8,10,9(交换0��?
�W�一轮：7,8,10,9->7,8,9,10(交换1��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?

上面我们�l�出了程序段�Q�现在我们分析它�Q�这里，影响我们��法性能的主要部分是循环和交换，昄��Q�次数越多，性能��p��差。从上面的程序我们可以看出��@环的�ơ数是固定的�Q��ؓ1+2+...+n-1�?
写成公式��是1/2*(n-1)*n�?
现在注意�Q�我们给出O�Ҏ��的定义：

  若存在一帔R��K和�v点n0�Q��当n>=n0�Ӟ��有f(n)<=K*g(n),则f(n) = O(g(n))。（呵呵�Q�不要说没学好数学呀�Q�对于编�E�数学是非常重要的！�Q�！�Q?

现在我们来看1/2*(n-1)*n�Q�当K=1/2�Q�n0=1�Q�g(n)=n*n�Ӟ��1/2*(n-1)*n<=1/2*n*n=K*g(n)。所�?n)=O(g(n))=O(n*n)。所以我们程序��@环的复杂度�ؓO(n*n)�?
再看交换。从�E�序后面所跟的表可以看刎ͼ�两种情况的��@环相同，交换不同。其实交换本�w�同数据源的有序�E�度有极大的关系�Q�当数据处于倒序的情冉|��Q?交换�ơ数同��@环一��P��每次循环判断都会交换�Q�，复杂度�ؓO(n*n)。当数据为正序，��不会有交换。复杂度为O(0)。�ؕ序时处于中间状态。正是由于这�?的原因，我们通常都是通过循环�ơ数来对比算法�?

2.交换法：
交换法的�E�序最清晰��单，每次用当前的元素一一的同其后的元素比较�ƈ交换�?
#include
void ExchangeSort(int* pData,int Count)
{
  int iTemp;
  for(int i=0;i  {
    for(int j=i+1;j    {
      if(pData[j]      {
        iTemp = pData[i];
        pData[i] = pData[j];
        pData[j] = iTemp;
      }
    }
  }
}

void main()
{
  int data[] = {10,9,8,7,6,5,4};
  ExchangeSort(data,7);
  for (int i=0;i<7;i++)
    cout<  cout<<"\n";
}
倒序(最�p�情�?
�W�一轮：10,9,8,7->9,10,8,7->8,10,9,7->7,10,9,8(交换3��?
�W�二轮：7,10,9,8->7,9,10,8->7,8,10,9(交换2��?
�W�一轮：7,8,10,9->7,8,9,10(交换1��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?

其他�Q?
�W�一轮：8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交换1��?
�W�二轮：7,10,8,9->7,8,10,9->7,8,10,9(交换1��?
�W�一轮：7,8,10,9->7,8,9,10(交换1��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?

从运行的表格来看�Q�交换几乎和冒��一��L��。事实确实如此。��@环次数和冒��一样也�?/2*(n-1)*n�Q�所以算法的复杂度仍然是O(n*n)。由于我们无法给出所有的情况�Q�所以只能直接告诉大家他们在交换上面也是一��L��p�糕�Q�在某些情况下稍好，在某些情况下�E�差�Q��?

3.选择法：
现在我们�l�于可以看到一点希望：选择法，�q�种�Ҏ��提高了一�Ҏ��能�Q�某些情况下�Q?
�q�种�Ҏ��c�M��我们��Zؓ的排序习惯：从数据中选择最��的同第一个��g��换，在从省下的部分中选择最��的与第二个交换�Q�这样往复下厅R�?
#include
void SelectSort(int* pData,int Count)
{
  int iTemp;
  int iPos;
  for(int i=0;i  {
    iTemp = pData[i];
    iPos = i;
    for(int j=i+1;j    {
      if(pData[j]      {
        iTemp = pData[j];
        iPos = j;
      }
    }
    pData[iPos] = pData[i];
    pData[i] = iTemp;
  }
}

void main()
{
  int data[] = {10,9,8,7,6,5,4};
  SelectSort(data,7);
  for (int i=0;i<7;i++)
    cout<  cout<<"\n";
}
倒序(最�p�情�?
�W�一轮：10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交换1��?
�W�二轮：7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交换1��?
�W�一轮：7,8,9,10->(iTemp=9)7,8,9,10(交换0��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?

其他�Q?
�W�一轮：8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交换1��?
�W�二轮：7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交换1��?
�W�一轮：7,8,10,9->(iTemp=9)7,8,9,10(交换1��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?
遗憾的是��法需要的循环�ơ数依然�?/2*(n-1)*n。所以算法复杂度为O(n*n)�?
我们来看他的交换。由于每�ơ外层��@环只产生一�ơ交换（只有一个最��|��。所以f(n)<=n
所以我们有f(n)=O(n)�?br />所以，在数据较��q��时候，可以减少一定的交换�ơ数�?

4.插入法：
插入法较为复杂，它的基本工作原理是抽出牌�Q�在前面的牌中寻扄��应的位置插入�Q�然后��l�下一�?
#include
void InsertSort(int* pData,int Count)
{
  int iTemp;
  int iPos;
  for(int i=1;i  {
    iTemp = pData[i];
    iPos = i-1;
    while((iPos>=0) && (iTemp    {
      pData[iPos+1] = pData[iPos];
      iPos--;
    }
    pData[iPos+1] = iTemp;
  }
}

void main()
{
  int data[] = {10,9,8,7,6,5,4};
  InsertSort(data,7);
  for (int i=0;i<7;i++)
    cout<  cout<<"\n";
}

倒序(最�p�情�?
�W�一轮：10,9,8,7->9,10,8,7(交换1��?(循环1��?
�W�二轮：9,10,8,7->8,9,10,7(交换1��?(循环2��?
�W�一轮：8,9,10,7->7,8,9,10(交换1��?(循环3��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?

其他�Q?
�W�一轮：8,10,7,9->8,10,7,9(交换0��?(循环1��?
�W�二轮：8,10,7,9->7,8,10,9(交换1��?(循环2��?
�W�一轮：7,8,10,9->7,8,9,10(交换1��?(循环1��?
循环�ơ数�Q?��?
交换�ơ数�Q?��?

上面�l�尾的行为分析事实上造成了一�U�假象，让我们认��U�算法是��单算法中最好的�Q�其实不是，因�ؓ其��@环次数虽然�ƈ不固定，我们仍可以��用O�?法。从上面的结果可以看出，循环的次数f(n)<= 1/2*n*(n-1)<=1/2*n*n。所以其复杂度仍为O(n*n)�Q�这里说明一下，其实如果不是��Z��展示�q�些��单排序的不同�Q�交换次��C��?可以�q�样推导�Q�。现在看交换�Q�从外观上看�Q�交换次数是O(n)�Q�推导类似选择法）�Q�但我们每次要进行与内层循环相同�ơ数�?#8216;=’操作。正常的一�ơ交换我�?需要三��?#8216;=’�Q�而这里显然多了一些，所以我们浪费了旉��?

最�l�，我个��为，在简单排序算法中�Q�选择法是最好的�?

二、高�U�排序算法：
高��排序��法中我们将只介�l�这一�U�，同时也是目前我所知道�Q�我看过的资料中�Q�的最快的�?
它的工作看�v来仍然象一个二叉树。首先我们选择一个中间值middle�E�序中我们��用数�l�中间��|��然后把比它小的放在左边，大的攑֜�双��Q�具体的实现是从两边找，扑ֈ�一对后交换�Q�。然后对两边分别使用�q�个�q�程�Q�最�Ҏ��的方�?#8212;—递归�Q��?

1.快速排序：
#include

void run(int* pData,int left,int right)
{
  int i,j;
  int middle,iTemp;
  i = left;
  j = right;
  middle = pData[(left+right)/2]; //求中间�?
  do{
    while((pData[i]      i++;
    while((pData[j]>middle) && (j>left))//从右扫描大于中值的�?
      j--;
    if(i<=j)//扑ֈ�了一对�?
    {
      //交换
      iTemp = pData[i];
      pData[i] = pData[j];
      pData[j] = iTemp;
      i++;
      j--;
    }
  }while(i<=j);//如果两边扫描的下标交错，��停止（完成一�ơ）

  //当左辚w��分有�?left  if(left    run(pData,left,j);
  //当右辚w��分有�?right>i)�Q�递归叛_��?
  if(right>i)
    run(pData,i,right);
}

void QuickSort(int* pData,int Count)
{
  run(pData,0,Count-1);
}

void main()
{
  int data[] = {10,9,8,7,6,5,4};
  QuickSort(data,7);
  for (int i=0;i<7;i++)
    cout<  cout<<"\n";
}

�q�里我没有给��为的分析�Q�因��个很��单，我们直接来分析算法：首先我们考虑最理想的情�?
1.数组的大��是2的幂�Q�这样分下去始终可以�?整除。假设�ؓ2的k�ơ方�Q�即k=log2(n)�?
2.每次我们选择的值刚好是中间��|��q�样�Q�数�l�才可以被等分�?
�W�一层递归�Q��@环n�ơ，�W�二层��@�?*(n/2)......
所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n
所以算法复杂度为O(log2(n)*n)
其他的情况只会比�q�种情况差，最差的情况是每�ơ选择到的middle都是最��值或最大��|��那么他将变成交换法（�׃��使用了递归�Q�情冉|��p�）。但是你认�ؓ�q�种情况发生的几率有多大�Q�？呵呵�Q�你完全不必担心�q�个问题。实践证明，大多数的情况�Q�快速排序��L��最好的�?
如果你担心这个问题，你可以��用堆排序�Q�这是一�U�稳定的O(log2(n)*n)��法�Q�但是通常情况下速度要慢
于快速排序（因�ؓ要重�l�堆�Q��?

三、其他排�?
1.双向冒��Q?
通常的冒泡是单向的，而这里是双向的，也就是说�q�要�q�行反向的工作�?
代码看�v来复杂，仔细理一下就明白了，是一个来回震荡的方式�?
写这�D�代码的作者认��样可以在冒��的基��上减��一些交换（我不�q�么认�ؓ�Q�也许我错了�Q��?
反正我认��是一�D�|��的代码�Q�值得一看�?
#include
void Bubble2Sort(int* pData,int Count)
{
  int iTemp;
  int left = 1;
  int right =Count -1;
  int t;
  do
  {
    //正向的部�?
    for(int i=right;i>=left;i--)
    {
      if(pData[i]      {
        iTemp = pData[i];
        pData[i] = pData[i-1];
        pData[i-1] = iTemp;
        t = i;
      }
    }
    left = t+1;

    //反向的部�?
    for(i=left;i    {
      if(pData[i]      {
        iTemp = pData[i];
        pData[i] = pData[i-1];
        pData[i-1] = iTemp;
        t = i;
      }
    }
    right = t-1;
  }while(left<=right);
}

void main()
{
  int data[] = {10,9,8,7,6,5,4};
  Bubble2Sort(data,7);
  for (int i=0;i<7;i++)
    cout<  cout<<"\n";
}

2.SHELL排序
�q�个排序非常复杂�Q�看了程序就知道了�?
首先需要一个递减的步长，�q�里我们使用的是9�?�?�?�Q�最后的步长必须�?�Q��?
工作原理是首先对盔R��9-1个元素的所有内�Ҏ��序，然后再��用同��L��Ҏ��对相�?-1个元素的排序以次�c�L��?
#include
void ShellSort(int* pData,int Count)
{
  int step[4];
  step[0] = 9;
  step[1] = 5;
  step[2] = 3;
  step[3] = 1;

  int iTemp;
  int k,s,w;
  for(int i=0;i<4;i++)
  {
    k = step[i];
    s = -k;
    for(int j=k;j    {
      iTemp = pData[j];
      w = j-k;//求上step个元素的下标
      if(s ==0)
      {
        s = -k;
        s++;
        pData[s] = iTemp;
      }
      while((iTemp=0) && (w<=Count))
      {
        pData[w+k] = pData[w];
        w = w-k;
      }
      pData[w+k] = iTemp;
    }
  }
}

void main()
{
  int data[] = {10,9,8,7,6,5,4,3,2,1,-10,-1};
  ShellSort(data,12);
  for (int i=0;i<12;i++)
    cout<  cout<<"\n";
}
呵呵�Q�程序看��h��有些头疼。不�q�也不是很难�Q�把s==0的块��L��p��村֤�了，�q�里是避免��?步长造成�E�序异常而写的代码。这个代码我认�ؓ很值得一看�?
�q�个��法的得名是因�ؓ其发明者的名字D.L.SHELL。依照参考资料上的说法：“�׃��复杂的数学原因避免��?的幂�ơ步长，它能降低��法效率�?#8221;另外��法的复杂度为n�?.2�ơ幂。同样因为非常复杂�ƈ“��出本书讨论范围”的原因（我也不知道过�E�）�Q�我们只有结果了�?

最后，希望大家愉快的编�E�。有什么意见，�l�我提吧�Q?

eircQ 2011-06-17 08:09 发表评论

Hash ��法及其应用(�?

eircQ — Thu, 02 Dec 2010 15:08:00 GMT

期：2004-07-30]

来源�Q?a target="_blank" style="color: rgb(65, 81, 154); text-decoration: none; ">CSDN 作者：

[字体�Q?a style="color: rgb(65, 81, 154); text-decoration: none; ">�?/a> �?/a> ��?/a>]

---------------
什么是 Hash
Hash 的重要特�?nbsp;
Hash 函数的实�?nbsp;
主要�?Hash ��法
Hash ��法的安全问�?nbsp;
Hash ��法的应�?nbsp;
�l?�?nbsp;
---------------

Hash�Q�一般翻译做“散列”�Q�也有直接音译�ؓ"哈希"的，��是把�Q意长度的输入�Q�又叫做预映��， pre-image�Q�，通过散列��法�Q�变换成固定长度的输出，该输出就是散列倹{��这�U��{换是一�U�压�~�映��，也就是，散列值的�I�间通常�q�小于输入的�I�间�Q�不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入倹{�?/p>

数学表述为：h = H(M) �Q�其中H( )--单向散列函数�Q�M--��L��长度明文�Q�h--固定长度散列倹{�?/p>

在信息安全领域中应用的Hash��法�Q�还需要满��_��他关键特性：

�W�一当然是单向�?one-way)�Q�从预映��，能够��单迅速的得到散列��|��而在计算上不可能构造一个预映射�Q��其散列结果等于某个特定的散列��|��x��造相应的M=H-1(h)不可行。这��P��散列值就能在�l�计上唯一的表征输入��|��因此�Q�密码学上的 Hash 又被�U�Cؓ"消息摘要(message digest)"�Q�就是要求能方便的将"消息"�q�行"摘要"�Q�但�?摘要"中无法得到比"摘要"本��n更多的关�?消息"的信息�?/p>

�W�二是抗冲突�?collision-resistant)�Q�即在统计上无法产生2个散列值相同的预映��。给定M�Q�计��上无法扑ֈ�M'�Q�满��H(M)=H(M') �Q�此谓弱抗冲�H�性；计算上也难以��L��一对�Q意的M和M'�Q��满��H(M)=H(M') �Q�此谓强抗冲�H�性。要�?强抗冲突�?主要是�ؓ了防范所�?生日��d��(birthday attack)"�Q�在一�?0人的团体中，你能扑ֈ�和你生日相同的�h的概率是2.4%�Q�而在同一团体中，�?人生日相同的概率�?1.7%。类似的�Q�当预映��的�I�间很大的情况下�Q�算法必��L��_��的强度来保证不能��L��扑ֈ�"相同生日"的�h�?/p>

�W�三是映��分布均匀性和差分分布均匀性，散列�l�果中，�?0 �?bit 和�ؓ 1 �?bit �Q�其��L��应该大致相等�Q�输入中一�?bit 的变化，散列�l�果中将有一半以上的 bit 改变�Q�这又叫�?雪崩效应(avalanche effect)"�Q�要实现使散列结果中出现 1bit 的变化，则输入中臛_��有一半以上的 bit 必须发生变化。其实质是必��M��输入中每一�?bit 的信息，��量均匀的反映到输出的每一�?bit 上去�Q�输��Z��的每一�?bit�Q�都是输入中��可能多 bit 的信息一起作用的�l�果�?/p>

Damgard �?Merkle 定义了所�?#8220;压羃函数(compression function)”�Q�就是将一个固定长度输入，变换成较短的固定长度的输出，�q�对密码学实践上 Hash 函数的设计��生了很大的媄响。Hash函数��是被设计�ؓ��Z��通过特定压羃函数的不断重�?#8220;压羃”输入的分�l�和前一�ơ压�~�处理的�l�果的过�E�，直到整个消息都被压羃完毕�Q�最后的输出作�ؓ整个消息的散列倹{��尽��还�~�Z��严格的证明，但绝大多��C��界的研究者都同意�Q�如果压�~�函数是安全的，那么以上�q��Ş式散列�Q意长度的消息也将是安全的。这��是所�?Damgard/Merkle �l�构�Q?/p>

在下图中�Q��Q意长度的消息被分拆成�W�合压羃函数输入要求的分�l�，最后一个分�l�可能需要在末尾��M��特定的填充字节，�q�些分组��被��序处理�Q�除了第一个消息分�l�将与散列初始化��g��起作为压�~�函数的输入外，当前分组��和前一个分�l�的压羃函数输出一赯��作�ؓ�q�一�ơ压�~�的输入�Q�而其输出又将被作��Z��一个分�l�压�~�函数输入的一部分�Q�直到最后一个压�~�函数的输出�Q�将被作为整个消息散列的�l�果�?/p>

MD5 �?SHA1 可以说是目前应用最�q�泛的Hash��法�Q�而它们都是以 MD4 为基��设计的�?/p>

1) MD4
MD4(RFC 1320)�?MIT �?Ronald L. Rivest �?1990 �q�设计的�Q�MD �?Message Digest 的羃写。它适用�?2位字长的处理器上用高速��Y件实�?-它是��Z�� 32 位操作数的位操作来实现的。它的安全性不像RSA那样��Z��数学假设�Q�尽��?Den Boer、Bosselaers �?Dobbertin 很快��q��分析和差分成功的��d��了它3轮变换中�?2 轮，证明了它�q�不像期望的那样安全�Q�但它的整个��法�q�没有真正被破解�q�，Rivest 也很快进行了改进�?/p>

下面是一些MD4散列�l�果的例子：

MD4 ("") = 31d6cfe0d16ae931b73c59d7e0c089c0
MD4 ("a") = bde52cb31de33e46245e05fbdbd6fb24
MD4 ("abc") = a448017aaf21d8525fc10ae87aa6729d
MD4 ("message digest") = d9130a8164549fe818874806e1c7014b
MD4 ("abcdefghijklmnopqrstuvwxyz") = d79e1c308aa5bbcdeea8ed63df412da9
MD4 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = 043f8582f241db351ce627e153e7f0e4
MD4 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = e33b4ddc9c38f2199c3e7b164fcc0536

2) MD5
MD5(RFC 1321)�?Rivest �?991�q�对MD4的改�q�版本。它对输入仍�?12位分�l�，其输出是4�?2位字的��联，�?MD4 相同。它较MD4所做的改进是：

1) 加入了第四轮
2) 每一步都有唯一的加法常敎ͼ�
3) �W�二轮中的G函数�?(X �?Y) �?(X �?Z) �?(Y �?Z)) 变�ؓ ((X �?Z) �?(Y �?～Z))以减��其对称性；
4) 每一步都加入了前一步的�l�果�Q�以加快"雪崩效应"�Q?nbsp;
5) 改变了第2轮和�W?轮中讉K��输入子分�l�的��序�Q�减��了形式的相似程度；
6) �q�似优化了每轮的循环左移位移量，以期加快"雪崩效应"�Q�各轮的循环左移都不同�?nbsp;
��管MD5比MD4来得复杂�Q��ƈ且速度较之要慢一点，但更安全�Q�在抗分析和抗差分方面表现更好�?/p>

消息首先被拆成若�q�个512位的分组�Q�其中最�?12位一个分�l�是“消息��?填充字节(100…0)+64 位消息长�?#8221;�Q�以��保对于不同长度的消息，该分�l�不相同�?4位消息长度的限制��D��了MD5安全的输入长度必��d��?64bit�Q�因为大�?4位的长度信息��被忽略。�?�?2位寄存器字初始化为A=0x01234567�Q�B=0x89abcdef�Q�C=0xfedcba98�Q�D=0x76543210�Q�它们将始终参与�q�算�q��Ş成最�l�的散列�l�果�?/p>

接着各个512位消息分�l�以16�?2位字的�Ş式进入算法的��d�@环，512位消息分�l�的个数据决定了循环的次数。主循环�?轮，每轮分别用到了非�U�性函�?/p>

F(X, Y, Z) = (X �?Y) �?(～X �?Z)
G(X, Y, Z) = (X �?Z) �?(Y �?～Z)
H(X, Y, Z) =X ⊕ Y ⊕ Z
I(X, Y, Z) = X ⊕ (Y �?～Z)
�q?轮变换是对进入主循环�?12位消息分�l�的16�?2位字分别�q�行如下操作�Q�将A、B、C、D的副本a、b、c、d中的3个经F、G、H、I�q�算后的�l�果与第4个相加，再加�?2位字和一�?2位字的加法常敎ͼ��q�将所得之值��@环左�U�若�q�位�Q�最后将所得结果加上a、b、c、d之一�Q��ƈ回送至ABCD�Q�由此完成一�ơ��@环�?/p>

所用的加法常数��p��样一张表T[i]来定义，其中i�?…64�Q�T[i]是i的正弦绝对��g��4294967296�ơ方的整数部分，�q�样做是��Z��通过正��u函数和幂函数来进一步消除变换中的线性性�?/p>

当所�?12位分�l�都�q�算完毕后，ABCD的��联将被输��ZؓMD5散列的结果。下面是一些MD5散列�l�果的例子：

MD5 ("") = d41d8cd98f00b204e9800998ecf8427e
MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661
MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72
MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0
MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f
MD5 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a
参考相应RFC文档可以得到MD4、MD5��法的详�l�描�q�和��法的C源代码�?/p>

3) SHA1 及其�?nbsp;
SHA1是由NIST NSA设计为同DSA一起��用的�Q�访问http://www.itl.nist.gov/fipspubs可以得到它的详细规范--[/url]"FIPS PUB 180-1 SECURE HASH STANDARD"。它寚w��度小�?64的输入，产生长度�?60bit的散列��|��因此抗穷�?brute-force)性更好。SHA-1 设计时基于和MD4相同原理,�q�且模仿了该��法。因为它��?60bit的散列��|��因此它有5个参与运��的32位寄存器字，消息分组和填充方式与MD5相同�Q�主循环也同��h��4轮，但每轮进�?0�ơ操作，非线性运��、移位和加法�q�算也与MD5�c�M��Q�但非线性函数、加法常数和循环左移操作的设计有一些区别，可以参考上面提到的规范来了解这些细节。下面是一些SHA1散列�l�果的例子：

SHA1 ("abc") = a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d
SHA1 ("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e44 1c3bd26e baae4aa1 f95129e5 e54670f1
其他一些知名的Hash��法�q�有MD2、N-Hash、RIPE-MD、HAVAL�{�等。上面提到的�q�些都属�?�U?Hash��法。还有另2�c�Hash��法�Q�一�c�d��是基于对�U�分�l�算法的单向散列��法�Q�典型的例子是基于DES的所谓Davies-Meyer��法�Q�另外还有经IDEA改进的Davies-Meyer��法�Q�它们两者目前都被认为是安全的算法。另一�c�L��Z��模运��?��L��Ҏ��的，也就是基于公开密钥��法的，但因为其�q�算开销太大�Q�而缺乏很好的应用前景�?/p>

没有通过分析和差分攻击考验的算法，大多都已�l�夭折在实验室里了，因此�Q�如果目前流行的Hash��法能完全符合密码学意义上的单向性和抗冲�H�性，��׃��证了只有�I��D�Q�才是破坏Hash�q�算安全�Ҏ��的唯一�Ҏ��。�ؓ了对抗弱抗冲�H�性，我们可能要穷举个数和散列值空间长度一样大的输入，卛_��?^128�?^160个不同的输入�Q�目前一台高档个人电脑可能需�?0^25�q�才能完成这一艰巨的工作，即��是最高端的�ƈ行系�l�，�q�也不是在几千年里的�q�得完的事。而因�?生日��d��"有效的降低了需要穷丄��I�间�Q�将光��低�ؓ大约1.2*2^64�?.2*2^80�Q�所以，强抗冲突性是军_��Hash��法安全性的关键�?/p>

在NIST新的 Advanced Encryption Standard (AES)中，使用了长度�ؓ128�?92�?56bit 的密钥，因此相应的设计了 SHA256、SHA384、SHA512�Q�它们将提供更好的安全性�?/p>

Hash��法在信息安全方面的应用主要体现在以下的3个方面：

1) 文�g校验
我们比较熟悉的校验算法有奇偶校验和CRC校验�Q�这2�U�校验�ƈ没有抗数据篡改的能力�Q�它们一定程度上能检��ƈ�U�正数据传输中的信道误码�Q�但却不能防止对数据的恶意破坏�?/p>

MD5 Hash��法�?数字指纹"�Ҏ��，使它成�ؓ目前应用最�q�泛的一�U�文件完整性校验和(Checksum)��法�Q�不��Unix�pȝ��有提供计��md5 checksum的命令。它常被用在下面�?�U�情况下�Q?/p>

�W�一是文件传送后的校验，��得到的目标文�g计算 md5 checksum�Q�与源文件的md5 checksum 比对�Q�由两�?md5 checksum 的一致性，可以从统计上保证2个文件的每一个码元也是完全相同的。这可以��验文件传输过�E�中是否出现错误�Q�更重要的是可以保证文�g在传输过�E�中未被恶意��改。一个很典型的应用是ftp服务�Q�用户可以用来保证多�ơ断点箋传，特别是从镜像站点下蝲的文件的正确性�?/p>

更出色的解决�Ҏ��是所谓的代码�{�֐��Q�文件的提供者在提供文�g的同�Ӟ��提供�Ҏ��件Hash值用自己的代码签名密钥进行数字签名的��|��及自��q��代码�{�֐�证书。文件的接受者不仅能验证文�g的完整性，�q�可以依据自己对证书�{�֏�者和证书拥有者的信�Q�E�度�Q�决定是否接受该文�g。浏览器在下载运行插件和java��程序时�Q��用的��是�q�样的模式�?/p>

�W�二是用作保存二�q�制文�g�pȝ��的数字指�U�，以便��文件系�l�是否未�l�允许的被修攏V��不��系�l�管�?�pȝ��安全软�g都提供这一文�g�pȝ��完整性评估的功能�Q�在�pȝ��初始安装完毕后，建立�Ҏ��件系�l�的基础校验和数据库�Q�因为散列校验和的长度很��，它们可以方便的被存放在容量很��的存储介质上。此后，可以定期或根据需要，再次计算文�g�pȝ��的校验和�Q�一旦发��C��原来保存的值有不匹配，说明该文件已�l�被非法修改�Q�或者是被病毒感染，或者被木马�E�序替代。TripWire��提供了一个此�c�d��用的典型例子�?/p>

更完��的�Ҏ��是��?MAC"�?MAC" 是一个与Hash密切相关的名词，即信息鉴权码(Message Authority Code)。它是与密钥相关的Hash��|��必须拥有该密钥才能检验该Hash倹{��文件系�l�的数字指纹也许会被保存在不可信�ȝ��介质上，只对拥有该密钥者提供可鉴别性。�ƈ且在文�g的数字指�UҎ��可能需要被修改的情况下�Q�只有密钥的拥有者可以计��出新的散列��|��而企囄��坏文件完整性者却不能得逞�?/p>

2) 数字�{�֐�
Hash ��法也是��C��密码体系中的一个重要组成部分。由于非对称��法的运��速度较慢�Q�所以在数字�{�֐�协议中，单向散列函数扮演了一个重要的角色�?/p>

在这�U�签名协议中�Q�双方必��M��先协商好双方都支持的Hash函数和签名算法�?/p>

�{�֐�方先对该数据文�g�q�行计算其散列��|��然后再对很短的散列值结�?-如Md5�?6个字节，SHA1�?0字节�Q�用非对�U�算法进行数字签名操作。对方在验证�{�֐��Ӟ��也是先对该数据文件进行计��其散列��|��然后再用非对�U�算法验证数字签名�?/p>

�?Hash ��|��又称"数字摘要"�q�行数字�{�֐��Q�在�l�计上可以认��Z��Ҏ��件本�w�进行数字签名是�{�效的。而且�q�样的协议还有其他的优点�Q?/p>

首先�Q�数据文件本�w�可以同它的散列值分开保存�Q�签名验证也可以��q��数据文�g本��n的存在而进行�?/p>

再者，有些情况下签名密钥可能与解密密钥是同一个，也就是说�Q�如果对一个数据文件签名，与对其进行非对称的解密操作是相同的操作，�q�是相当危险的，恶意的破坏者可能将一个试��N��你将其解密的文�g�Q�充当一个要求你�{�֐�的文件发送给你。因此，在对��M��数据文�g�q�行数字�{�֐��Ӟ��只有对其Hash��D��行签名才是安全的�?/p>

3) 鉴权协议
如下的鉴权协议又被称�?挑战--认证模式�Q�在传输信道是可被侦听，但不可被��改的情况下�Q�这是一�U�简单而安全的�Ҏ��?/p>

需要鉴权的一方，向将被鉴权的一方发送随��Z��Q?#8220;挑战”�Q�，被鉴权方��该随机串和自己的鉴权口令字一赯��?Hash �q�算后，�q�还鉴权方，鉴权方将收到的Hash��g��在己端用该随��Z��和对方的鉴权口��o字进�?Hash �q�算的结果相比较�Q?#8220;认证”�Q�，如相同，则可在统计上认�ؓ�Ҏ��拥有该口令字�Q�即通过鉴权�?/p>

POP3协议中就有这一应用的典型例子：

S: +OK POP3 server ready <1896.697170952@dbc.mtview.ca.us>
C: APOP mrose c4c9334bac560ecc979e58001b3e22fb
S: +OK maildrop has 1 message (369 octets)
在上面的一�D�POP3协议会话中，双方都共享的对称密钥�Q�鉴权口令字�Q�是tanstaaf�Q�服务器发出的挑战是<1896.697170952@dbc.mtview.ca.us>�Q�客��L��Ҏ��战的应答是MD5("<1896.697170952@dbc.mtview.ca.us>tanstaaf") = c4c9334bac560ecc979e58001b3e22fb�Q�这个正��的应答使其通过了认证�?/p>

散列��法长期以来一直在计算机科学中大量应用�Q�随着��C��密码学的发展�Q�单向散列函数已�l�成��Z��息安全领域中一个重要的�l�构模块�Q�我们有理由深入研究其设计理论和应用�Ҏ��?/p>

eircQ 2010-12-02 23:08 发表评论

C++随机数生成方法（转蝲)

eircQ — Thu, 02 Dec 2010 00:42:00 GMT

原文 http://www.cnblogs.com/finallyliuyu/archive/2010/10/11/1848130.html

一、C++中不能��用random()函数

==================================================================================

本文由青村֎�创�ƈ依GPL-V2及其后箋版本发放�Q��{载请注明出处且应包含本行声明�?/p>

C++中常用rand()函数生成随机敎ͼ�但严格意义上来讲生成的只是伪随机敎ͼ�pseudo-random integral number�Q�。生成随机数旉��要我们指定一个种子，如果在程序内循环�Q�那么下一�ơ生成随机数时调用上一�ơ的�l�果作�ؓ�U�子。但如果分两�ơ执行程序，那么�? 于种子相同，生成�?#8220;随机�?#8221;也是相同的�?/p>

在工�E�应用时�Q�我们一般将�pȝ��当前旉��(Unix旉��)作�ؓ�U�子�Q�这��L��成的随机数更接近于实际意义上的随机数。给一下例�E�如下：

#include
#include
#include
using namespace std;

int main()
{
    double random(double,double);
    srand(unsigned(time(0)));
    for(int icnt = 0; icnt != 10; ++icnt)
        cout << "No." << icnt+1 << ": " << int(random(0,10))<< endl;
    return 0;
}

double random(double start, double end)
{
return start+(end-start)*rand()/(RAND_MAX + 1.0);
}
/* �q�行�l�果
* No.1: 3
* No.2: 9
* No.3: 0
* No.4: 9
* No.5: 5
* No.6: 6
* No.7: 9
* No.8: 2
* No.9: 9
* No.10: 6
*/
利用�q�种�Ҏ��能不能得到完全意义上的随机数呢？��g��9有点多哦�Q�却没有1,4,7�Q�！我们来做一个概率实验，生成1000万个随机敎ͼ��?-9�q?0个数出现的频率是不是大致相同的。程序如下：
#include
#include
#include
#include
using namespace std;

int main()
{
    double random(double,double);
    int a[10] = {0};
    const int Gen_max = 10000000;
    srand(unsigned(time(0)));

    for(int icnt = 0; icnt != Gen_max; ++icnt)
        switch(int(random(0,10)))
        {
        case 0: a[0]++; break;
        case 1: a[1]++; break;
        case 2: a[2]++; break;
        case 3: a[3]++; break;
        case 4: a[4]++; break;
        case 5: a[5]++; break;
        case 6: a[6]++; break;
        case 7: a[7]++; break;
        case 8: a[8]++; break;
        case 9: a[9]++; break;
        default: cerr << "Error!" << endl; exit(-1);
        }

    for(int icnt = 0; icnt != 10; ++icnt)
        cout << icnt << ": " << setw(6) << setiosflags(ios::fixed) << setprecision(2) << double(a[icnt])/Gen_max*100 << "%" << endl;

    return 0;
}

double random(double start, double end)
{
    return start+(end-start)*rand()/(RAND_MAX + 1.0);
}
/* �q�行�l�果
* 0: 10.01%
* 1:   9.99%
* 2:   9.99%
* 3:   9.99%
* 4:   9.98%
* 5: 10.01%
* 6: 10.02%
* 7: 10.01%
* 8: 10.01%
* 9:   9.99%
*/
可知用这�U�方法得到的随机数是满��l�计规律的�?/p>

另：在Linux下利用GCC�~�译�E�序�Q�即使我执行�?000000�ơ运��，是否��random函数定义了inline函数��g��对程序没有�Q何媄响，有理��q��信，GCC已经为我们做了优化。但是冥冥之中我又记得要做inline优化得加O3才行...

不行�Q�于是我们把循环�ơ数改�ؓ10亿次�Q�用time命��o查看执行旉��Q?br>chinsung@gentoo ~/workspace/test/Debug $ time ./test
0: 10.00%
1: 10.00%
2: 10.00%
3: 10.00%
4: 10.00%
5: 10.00%
6: 10.00%
7: 10.00%
8: 10.00%
9: 10.00%

real    2m7.768s
user    2m4.405s
sys     0m0.038s
chinsung@gentoo ~/workspace/test/Debug $ time ./test
0: 10.00%
1: 10.00%
2: 10.00%
3: 10.00%
4: 10.00%
5: 10.00%
6: 10.00%
7: 10.00%
8: 10.00%
9: 10.00%

real    2m7.269s
user    2m4.077s
sys     0m0.025s

前一�ơ�ؓ�q�行inline优化的情形，后一�ơ�ؓ没有作inline优化的情形，两次�l�果相差不大�Q�甚臛_��Ҏ��标后者还要好一些，不知是何�~�由...

=================================================================================

     random函数不是ANSI C标准�Q�不能在gcc,vc�{�编译器下编译通过�? 可改用C++下的rand函数来实现�?nbsp;    1、C++标准函数库提供一随机数生成器rand�Q�返�?�Q�RAND_MAX之间均匀分布的伪随机整数�? RAND_MAX必须臛_��?2767。rand()函数不接受参敎ͼ�默认�?为种子（卌��v始��|��? 随机数生成器��L��以相同的�U�子开始，所以�Ş成的伪随机数列也相同�Q�失��M��随机意义。（但这样便于程序调试）
      2、C++中另一函数srand�Q�）�Q�可以指定不同的敎ͼ�无符��h��数变元）为种子。但是如果种子相同，伪随机数列也相同。一个办法是让用戯��入种子，但是仍然不理惟�?
     3�?比较理想的是用变化的敎ͼ�比如旉��来作为随机数生成器的�U�子�?time的值每时每刻都不同。所以种子不同，所以，产生的随机数也不同�?
// C++随机函数�Q�VC program�Q?
#include
#include
#include
using namespace std;
#define MAX 100
int main(int argc, char* argv[])
{        srand( (unsigned)time( NULL ) );//srand()函数产生一个以当前旉��开始的随机�U�子.应该攑֜�for�{��@环语句前�?不然要很长时间等�?
　　 for (int i=0;i<10;i++)
　　 cout<　　 return 0;
}
二、rand()的用�?
     rand()不需要参敎ͼ�它会�q�回一个从0到最大随机数的�Q意整敎ͼ�最大随机数的大��通常是固定的一个大整数�?�q�样�Q�如果你要��?~10�?0个整敎ͼ�可以表达为：
　　int N = rand() % 11;
     �q�样�Q�N的值就是一�?~10的随机数�Q�如果要产生1~10�Q�则是这��P��
　　int N = 1 + rand() % 10;
　　�ȝ��来说�Q�可以表�C�Zؓ�Q?
　　a + rand() % n
     其中的a是�v始��|��n是整数的范围�?　　a + rand() % (b-a+1) ��p��C�　ａ～ｂ之间的一个随机数若要0~1的小敎ͼ�则可以先取得0~10的整敎ͼ�然后均除�?0卛_��得到随机到十分位�?0个随机小敎ͼ�若要得到随机到百分位的随机小敎ͼ�则需要先得到0~100�?0个整敎ͼ�然后均除�?00�Q�其它情况依此类推�?
     通常rand()产生的随机数在每�ơ运行的时候都是与上一�ơ相同的�Q�这是有意这栯��计的�Q�是��Z��便于�E�序的调试。若要��生每�ơ不同的随机敎ͼ�可以使用srand( seed )函数�q�行随机化，随着seed的不同，��p��够��生不同的随机数�?
     如大家所��_��q�可以包含time.h头文�Ӟ��然后使用srand(time(0))来��用当前时间��随机数发生器随机化，�q�样��可以保证每两次�q�行时可以得��C��同的随机数序�?只要两次�q�行的间隔超�q?�U?�?/p>

eircQ 2010-12-02 08:42 发表评论

trie�?-详解

eircQ — Fri, 26 Nov 2010 01:48:00 GMT

文章作者：yx_th000 文章来源�Q?/span>Cherish_yimi (http://www.cnblogs.com/cherish_yimi/) 转蝲��h��明，谢谢合作�?br>关键词：trie trie�?数据�l�构

前几天学习了�q�查集和trie树，�q�里�ȝ��一下trie�?br> 本文讨论一��|��单的trie树，��Z��英文26个字母组成的字符�Ԍ��讨论插入字符丌Ӏ�判断前�~�是否存在、查扑֭��W�串�{�基本操作；至于trie树的删除单个节点实在是少见，故在此不做详解�?/span>

l Trie原理

Trie的核心思想是空间换旉��。利用字�W�串的公共前�~�来降低查询时间的开销以达到提高效率的目的�?/span>

l Trie性质

好多��trie的根节点不包含�Q何字�W�信息，我所习惯的trie根节点却是包含信息的�Q�而且认�ؓ�q�样也方便，下面说一下它的性质 (��Z��本文所讨论的简单trie�?

1. 字符的种数决定每个节点的出度�Q�即branch数组(�I�间换时间思想)

2. branch数组的下标代表字�W�相对于a的相对位�|?/span>

3. 采用标记的方法确定是否�ؓ字符丌Ӏ?/span>

4. 插入、查扄��复杂度均为O(len),len为字�W�串长度

l Trie的示意图

如图所�C�，该trie树存有abc、d、da、dda四个字符�Ԍ��如果是字�W�串会在节点的尾部进行标记。没有后�l�字�W�的branch分支指向NULL

l TrieTrie的优点�D�?/span>

已知n个由��写字母构成的��^均长度�ؓ10的单�?判断其中是否存在某个串�ؓ另一个串的前�~�子串。下面对�?�U�方法：

1. 最�Ҏ��惛_��的：即从字符串集中从头往后搜�Q�看每个字符串是否�ؓ字符串集中某个字�W�串的前�~��Q�复杂度为O(n^2)�?/span>

2. 使用hash�Q�我们用hash存下所有字�W�串的所有的前缀子串。徏立存有子串hash的复杂度为O(n*len)。查询的复杂度�ؓO(n)* O(1)= O(n)�?/span>

3. �? 用trie�Q�因为当查询如字�W�串abc是否为某个字�W�串的前�~��Ӟ��昄��以b,c,d....�{�不是以a开头的字符串就不用查找了。所以徏立trie的复�? 度�ؓO(n*len)�Q�而徏�?查询在trie中是可以同时执行的，建立的过�E�也��可以成为查询的�q�程�Q�hash��׃��能实现这个功能。所以�ȝ��复杂度�ؓ O(n*len)�Q�实际查询的复杂度只是O(len)�?br>

解释一�? hash��Z��么不能将建立与查询同时执行，例如有串�Q?11�Q?11456输入�Q�如果要同时执行建立与查询，�q�程��是查询911�Q�没有，然后存入9�? 91�?11�Q�查�?11456�Q�没有然后存�?114�?1145�?11456�Q�而程序没有记忆功能，�q�不知道911在输入数据中出现�q�。所以用 hash必须先存入所有子�Ԍ��然后for循环查询�?/span>

而trie树便�? 以，存入911后，已经记录911为出现的字符�Ԍ��在存�?11456的过�E�中��p��发现而输出答案；倒过来亦可以�Q�先存入911456�Q�在存入911�Ӟ�� 当指针指向最后一�?�Ӟ��E�序会发现这�?已经存在�Q�说�?11必定是某个字�W�串的前�~��Q�该思想是我在做pku上的3630中发现的�Q�详见本文配套的“�? 门练�?#8221;�?/span>

l Trie的简单实�?插入、查�?

1
2#include <iostream>
3using namespace std;
4
5const int branchNum = 26; //声明帔R��
6int i;
7
8struct Trie_node
9{
10    bool isStr; //记录此处是否构成一个串�?/span>
11    Trie_node *next[branchNum];//指向各个子树的指�?下标0-25代表26字符
12    Trie_node():isStr(false)
13    {
14        memset(next,NULL,sizeof(next));
15    }
16};
17
18class Trie
19{
20public:
21    Trie();
22    void insert(const char* word);
23    bool search(char* word);
24    void deleteTrie(Trie_node *root);
25private:
26    Trie_node* root;
27};
28
29Trie::Trie()
30{
31    root = new Trie_node();
32}
33
34void Trie::insert(const char* word)
35{
36    Trie_node *location = root;
37    while(*word)
38    {
39        if(location->next[*word-'a'] == NULL)//不存在则建立
40        {
41            Trie_node *tmp = new Trie_node();
42            location->next[*word-'a'] = tmp;
43        }
44        location = location->next[*word-'a']; //每插入一步，相当于有一个新串经�q�，指针要向下移�?/span>
45        word++;
46    }
47    location->isStr = true; //到达��N��,标记一个串
48}
49
50bool Trie::search(char *word)
51{
52    Trie_node *location = root;
53    while(*word && location)
54    {
55        location = location->next[*word-'a'];
56        word++;
57    }
58    return(location!=NULL && location->isStr);
59}
60
61void Trie::deleteTrie(Trie_node *root)
62{
63    for(i = 0; i < branchNum; i++)
64    {
65        if(root->next[i] != NULL)
66        {
67            deleteTrie(root->next[i]);
68        }
69    }
70    delete root;
71}
72
73void main() //��单测�?/span>
74{
75    Trie t;
76    t.insert("a");
77    t.insert("abandon");
78    char * c = "abandoned";
79    t.insert(c);
80    t.insert("abashed");
81    if(t.search("abashed"))
82        printf("true\n");
83}

eircQ 2010-11-26 09:48 发表评论

eircQ — Mon, 23 Aug 2010 06:42:00 GMT

;***************************************************************************************************************
;       strlen returns the length of a null-terminated string in bytes, not including the null byte itself.
;       Algorithm:
;       int strlen (const char * str)
;       {
;           int length = 0;
;
;           while( *str++ )
;                   ++length;
;
;           return( length );
;       }

;***************************************************************************************************************
;       memcpy() copies a source memory buffer to a destination buffer.
;       Overlapping buffers are not treated specially, so propogation may occur.
;       Algorithm:
;       void * memcpy(void * dst, void * src, size_t count)
;       {
;               void * ret = dst;
;               /*
;                * copy from lower addresses to higher addresses
;                */
;               while (count--)
;                       *dst++ = *src++;
;
;               return(ret);
;       }

;***************************************************************************************************************
;       memmove() copies a source memory buffer to a destination memory buffer.
;       This routine recognize overlapping buffers to avoid propogation.
;       For cases where propogation is not a problem, memcpy() can be used.
;       Algorithm:
;       void * memmove(void * dst, void * src, size_t count)
;       {
;               void * ret = dst;
;               if (dst <= src || dst >= (src + count)) {
;                       /*
;                        * Non-Overlapping Buffers
;                        * copy from lower addresses to higher addresses
;                        */
;                       while (count--)
;                               *dst++ = *src++;
;                       }
;               else {
;                       /*
;                        * Overlapping Buffers
;                        * copy from higher addresses to lower addresses
;                        */
;                       dst += count - 1;
;                       src += count - 1;
;
;                       while (count--)
;                               *dst-- = *src--;
;                       }
;
;               return(ret);
;       }

;***************************************************************************************************************
int strcmp(const char *str1,const char *str2)
{
while((*str1==*str2)&&(*str1))
{
str1++;
str2++;
}
if((*str1==*str2)&&(!*str1)) //Same strings
return 0;
else if((*str1)&&(!*str2)) //Same but str1 longer
return -1;
else if((*str2)&&(!*str1)) //Same but str2 longer
return 1;
else
return((*str1>*str2)?-1:1);
}

;***************************************************************************************************************
char *strstr1(const char *str1, const char *str2)
{
     char *cp = (char *)str1; //type transfer
     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;
      else
       cp++;
     }
     return NULL;
}

;***************************************************************************************************************
*char *_itoa, *_ltoa, *_ultoa(val, buf, radix) - convert binary int to ASCII string
static void __cdecl xtoa (unsigned long val, char *buf, unsigned radix, int is_neg )
{
        char *p;                /* pointer to traverse string */
        char *firstdig;         /* pointer to first digit */
        char temp;              /* temp char */
        unsigned digval;        /* value of digit */

p = buf;

        if (is_neg) {
            /* negative, so output '-' and negate */
            *p++ = '-';
            val = (unsigned long)(-(long)val);
        }

firstdig = p; /* save pointer to first digit */

        do {
            digval = (unsigned) (val % radix);
            val /= radix;       /* get next digit */

            /* convert to ascii and store */
            if (digval > 9)
                *p++ = (char) (digval - 10 + 'a'); /* a letter */
            else
                *p++ = (char) (digval + '0');       /* a digit */
        } while (val > 0);

/* We now have the digit of the number in the buffer, but in reverse
order. Thus we reverse them now. */

*p-- = '\0'; /* terminate string; p points to last digit */

        do {
            temp = *p;
            *p = *firstdig;
            *firstdig = temp;   /* swap *p and *firstdig */
            --p;
            ++firstdig;         /* advance to next two digits */
        } while (firstdig < p); /* repeat until halfway */
}
char * __cdecl _itoa ( int val, char *buf, int radix )
{
        if (radix == 10 && val < 0)
            xtoa((unsigned long)val, buf, radix, 1);
        else
            xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
        return buf;
}
char * __cdecl _ltoa ( long val, char *buf, int radix )
{
        xtoa((unsigned long)val, buf, radix, (radix == 10 && val < 0));
        return buf;
}

;***************************************************************************************************************
*long atol(char *nptr) - Convert string to long. Overflow is not detected.
long __cdecl _tstol(const _TCHAR *nptr )
{
        int c;              /* current char */
        long total;         /* current total */
        int sign;           /* if '-', then negative, otherwise positive */
        while ( _istspace((int)(_TUCHAR)*nptr) )
                 ++nptr; /* skip whitespace */

        c = (int)(_TUCHAR)*nptr++;
        sign = c;           /* save sign indication */
        if (c == _T('-') || c == _T('+'))
            c = (int)(_TUCHAR)*nptr++;    /* skip sign */

total = 0;

        while ( (c = _tchartodigit(c)) != -1 ) {
            total = 10 * total + c;     /* accumulate digit */
            c = (_TUCHAR)*nptr++;    /* get next char */
        }

        if (sign == '-')
            return -total;
        else
            return total;   /* return result, negated if necessary */
}
int __cdecl _tstoi( const _TCHAR *nptr )
{
        return (int)_tstol(nptr);
}

;***************************************************************************************************************
;performs a byteswap on an unsigned integer.
unsigned short __cdecl _byteswap_ushort(unsigned short i)
{
    unsigned short j;
    j = (i << 8) ;
    j += (i >> 8) ;
    return j;
}
unsigned long __cdecl _byteswap_ulong(unsigned long i)
{
    unsigned int j;
    j = (i << 24);
    j += (i << 8) & 0x00FF0000;
    j += (i >> 8) & 0x0000FF00;
    j += (i >> 24);
    return j;
}

;***************************************************************************************************************
*char *bsearch() - do a binary search on an array
*Entry:
*       const char *key    - key to search for const char *base   - base of sorted array to search unsigned int num   - number of *elements in array unsigned int width - number of bytes per element int (*compare)()   - pointer to function that compares two
*array elements, returning neg when #1 < #2, pos when #1 > #2, and 0 when they are equal. Function is passed pointers to two
*array elements.
*Exit:
*       if key is found: returns pointer to occurrence of key in array
*       if key is not found:returns NULL

void * __cdecl bsearch ( REG4 const void *key, const void *base, size_t num, size_t width, int (__cdecl *compare)(const void *, const void *)   )
{
        REG1 char *lo = (char *)base;
        REG2 char *hi = (char *)base + (num - 1) * width;
        REG3 char *mid;
        size_t half;
        int result;

        while (lo <= hi)
                if (half = num / 2)
                {
                        mid = lo + (num & 1 ? half : (half - 1)) * width;
                        if (!(result = (*compare)(key,mid)))
                                return(mid);
                        else if (result < 0)
                        {
                                hi = mid - width;
                                num = num & 1 ? half : half-1;
                        }
                        else    {
                                lo = mid + width;
                                num = half;
                        }
                }
                else if (num)
                        return((*compare)(key,lo) ? NULL : lo);
                else
                        break;

        return(NULL);
}

;***************************************************************************************************************
void __cdecl _tmakepath (register _TSCHAR *path, const _TSCHAR *drive, const _TSCHAR *dir,
const _TSCHAR *fname, const _TSCHAR *ext )
{
     register const _TSCHAR *p;
     /* copy drive */
     if (drive && *drive) {
                *path++ = *drive;
                *path++ = _T(':');
        }

        /* copy dir */
        if ((p = dir) && *p) {
                do {
                        *path++ = *p++;
                }while (*p);
                if (*(p-1) != _T('/') && *(p-1) != _T('\\')) {
                        *path++ = _T('\\');
                }
        }

        /* copy fname */
        if (p = fname) {
                while (*p) {
                        *path++ = *p++;
                }
        }

        /* copy ext, including 0-terminator - check to see if a '.' needs to be inserted. */
        if (p = ext) {
                if (*p && *p != _T('.')) {
                        *path++ = _T('.');
                }
                while (*path++ = *p++)
                        ;
        }
        else {
                /* better add the 0-terminator */
                *path = _T('\0');
        }
}

eircQ 2010-08-23 14:42 发表评论

eircQ — Wed, 18 Aug 2010 03:26:00 GMT

   1. /***********************************/
   2. /* 功能�Q�求两个单链表是否相交和交点*/
   3. /* 转蝲自CSDN博客                  * /
   4. /* 日期�Q?010/03/29                */
   5. /***********************************/
   6.
   7.
   8. Node* find(Node* head1,Node* head2)
   9. {
10.      Node *p1=head1,*p2=head2;
11.     int m=0,n=0;
12.     while(p1)//O(len1)
13.      {
14.          p1=p1->next;
15.          m++;
16.      }
17.     while(p2)//O(len2)
18.      {
19.          p2=p2->next;
20.          n++;
21.      }
22.      p1=head1;
23.      p2=head2;
24.
25.     if(m>n)
26.      {
27.         for(i=0;i 28.              p1=p1->next;
29.      }
30.     else
31.      {
32.         for(i=0;i 33.                p2=p2->next;
34.      }//O(abs(len1-len2))
35.     while(p1!=p2)
36.      {
37.          p1=p1->next;
38.          p2=p2->next;
39.      }//O(min(len1,len2))
40.     return p1;
41. }

eircQ 2010-08-18 11:26 发表评论

c与汇�~�，以及嵌入式工�E�师应注意的问题

eircQ — Sun, 25 Jul 2010 03:43:00 GMT

c与汇�~�，以及嵌入式工�E�师应注意的问题

人生哲理与经�?/a> 2007-07-25 13:31:04 阅读41 评论1 字号�Q?span class="ul sep fc04">�?/span>�?/span>��?/span>

　汇编和c同样重要�Q�相互配合，�~�Z��不可�Q?

　　汇编的重要性：

�?帮助你从�Ҏ��上彻底和完全了解芯片的结构和性能�Q�以及工作原理，如何使用�?
�?在小的芯片上实现��的�pȝ��?
�?�pȝ��的调试。尽��你使用了高�U�语�a��Q�在调试中可以帮助你了解C代码的性能和特点，甚至扑ֈ�使用开发��^台本�w�的BUG�?
�?�~�写时序要求严格的代码，实现一些高�U�语�a�不易实现的功能�?

　　��出版的AVR128的书里面�Q�第五章中主使用C作�ؓ�pȝ��开发设计语�a��Q�这是因为M128的速度高，内部�?K的RAM�Q?28KFLASH�Q? 适合于实现比较高�U�的应用�Q�所以采用C语言作�ؓ�pȝ��开发的设计语言。但作�ؓ开发工�E�师来讲�Q�熟悉M128的结构和应用原理�Q�基本掌握它的汇�~�语�a�是必要的基础�?

　　从目前的技术和应用发展来看�Q�对��g工程师的要求��来��高。以我的观点�Q�作为单片机和嵌入式�pȝ��开发真正的高手�Q�应具备以下几个斚w��的综合能力：

�?��g。模拟、数字电路的雄厚基础�Q�了解跟�t�现在市��Z��的各�U�元器�g的应用和发展�Q�能够进行可靠、完善的电�\设计以及PCB的设计�?
�? 软�g。不仅需要精通汇�~�语�a��Q�也要精通C语言�Q�要有好的单片机�pȝ��E�序设计理念和能力，学校中学的那些分支结构、��@环结构等基本原理�q�远不够�Q�要有基本的数据�l�构的知识。否则你如何设计实现USB HOST读U盘的接口�Q�如何实现嵌入式WEB�pȝ��Q�以及如何��用真正了解和使用RTOS�Q?
�?具备计算机网�l�和数字通信的基��知识�Q�从�Ҏ��上熟悉和了解各种协议的构造和实现�Q�如�Q�UART、RS232、SPI、I2C、USB、IEEE802、TCP/IP�{��?
�?计算机应用的高手�?
�?熟练阅读英文资料�?
�?热爱和喜�Ƣ电子技术，具备刻苦�_��、踏�t�实实，不弄虚作假，不��Q�w�。多动手�Q�勤实践。有强烈的专业和�ȝ��_��。最后一条最重要�Q?

eircQ 2010-07-25 11:43 发表评论

亚洲免费观看高清在线观看 ,亚洲美女啪啪,亚洲欧美日韩一区

各种排序���法介绍

Hash ���法及其应用(�?

C++随机数生成方法（转蝲)

trie�?-详解

c与汇�~�，以及嵌入式工�E�师应注意的问题

c与汇�~�，以及嵌入式工�E�师应注意的问题

各种排序��法介绍

Hash ��法及其应用(�?