欧美大片免费久久精品三p ,国产精品久久久久久久电影 ,国产精品99久久久久久久女警

STL 堆排序��用和体会(�?

hunter — Fri, 28 May 2010 23:37:00 GMT

STL堆排序其实就�?wbr>创徏一个二叉树(w��i)�Q�下�?wbr>是几个常用函数的使用�Ҏ(gu��)��和代表的意�?br>#include
#include
#include
#include
using namespace std;

�Q?�Q�创��Z��个数�l�，�q�添加数�?br>    vector v_Arry;
    v_Arry.push_back(5);
    v_Arry.push_back(6);
    v_Arry.push_back(4);
    v_Arry.push_back(8);
    v_Arry.push_back(2);
    v_Arry.push_back(3);
    v_Arry.push_back(7);
    v_Arry.push_back(1);
    v_Arry.push_back(9);
    v_Arry.push_back(10);
    v_Arry.push_back(55);

�Q?�Q�make_heap�Q�v_Arry.begin�Q�）, v_Arry.end�Q�）, less()) //建堆�Q�其实就是徏二叉�?w��i)�?根节�Ҏ(gu��)��最大��|��其每一个节炚w��于或等于其父节点；使用greater()则相反，根节�Ҏ(gu��)��最��|��其每一个节�?wbr>都大于或�{�于其父节点

�Q?�Q�此时可以输出查看一下徏好的堆是不是一个标准的二叉�?br>我的输出�l�果是：55�Q?0�Q?�Q?�Q?�Q?wbr>3�Q?�Q?�Q?�Q?�Q?wbr>2
变成二叉�?w��i)就是如下�?br> --[endif]--> --[endif]-->

�l�果不是唯一单一定要满��父节点和子节点的大小关系�?br>�Q?�Q�pop_heap(v_Arry.begin(), v_Arry.end());//把根节点�U�d��末尾�Q��ƈ没有删除
v_Arry.pop_back();//删除该节�?br> 此时输出�l�果�Q?0�Q?wbr>9�Q?�Q?�Q?�Q?�Q?wbr>4�Q?�Q?�Q?
二叉�?w��i)如下�?

�Q?�Q�v_Arry.push_back(55); //只是��d��数据攑ֈ�子节�?br> push_heap(v_Arry.begin(), v_Arry.end());//往二叉�?wbr>中插入数据，满��子节点小于等于父节点
此时输出�l�果�Q?5�Q?wbr>10�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?
二叉�?w��i)如下�?br>

�Q?�Q�sort_heap(v_Arry.begin(), v_Arry.end());//对二叉树(w��i)所有节点进行排�?br>此时输出�l�果�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?0�Q?5

�Q?�Q�find ( v_Arry.begin(), v_Arry.end()�Q?value );// 从begin到end查找value�Q�若�?wbr>不到�Q�返回end

原文地址�Q?a >http://blog.zol.com.cn/1356/article_1355249.html

hunter 2010-05-29 07:37 发表评论

�q�用计数排序�q�行基数排序

hunter — Thu, 11 Mar 2010 03:08:00 GMT

基数排序是首先按最低有效位数字�q�行排序�Q�以解决卡片排序问题�?br>重复�Ҏ(gu��)��有的d位数字都�q�行排序�Q�仅需要d遍就可以��一堆卡片进行排序�?br>�q�里又运用了基数排序的方法，所以�ȝ��旉��复杂度�ؓO(n*d)�?br>

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <cmath>
using namespace std;

void CountSort(int a[], int b[],int num,int d)   //计数排序
{
    int* c = new int[10];
    int index;
    for (int i=0;i<=9;i++)
       c[i]=0;
    int size = num;
    for (int j=0;j<size;j++)
    {
        index=a[j]%(int)pow(10.0,d)/(int)pow(10.0,d-1);
        c[index]++;
    }
    //c[i]包含�{�于i的元素个�?/span>
    for (i=1;i<=9;i++)
       c[i]=c[i]+c[i-1];
    //c[i]包含��于�{�于i的元素个�?/span>
    for (j=size-1;j>=0;j--)
    {
        index=a[j]%(int)pow(10.0,d)/(int)pow(10.0,d-1);
        b[c[index]-1]=a[j];
        c[index]--;
    }

    for (j=0;j<size;j++)    //更新一�ơ排序后的a数组
    {
        a[j]=b[j];
    }
        delete [] c;
}

void RadixSort(int a[],int b[],int d,int num)   //基数排序
{
    for(int i=1;i<=d;i++)
        CountSort(a,b,num,i);
}

void main()
{
    int num,d;
    cout<<"输入个数及位�?/span>"<<endl;
    cin>>num>>d;
    int* a = new int[num];
    int* b = new int[num];
    cout<<"排序前："<<endl;
    for(int i=0;i<num;i++)
    {
        cin>>a[i];
    }

    RadixSort(a,b,d,num);

    cout<<"排序后："<<endl;
    for (int j=0;j<num;j++)
    {
        cout<<b[j]<<endl;
    }

    delete [] a;
    delete [] b;
}

hunter 2010-03-11 11:08 发表评论

hunter — Wed, 10 Mar 2010 15:36:00 GMT

C语言中判断数据类型长度符
用法
      sizeof(�c�d��说明�W�，数组名或表达�?;
�?br>      sizeof 变量�?br>
1. 定义�Q?br>sizeof是C/C++中的一个操作符�Q�operator�Q�是也，��单的说其作用��是�q�回一个对象或者类型所占的内存字节数�?br>MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types). This keyword returns a value of type size_t.
其返回值类型�ؓsize_t�Q�在头文件stddef.h中定义。这是一个依赖于�~�译�pȝ��的��|��一般定义�ؓ
typedef unsigned int size_t;
世上�~�译器林林��L��，但作��Z��个规范，它们都会保证char、signed char和unsigned
char的sizeof��gؓ1�Q�毕竟char是我们编�E�能用的最��数据类型�?br>2. 语法�Q?br>sizeof有三�U�语法�Ş式，如下�Q?br>1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( �c�d�� );
3) sizeof object; // sizeof 对象;
所以，
int i;
sizeof( i );  // ok
sizeof i;     // ok
sizeof( int ); // ok
sizeof int;    // error
既然写法3可以用写�?代替�Q��ؓ求�Ş式统一以及减少我们大脑的负担，�W?�U�写法，忘掉它吧�Q�实际上�Q�sizeof计算对象的大��也是�{换成对对象类型的计算�Q�也��是��_��同种�c�d��的不同对象其sizeof值都是一致的。这里，对象可以�q�一步�g伸至表达式，即sizeof可以对一个表辑ּ�求��|��~�译器根据表辑ּ�的最�l�结果类型来��定大小�Q�一般不会对表达式进行计��。如�Q?br>sizeof( 2 );          // 2的类型�ؓint�Q�所以等价于 sizeof( int );
sizeof( 2 + 3.14 );   // 3.14的类型�ؓdouble�Q?也会被提升成double�c�d��Q�所以等价于 sizef(double)

也可以对一个函数调用求��|��其结果是函数�q�回�c�d��的大��，函数�q�不会被调用�Q�我们来看一个完整的例子�Q?br>char foo()
{
printf("foo() has been called.\n");
return 'a';
}
int main()
{
size_t sz = sizeof( foo() ); // foo() 的返回值类型�ؓchar�Q�所以sz = sizeof(char )�Q�foo()�q�不会被调用
printf("sizeof( foo() ) = %d\n", sz);
}
C99标准规定�Q�函数、不能确定类型的表达式以及位域（bit-field�Q�成员不能被计算sizeof��|��即下面这些写法都是错误的�Q?br>sizeof( foo );// error
void foo2() { }
sizeof( foo2() );// error
struct S
{
       unsigned int f1 : 1;
       unsigned int f2 : 5;
       unsigned int f3 : 12;
};
sizeof( S.f1 );// error
3. sizeof的常量�?br>sizeof的计��发生在�~�译时刻�Q�所以它可以被当作常量表辑ּ�使用�Q�如�Q?br>char ary[ sizeof( int ) * 10 ]; // ok
最新的C99标准规定sizeof也可以在�q�行时刻�q�行计算�Q�如下面的程序在Dev-C++中可以正��执行：
int n;
n = 10; // n动态赋�?br>char ary[n]; // C99也支持数�l�的动态定�?br>printf("%d\n", sizeof(ary)); // ok. 输出10
但在没有完全实现C99标准的编译器中就行不通了�Q�上面的代码在VC6中就通不�q�编译。所以我们最好还是认为sizeof是在�~�译期执行的�Q�这样不会带来错误，让程序的可移植性强些�?br>4. 基本数据�c�d��的sizeof
�q�里的基本数据类型指short、int、long、float、double�q�样的简单内�|�数据类型，�׃��它们都是和系�l�相关的�Q�所以在不同的系�l�下取值可能不同，�q�务必引��h��们的注意�Q�尽量不要在�q�方面给自己�E�序的移植造成�ȝ��?br>一般的�Q�在32位编译环境中�Q�sizeof(int)的取��gؓ4�?br>5. 指针变量的sizeof
学过数据�l�构的你应该知道指针是一个很重要的概念，它记录了另一个对象的地址。既然是来存攑֜�址的，那么它当然等于计��机内部地址�ȝ��的宽度。所以在32位计��机中，一个指针变量的�q�回值必定是4�Q�注意结果是以字节�ؓ单位�Q�，可以预计�Q�在��来�?4位系�l�中指针变量的sizeof�l�果�?�?br>char* pc = "abc";
int* pi;
string* ps;
char** ppc = &pc;
void (*pf)();// 函数指针
sizeof( pc ); // �l�果�?
sizeof( pi ); // �l�果�?
sizeof( ps ); // �l�果�?
sizeof( ppc ); // �l�果�?
sizeof( pf );// �l�果�?
指针变量的sizeof��g��指针所指的对象没有��M��关系�Q�正是由于所有的指针变量所占内存大��相�{�，所以MFC消息处理函数使用两个参数WPARAM、LPARAM��p��传递各�U�复杂的消息�l�构�Q��用指向结构体的指针）�?br>6. 数组的sizeof
数组的sizeof值等于数�l�所占用的内存字节数�Q�如�Q?br>char a1[] = "abc";
int a2[3];
sizeof( a1 ); // �l�果�?�Q�字�W?末尾�q�存在一个NULL�l�止�W?br>sizeof( a2 ); // �l�果�?*4=12�Q�依赖于int�Q?br>一些朋友刚开始时把sizeof当作了求数组元素的个敎ͼ�现在�Q�你应该知道�q�是不对的，那么应该怎么求数�l�元素的个数呢Easy�Q�通常有下面两�U�写法：
int c1 = sizeof( a1 ) / sizeof( char ); // 总长�?单个元素的长�?br>int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长�?�W�一个元素的长度
写到�q�里�Q�提一问，下面的c3�Q�c4值应该是多少�?br>void foo3(char a3[3])
{
int c3 = sizeof( a3 ); // c3 ==
}
void foo4(char a4[])
{
int c4 = sizeof( a4 ); // c4 ==
}
也许当你试图回答c4的值时已经意识到c3�{�错了，是的�Q�c3!=3。这里函数参数a3已不再是数组�c�d��Q�而是蜕变成指针，相当于char* a3�Q��ؓ什么仔�l�想惛_��不难明白�Q�我们调用函数foo1�Ӟ��E�序会在栈上分配一个大��ؓ3的数�l�吗不会�Q�数�l�是“传址”的，调用者只需��实参的地址传递过去，所以a3自然为指针类型（char*�Q�，c3的��g��׃ؓ4�?br>7. �l�构体的sizeof
�q�是初学者问得最多的一个问题，所以这里有必要多费点笔墨。让我们先看一个结构体�Q?br>struct S1
{
char c;
int i;
};
问sizeof(s1)�{�于多少聪明的你开始思考了�Q�char�?个字节，int�?个字节，那么加�v来就应该�?。是�q�样吗你在你机器上试�q�了吗也�怽�是对的，但很可能你是错的�Q�VC6中按默认讄��得到的结果�ؓ8�?br>Why��Z��么受伤的��L��?br>请不要沮丧，我们来好好琢��一下sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节敎ͼ�好吧�Q�那��p��我们来看看S1的内存分配情况：
S1 s1 = { 'a', 0xFFFFFFFF };
定义上面的变量后�Q�加上断点，�q�行�E�序�Q�观察s1所在的内存�Q�你发现了什�?br>以我的VC6.0��Z��Q�s1的地址�?x0012FF78�Q�其数据内容如下�Q?br>0012FF78: 61 CC CC CC FF FF FF FF
发现了什么怎么中间�Ҏ(gu��)��?个字节的CC看看MSDN上的说明�Q?br>When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.
原来如此�Q�这��是传说中的字节寚w��啊！一个重要的话题出现了�?br>��Z��么需要字节对齐计��机�l�成原理教导我们�q�样有助于加快计��机的取数速度�Q�否则就得多花指令周期了。�ؓ此，�~�译器默认会对结构体�q�行处理�Q�实际上其它地方的数据变量也是如此）�Q�让宽度�?的基本数据类型（short�{�）都位于能�?整除的地址上，让宽度�ؓ4的基本数据类型（int�{�）都位于能�?整除的地址上，以此�c�L��。这��P��两个��C��间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了�?br>让我们交换一下S1中char与int的位�|�：
struct S2
{
int i;
char c;
};
看看sizeof(S2)的结果�ؓ多少�Q�怎么�q�是8再看看内存，原来成员c后面仍然�?个填充字节，�q�又是�ؓ什么啊别着急，下面�ȝ��规律�?br>字节寚w��的细节和�~�译器实现相养I��但一般而言�Q�满��三个准则：
1) �l�构体变量的首地址能够被其最宽基本类型成员的大小所整除�Q?br>2) �l�构体每个成员相对于�l�构体首地址的偏�U�量�Q�offset�Q�都是成员大��的整数倍，如有需要编译器会在成员之间加上填充字节�Q�internal adding�Q�；
3) �l�构体的��d��ؓ�l�构体最宽基本类型成员大��的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding�Q��?br>对于上面的准则，有几炚w��要说明：
1) 前面不是说结构体成员的地址是其大小的整数倍，怎么又说到偏�U�量了呢因�ؓ有了�W?点存在，所以我们就可以只考虑成员的偏�U�量�Q�这��h��考�v来简单。想想�ؓ什么�?br>�l�构体某个成员相对于�l�构体首地址的偏�U�量可以通过宏offsetof()来获得，�q�个宏也在stddef.h中定义，如下�Q?br>   #define offsetof(s,m) (size_t)&(((s *)0)->m)
例如�Q�想要获得S2中c的偏�U�量�Q�方法�ؓ
size_t pos = offsetof(S2, c);// pos�{�于4
2) 基本�c�d��是指前面提到的像char、short、int、float、double�q�样的内�|�数据类型，�q�里所说的“数据宽度”��是指其sizeof的大��。由于结构体的成员可以是复合�c�d��Q�比如另外一个结构体�Q�所以在��L��最宽基本类型成员时�Q�应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合�c�d��作�ؓ整体看待�?br>�q�里叙述��h��有点拗口�Q�思考�v来也有点挠头�Q�还是让我们看看例子吧（具体数��g��以VC6��Z��Q�以后不再说明）�Q?br>struct S3
{
char c1;
S1 s;
char c2;
};
S1的最宽简单成员的�c�d��为int�Q�S3在考虑最宽简单类型成员时是将S1“打散”看的�Q�所以S3的最宽简单类型�ؓint�Q�这��P��通过S3定义的变量，其存储空间首地址需要被4整除�Q�整个sizeof(S3)的��g��应该�?整除�?br>c1的偏�U�量�?�Q�s的偏�U�量呢这时s是一个整体，它作为结构体变量也满��_��面三个准则，所以其大小�?�Q�偏�U�量�?�Q�c1与s之间侉K��?个填充字节，而c2与s之间��׃��需要了�Q�所以c2的偏�U�量�?2�Q�算上c2的大��ؓ13�Q?3是不能被4整除的，�q�样末尾�q�得补上3个填充字节。最后得到sizeof(S3)的��gؓ16�?br>通过上面的叙�q�ͼ�我们可以得到一个公式：
�l�构体的大小�{�于最后一个成员的偏移量加上其大小再加上末��填充字节数目�Q�即�Q?br>sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( trailing padding )
到这里，朋友们应该对�l�构体的sizeof有了一个全新的认识�Q�但不要高兴得太早，有一个媄响sizeof的重要参量还未被提及�Q�那便是�~�译器的pack指��o。它是用来调整结构体寚w��方式的，不同�~�译器名�U�和用法略有不同�Q�VC6中通过#pragma pack实现�Q�也可以直接修改/Zp�~�译开兟�?pragma pack的基本用法�ؓ�Q?pragma pack( n )�Q�n为字节对齐数�Q�其取��gؓ1�?�?�?�?6�Q�默认是8�Q�如果这个值比�l�构体成员的sizeof值小�Q�那�?br>该成员的偏移量应该以此��gؓ准，��x��_��l�构体成员的偏移量应该取二者的最��|��
公式如下�Q?br>offsetof( item ) = min( n, sizeof( item ) )
再看�C�Z��Q?br>#pragma pack(push)   // ��当前pack讄��压栈保存
#pragma pack(2) // 必须在结构体定义之前使用
struct S1
{
char c;
int i;
};
struct S3
{
char c1;
S1 s;
char c2;
};
#pragma pack(pop) // 恢复先前的pack讄��
计算sizeof(S1)�Ӟ��min(2, sizeof(i))的��gؓ2�Q�所以i的偏�U�量�?�Q�加上sizeof(i)�{�于6�Q�能够被2整除�Q�所以整个S1的大��ؓ6�?br>同样�Q�对于sizeof(S3)�Q�s的偏�U�量�?�Q�c2的偏�U�量�?�Q�加上sizeof(c2)�{�于9�Q�不能被2整除�Q�添加一个填充字节，所以sizeof(S3)�{�于10�?br>
现在�Q�朋友们可以��L��的出一口气了，:)
�q�有一点要注意�Q?#8220;�I�结构体”�Q�不含数据成员）的大��不�?�Q�而是1。试想一�?#8220;不占�I�间”的变量如何被取地址、两个不同的“�I�结构体”变量又如何得以区分呢于是�Q?#8220;�I�结构体”变量也得被存储，�q�样�~�译器也��只能�ؓ其分配一个字节的�I�间用于占位了。如下：
struct S5 { };
sizeof( S5 ); // �l�果�?
8. 含位域结构体的sizeof
前面已经说过�Q�位域成员不能单独被取sizeof��|��我们�q�里要讨论的是含有位域的�l�构体的sizeof�Q�只是考虑到其�Ҏ(gu��)��性而将其专门列了出来�?br>C99规定int、unsigned int和bool可以作�ؓ位域�c�d��Q�但�~�译器几乎都�Ҏ(gu��)��作了扩展�Q�允许其它类型类型的存在。��用位域的主要目的是压�~�存储，其大致规则�ؓ�Q?br>1) 如果盔R��位域字段的类型相同，且其位宽之和��于�c�d��的sizeof大小�Q�则后面的字�D�将紧邻前一个字�D�存储，直到不能容纳为止�Q?br>2) 如果盔R��位域字段的类型相同，但其位宽之和大于�c�d��的sizeof大小�Q�则后面的字�D�将从新的存储单元开始，其偏�U�量为其�c�d��大小的整数倍；
3) 如果盔R��的位域字�D늚��c�d��不同�Q�则各编译器的具体实现有差异�Q�VC6采取不压�~�方式，Dev-C++采取压羃方式�Q?br>4) 如果位域字段之间�I�插着非位域字�D�，则不�q�行压羃�Q?br>5) 整个�l�构体的��d��ؓ最宽基本类型成员大��的整数倍�?br>�q�是让我们来看看例子�?br>�C�Z��1�Q?br>struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
其内存布局为：
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
0 3 7 8 1316
位域�c�d��为char�Q�第1个字节仅能容�U�下f1和f2�Q�所以f2被压�~�到�W?个字节中�Q�而f3�?br>能从下一个字节开始。因此sizeof(BF1)的结果�ؓ2�?br>�C�Z��2�Q?br>struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
�׃��盔R��位域�c�d��不同�Q�在VC6中其sizeof�?�Q�在Dev-C++中�ؓ2�?br>�C�Z��3�Q?br>struct BF3
{
char f1 : 3;
char f2;
char f3 : 5;
};
非位域字�D늩�插在其中�Q�不会��生压�~�，在VC6和Dev-C++中得到的大小均�ؓ3�?br>9. 联合体的sizeof
�l�构体在内存�l�织上是��序式的�Q�联合体则是重叠式，各成员共享一�D�内存，所以整个联合体的sizeof也就是每个成员sizeof的最大倹{��结构体的成员也可以是复合类型，�q�里�Q�复合类型成员是被作为整体考虑的�?br>所以，下面例子中，U的sizeof值等于sizeof(s)�?br>union U
{
int i;
char c;
S1 s;
};

转自�Q?a >http://blog.sina.com.cn/s/blog_5af743940100ctd9.html

hunter 2010-03-10 23:36 发表评论

计数排序

hunter — Wed, 10 Mar 2010 15:29:00 GMT

旉��复杂度�ؓO(n).
计数排序的基本思想��是�Ҏ(gu��)��一个输入元素X�Q�确定出��于X的元素个数�?br>有了�q�一信息��可以把X直接攑ֈ�它在最�l�输出数�l�中的位�|�上�?br>例如�Q�如果有17个元素小于X�Q�则X��属于第18个输��Z��|��?br>在计数排序算法的代码中，我们假定输入是个数组A[0...n-1]�Q�length[A]=n。另外还需要两个数�l�：存放排序�l�果的B[0...n-1]�Q�以及提供��(f��)时存储区的C[0...k].

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

void CountSort(int a[], int b[],int k,int num)
{
    int* c = new int[k+1];
    for (int i=0;i<=k;i++)
       c[i]=0;
    int size = num;
    for (int j=0;j<size;j++)
       c[a[j]]++;
    //c[i]包含�{�于i的元素个�?/span>
    for (i=1;i<=k;i++)
       c[i]=c[i]+c[i-1];
    //c[i]包含��于�{�于i的元素个�?/span>
    for (j=size-1;j>=0;j--)
    {
        b[c[a[j]]-1]=a[j];
        c[a[j]]--;
    }

        delete [] c;
}
void main()
{
    int num,max;
    cout<<"输入最大整数及输入个数"<<endl;
    cin>>max;
    cin>>num;
    int* a = new int[num];
    int* b = new int[num];
    cout<<"排序前："<<endl;
    for(int i=0;i<num;i++)
    {
        cin>>a[i];
        if (a[i]>max)
            i--;
    }

    CountSort(a,b,max,num);

    cout<<"排序后："<<endl;
    for (int j=0;j<num;j++)
    {
        cout<<b[j]<<endl;
    }

    delete [] a;
    delete [] b;
}

hunter 2010-03-10 23:29 发表评论

快速排序及二分查找

hunter — Tue, 09 Mar 2010 14:05:00 GMT

�l�典的快速排序和二分查找

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

int Partition(int a[],int p,int r)
{
    int ran=rand()%(r-p+1)+p;       //随即选取卫兵
    swap(a[ran],a[r]);
    int x=a[r];
    int i=p-1;
    for (int j=p;j<r;j++)
    {
        if (a[j]<=x)               //��于卫兵的��D��行对�?/span>
        {
            i++;
            swap(a[i],a[j]);
        }
    }
    swap(a[i+1],a[r]);
    return i+1;
}

void QuickSort(int a[],int p,int r)
{
    int q;
    if (p<r)
    {
        q=Partition(a,p,r);
        QuickSort(a,p,q-1);
        QuickSort(a,q+1,r);
    }
}

int BinarySearch(int a[],int min,int max,int x)
{
    int mid;
    while (min<max)
    {
        mid=min+(max-min)/2;
        if (a[mid]>=x)
            max=mid;
        else
            min=mid+1;     //若不加一可能存在无限循环的结�?/span>
    }
    if (a[min]==x)
        return min;
    else if(a[max]==x)
        return max;
    else
        return -1;
}
void main()
{
    int num;
    cin>>num;
    int* a = new int[num];
    cout<<"排序前："<<endl;
    for(int i=0;i<num;i++)
        cin>>a[i];
    QuickSort(a,0,num-1);
    cout<<"排序后："<<endl;
    for (int j=0;j<num;j++)
    {
        cout<<a[j]<<endl;
    }
    cout<<"输入要查扄��?/span>"<<endl;
    int x;
    cin>>x;
    int result=BinarySearch(a,0,num-1,x);
    if (result>=0)
        cout<<"目标位置�?"<<result+1<<endl;
    else
        cout<<"目标不在数组�?/span>"<<endl;
}

hunter 2010-03-09 22:05 发表评论

hunter — Sun, 07 Mar 2010 14:08:00 GMT

《算法导论》中典型的最大堆排序

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <vector>
using namespace std;

template<class T> void Max_Heap(T a[],int i,int size)
{
    int r = 2*i + 2;
    int l = 2*i + 1;
    int largest;
    if (l<size && a[l]>=a[i])
    {
        largest = l;
    }
    else
        largest = i;
    if (r<size && a[r] >=a[largest])
    {
        largest = r;
    }
    if (largest != i)
    {
        swap(a[largest],a[i]);
        Max_Heap(a,largest,size);
    }
}

template<class T> void Build_Max_Heap(T a[],int size)
{
    for (int i=size/2;i>=0;i--)
    {
        Max_Heap(a,i,size);
    }
}

template<class T> void HeapSort(T a[],int size)
{
    Build_Max_Heap(a,size);
    for (int i=size-1;i>=1;i--)
    {
        swap(a[i],a[0]);       //��最大数换到数组末尾
        //show(a,size);
        size--;
        Max_Heap(a,0,size);
    }
}

template<class T> void show(T a[],int size)
{
    cout<<"排序后结果�ؓ"<<endl;
    for (int i=0;i<size;i++)
    {
        cout<<a[i]<<endl;
    }
}

int main()
{
    int num;
    cin>>num;
    char* input = new char[num];
    for (int i=0;i<num;i++)
    {
        cin>>input[i];
    }

//    Build_Max_Heap(input,num);     //建立最大堆
    HeapSort(input,num);           //堆排�?/span>
    show(input,num);
}

hunter 2010-03-07 22:08 发表评论

hunter — Fri, 28 Nov 2008 05:24:00 GMT

cin.getline()�Ҏ(gu��)��q�箋��C��用户�l�端接受字符�Q��ƈ��字�W�存入字�W�型数组message中，直到输入了（maxchars�Q?/font>1�Q�个字符�Q�第maxchars个字�W�用来存储字�W�串�l�尾�?/font>NULL字符'\0')或者接受到了回车�ؓ止，�q�终端键入回车键产生一个换�?/font>'\n'�Q�它�?/font>cin.getline()认�ؓ是行输入�l�尾�?/font>cin.getline()获得的字�W?/font>(除了换行�W�外)被存储到message数组中。在�q�回之前�Q?/font>cin.getline�Q�）函数在存储的�q�些字符后面��d��一�?/font>NULL字符'\0'�?/span>
Cin.ignore�Q�）�Ҏ(gu��)��cin.ignore( 5, 'c' ) 的是从输入流�Q?span lang=EN-US>cin�Q�中提取字符�Q�提取的字符被忽略（ignore�Q�，不被使用。每抛弃一个字�W�，它都要计数和比较字符�Q�如果计数��D��?span lang=EN-US>5或者被抛弃的字�W�是'c'�Q�则cin.ignore() 函数执行�l�止�Q�否则，它��l�等待�?span lang=EN-US> 它的一个常用功能就是用来清除以回�R�l�束的输入缓冲区的内容，消除上一�ơ输入对下一�ơ输入的影响。比如可以这么用�Q?span lang=EN-US>cin.ignore( 1024, '\n' );�Q�通常把第一个参数设�|�得��_��大，�q�样实际上��L��只有�W�二个参�?span lang=EN-US> '\n' 起作用，所以这一句就是把回�R�Q�包括回车）之前的所以字�W�从输入�~�冲�Q�流�Q�中清除出去�?/span>
Cin.clear用法如果输入发生错误发生�Q�那么流状态既被标��Cؓ错误�Q�你必须清除�q�些错误状态，以��你的�E�序能正��适当地��l�运行。要清除错误状态，需使用clear()函数。此函数带一个参敎ͼ�它是你将要设为当前状态的标志倹{��，只要��?/font>ios::goodbit作�ؓ实参

hunter 2008-11-28 13:24 发表评论

合�ƈ排序

hunter — Tue, 25 Nov 2008 13:03:00 GMT

实现《算法导论》里的算法，一步一步来。。�?br>
合�ƈ�q�程中的变量�Ҏ(gu��)��搞错�Q�特别不能忽略合�q�过�E�中数组边界的改变！�Q�！

#include <iostream>
#include <string>
#include <vector>
#include <cmath>
using namespace std;

void Merge(int a[],int p,int k,int q)
{
   int num1=k-p+1;
   int num2=q-k;
   int i;
   int* b1=new int[num1+1];
   int* b2=new int[num2+1];
   for (i=0;i<num1;i++)
   {
       b1[i]=a[p+i];
   }
   b1[i]=9999;
   for (i=0;i<num2;i++)
   {
       b2[i]=a[k+i+1];
   }
   b2[i]=9999;
   int j=0;i=0;
   for(int kk=p;kk<=q;kk++)    //注意�Q�！�Q?br>   {
       if (b1[i]<=b2[j])
           a[kk]=b1[i++];
       else
           a[kk]=b2[j++];
   }
   delete [] b1;
   delete [] b2;
}
void MergeSort(int a[],int p,int q)
{
   if (p<q)
   {
       int k=(p+q)/2;
       MergeSort(a,p,k);
       MergeSort(a,k+1,q);
       Merge(a,p,k,q);
   }
}
int main()
{
   int n;
   scanf("%d",&n);
   int* input=new int[n];
   for (int i=0;i<n;i++)
   {
       scanf("%d",&input[i]);
   }
   MergeSort(input,0,n-1);
   for (int i=0;i<n;i++)
   {
       printf("%d ",input[i]);
   }
   delete [] input;
}

hunter 2008-11-25 21:03 发表评论

hunter — Sat, 22 Nov 2008 05:52:00 GMT

摘要: 帮同学妹妹弄的作业。。。以后可以参�?#include #include #include #include #include #include #includ... 阅读全文

hunter 2008-11-22 13:52 发表评论

二叉�?w��i)前序、中序、后序三�U�遍历的非递归��法

hunter — Fri, 21 Nov 2008 16:04:00 GMT

1.先序遍历非递归��法
void PreOrderUnrec(Bitree *t)
{
    Stack s;
StackInit(s);
Bitree *p=t;

while (p!=NULL || !StackEmpty(s))
{
      while (p!=NULL)          //遍历左子�?br>       {
         visite(p->data);
         push(s,p);
         p=p->lchild;
        }

        if (!StackEmpty(s))       //通过下一�ơ��@环中的内嵌while实现叛_��?w��i)遍�?br>       {
         p=pop(s);
         p=p->rchild;
      }//endif

}//endwhile
}

2.中序遍历非递归��法
void InOrderUnrec(Bitree *t)
{
    Stack s;
StackInit(s);
Bitree *p=t;

    while (p!=NULL || !StackEmpty(s))
{
      while (p!=NULL)          //遍历左子�?br>       {
         push(s,p);
         p=p->lchild;
      }

        if (!StackEmpty(s))
      {
         p=pop(s);
         visite(p->data);       //讉K��根结�?br>          p=p->rchild;          //通过下一�ơ��@环实现右子树(w��i)遍历
      }//endif

}//endwhile
}

3.后序遍历非递归��法
typedef enum{L,R} tagtype;
typedef struct
{
Bitree ptr;
tagtype tag;
}stacknode;

typedef struct
{
stacknode Elem[maxsize];
int top;
}SqStack;

void PostOrderUnrec(Bitree t)
{
SqStack s;
stacknode x;
StackInit(s);
p=t;

do
{
      while (p!=null)       //遍历左子�?br>       {
         x.ptr = p;
         x.tag = L;       //标记为左子树(w��i)
         push(s,x);
         p=p->lchild;
      }

      while (!StackEmpty(s) && s.Elem[s.top].tag==R)
      {
         x = pop(s);
         p = x.ptr;
         visite(p->data); //tag为R�Q�表�C�右子树(w��i)讉K��完毕�Q�故讉K��根结�?nbsp;
      }

      if (!StackEmpty(s))
      {
         s.Elem[s.top].tag =R;    //遍历叛_��?br>          p=s.Elem[s.top].ptr->rchild;
      }
}while (!StackEmpty(s));
}//PostOrderUnrec

二。前序最��z�算�?br>void PreOrderUnrec(Bitree *t)
{
   Bitree *p;
   Stack s;
   s.push(t);

   while (!s.IsEmpty())
   {
      s.pop(p);
      visit(p->data);
      if (p->rchild != NULL) s.push(p->rchild);
      if (p->lchild != NULL) s.push(p->lchild);
   }
}

三。后序算法之�?/strong>
void BT_PostOrderNoRec(pTreeT root)
{
stack s;
pTreeT pre=NULL;

while ((NULL != root) || !s.empty())
{
if (NULL != root)
{
s.push(root);
root = root->left;
}
else
{
root = s.top();
if (root->right!=NULL && pre!=root->right){
root=root->right;
}
else{
root=pre=s.top();
visit(root);
s.pop();
root=NULL;
}
}
}
}

hunter 2008-11-22 00:04 发表评论

hunter — Sun, 16 Nov 2008 03:42:00 GMT

Trie�?w��i)就是字典�?w��i)�Q�其核心思想��是�I�间换时间�?/p>

举个��单的例子�?/p>

�l�你100000个长度不��过10的单词。对于每一个单词，我们要判断他出没出现�q�，如果出现了，�W�一�ơ出现第几个位置�?br>�q�题当然可以用hash来，但是我要介绍的是trie�?w��i)。在某些斚w��它的用途更大。比如说对于某一个单词，我要询问它的前缀是否出现�q�。这样hash��׃��好搞了，而用trie�q�是很简单�?br>现在回到例子中，如果我们用最�?c��)��?gu��)��Q�对于每一个单词，我们都要��L��扑֮�前面的单词中是否有它。那么这个算法的复杂度就是O(n^2)。显然对�?00000的范围难以接受。现在我们换个思�\惟뀂假设我要查询的单词是abcd�Q�那么在他前面的单词中，以b�Q�c�Q�d�Q�f之类开头的我显然不必考虑。而只要找以a开头的中是否存在abcd��可以了。同��L(f��ng)��Q�在以a开头中的单词中�Q�我们只要考虑以b作�ؓ�W�二个字母的……�q�样一个树(w��i)的模型就渐渐清晰�?#8230;…
假设有b�Q�abc�Q�abd�Q�bcd�Q�abcd�Q�efg�Q�hii�q?个单词，我们构徏的树(w��i)��是�q�样的�?br>
对于每一个节点，从根遍历��C��的过�E�就是一个单词，如果�q�个节点被标��Cؓ�U�色�Q�就表示�q�个单词存在�Q�否则不存在�?br>那么�Q�对于一个单词，我只要顺着他从跟走到对应的节点�Q�再看这个节�Ҏ(gu��)��否被标记为红色就可以知道它是否出现过了。把�q�个节点标记为红�Ԍ��q��当于插入了这个单词�?br>�q�样一来我们询问和插入可以一起完成，所用时间仅仅�ؓ单词长度�Q�在�q�一个样例，便是10�?br>我们可以看到�Q�trie�?w��i)每一层的节点数是26^i�U�别的。所以�ؓ了节省空间。我们用动态链表，或者用数组来模拟动态。空间的��p��Q�不会超�q�单词数×单词长度�?/p>

�l�出一个用�c�d��装的字典�?w��i)代码，厄。。。做ACM的模板用另一个。。应该放在了“ACM模板”文�g夹下了。。�?/p>
#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;

const int num_chars = 26;

class Trie {
public:
      Trie():root(NULL){};
      Trie(Trie& tr);

     int search(const char* word, char* entry ) const;
     int insert(const char* word, const char* entry);
     int remove(const char* word, char* entry);
private:
     struct Trie_node
     {
         char* data;
          Trie_node* branch[num_chars];
          Trie_node();
     }* root;
};
Trie::Trie_node::Trie_node()
{
      data = NULL;
    for (int i=0; i<num_chars; ++i)
          branch[i] = NULL;
}

int Trie::search(const char* word, char* entry ) const
{
    int position = 0;
    char char_code;
     Trie_node *location = root;
    while( location!=NULL && *word!=0 )
    {
        if (*word>='A' && *word<='Z')
              char_code = *word-'A';
        else if (*word>='a' && *word<='z')
              char_code = *word-'a';
        else return 0;

         location = location->branch[char_code];
         position++;
         word++;
    }
    if ( location != NULL && location->data != NULL )
    {
        strcpy(entry,location->data);
        return 1;
    }
    else return 0;
}
int Trie::insert(const char* word, const char* entry)
{
    int result = 1, position = 0;
    if ( root == NULL ) root = new Trie_node;
    char char_code;
      Trie_node *location = root;
    while( location!=NULL && *word!=0 )
    {
        if (*word>='A' && *word<='Z')
              char_code = *word-'A';
        else if (*word>='a' && *word<='z')
              char_code = *word-'a';
        else return 0;

        if( location->branch[char_code] == NULL )
              location->branch[char_code] = new Trie_node;

          location = location->branch[char_code];
          position++;
          word++;
    }
    if (location->data != NULL)
          result = 0;
    else {
          location->data = new char[strlen(entry)+1];
        strcpy(location->data, entry);
    }
    return result;
}
int main()
{
      Trie t;
      char entry[100];
      t.insert("aa", "DET");
      t.insert("abacus","NOUN");
      t.insert("abalone","NOUN");
      t.insert("abandon","VERB");
      t.insert("abandoned","ADJ");
      t.insert("abashed","ADJ");
      t.insert("abate","VERB");
      t.insert("this", "PRON");
    if (t.search("this", entry))
        cout<<"'this' was found. pos: "<<entry<<endl;
    if (t.search("abate", entry))
        cout<<"'abate' is found. pos: "<<entry<<endl;
    if (t.search("baby", entry))
        cout<<"'baby' is found. pos: "<<entry<<endl;
    else
        cout<<"'baby' does not exist at all!"<<endl;

    if (t.search("aa", entry))
        cout<<"'aa was found. pos: "<<entry<<endl;
}

PS:实现�Ҏ(gu��)��http://met.fzu.edu.cn/eduonline/web/web/resources/articleContent.asp?id=346

hunter 2008-11-16 11:42 发表评论

七种qsort排序�Ҏ(gu��)��

hunter — Sat, 15 Nov 2008 13:32:00 GMT
<本文中排序都是采用的从小到大排序>
一、对int�c�d��数组排序
�E�序代码 �E�序代码
int num[100];
Sample:
int cmp ( const void *a , const void *b )
{
     return *(int *)a - *(int *)b;
}
qsort(num,100,sizeof(num[0]),cmp);

二、对char�c�d��数组排序�Q�同int�c�d��Q?br>�E�序代码 �E�序代码
char word[100];
Sample:
int cmp( const void *a , const void *b )
{
    return *(char *)a - *(char*)b;
}
qsort(word,100,sizeof(word[0]),cmp)

三、对double�c�d��数组排序�Q�特别要注意�Q?br>�E�序代码 �E�序代码
double in[100];
int cmp( const void *a , const void *b )
{
    return *(double *)a > *(double *)b ? 1 : -1;
} qsort(in,100,sizeof(in[0]),cmp)�Q?br>
四、对�l�构体一�U�排�?
�E�序代码 �E�序代码
struct In {
double data;
int other;
}s[100]
//按照data的��g��到大将�l�构体排�?关于�l�构体内的排序关键数据data的类型可以很多种�Q?br>参考上面的例子�?
int cmp( const void *a ,const void *b)
{
     return (*(In *)a).data > (*(In *)b).data ? 1 : -1;
}
qsort(s,100,sizeof(s[0]),cmp);

五、对�l�构体二�U�排�?
�E�序代码 �E�序代码
struct In {
   int x; int y;
}s[100];
//按照x从小到大排序�Q�当x相等时按照y从大到小排序
int cmp( const void *a , const void *b )
{
    struct In *c = (In *)a;
    struct In *d = (In *)b;
    if(c->x != d->x) return c->x - d->x;
    else return d->y - c->y;
}
qsort(s,100,sizeof(s[0]),cmp);

六、对字符串进行排�?
�E�序代码 �E�序代码
struct In {
   int data; char str[100];
}s[100];
//按照�l�构体中字符串str的字兔R��序排�?
int cmp ( const void *a , const void *b )
{
    return strcmp( (*(In *)a)->str , (*(In *)b)->str );
}
qsort(s,100,sizeof(s[0]),cmp);

七、计��几何中求凸包的cmp
�E�序代码 �E�序代码
int cmp(const void *a,const void *b)
//重点cmp函数�Q�把除了1点外的所有点�Q�旋转角度排�?
{
    struct point *c=(point *)a;
    struct point *d=(point *)b;
    if( calc(*c,*d,p[1]) < 0) return 1;
    else if( !calc(*c,*d,p[1])
   && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y))
   //如果在一条直�U�上�Q�则把远的放在前�?
   return 1; else return -1;
}

PS: 其中的qsort函数包含�?lt;stdlib.h>的头文�g里，strcmp包含�?lt;string.h>的头文�g�?

hunter 2008-11-15 21:32 发表评论

12个球找不同的智力题解题思�\

hunter — Fri, 14 Nov 2008 03:55:00 GMT

2个球,大小�?其中一个重量不同。现有一个天�q?要用�q�个天��^�U?�ơ找��个不同重量的�?如何�U?

��所有球�~�号�?-12�Q?br>�W�一步，��?-4��h��左边�Q?-8��h��双��Q?br>        若倾斜�Q�假讑֏�重（左重雷同�Q�：
        �W�二步[0]�Q�将2-4�U�走�Q?-8�U�d��左边�Q?-11�U�d��双��Q?br>                若仍倾斜�Q�则不同的那个�ؓ�~�号1�?��P��
                        �W�三步[0][0]�Q�将1号与2��h��较，若相�{�，�?号偏重，反之�Q?��L(f��ng)��偏轻�Q?br>                若不倾斜�Q�则不同的那个在�~�号2-4中，且偏轻；
                        �W�三步[0][1]�Q��Q�?-4�U�两球可得结果；
        若不倾斜�Q�则不同的在9-12中：
        �W�二步[1]�Q�移�?-8球，�U�d��9-11球：
                若倾斜�Q�假讑֏�重（左重雷同�Q�：
                �W�三步[1][0]�Q��Q�?-11�U�两球可得结果；
                若不倾斜�Q�则12��L(f��ng)��异常�Q?br>                �W�三步[1][1]�Q�将12��L(f��ng)��与其它�Q意球比较可知是轻是重�Q?/p>

hunter 2008-11-14 11:55 发表评论

hunter — Mon, 10 Nov 2008 16:25:00 GMT

一个K位的数N (K<=2000,N<=10^20)
扑և�一个比N大且最接近的数�Q�这个数的每位之和与N相同
用代码实��C��

如：
0050    所求数�?104
112     所求数�?21

�ȝ��看到一题会做的 -_-|||
从右往左扫描即可，而且�l�出的例子也很典型�?br>考虑问题全面一些，注意 823993 �q�样的情�?

�?3919999700
从右向左扑ֈ��W�一个非0 7,7-- ,�q�且�?�U�d��最�?br>�l�箋扫碰�?��q��到最�?扑ֈ��W�一个非9 1, 1++
最后变�?3920069999

�q�要考虑到只有一位非零��|��q�位问题
�?0-�?08

hunter 2008-11-11 00:25 发表评论