C++博客-xyjzsh-随笔分类-算法

重载标准输出符号operator<<

呆人 — Wed, 10 Aug 2011 05:43:00 GMT

CString是我自己定义的一个类
为了实现：
CString str("123abvc");
cout<

声明：
ostream& operator<<(ostream& os,const CString& str);
实现：

ostream& operator<<(ostream& os,const CString& str)
{
long multiBytes = WideCharToMultiByte(CP_ACP,0,str._pData,-1,NULL,0,NULL,NULL);//获得将宽字节转换成多自己时，所需要的字节个数，注意蓝色部分
char *lpMultiBytes = new char[multiBytes+10];//分配多字节时所需要的内存
memset(lpMultiBytes,0,multiBytes+10);

WideCharToMultiByte(CP_ACP,0,str._pData,-1,lpMultiBytes,multiBytes+10,NULL,NULL);//调用win32api函数将宽字节的表示转换成为多字节的表示，注意蓝色部分

os<

return os;//注意返回值
}

呆人 2011-08-10 13:43 发表评论

matlab生成dll后在vc中脱离matlab环境执行

呆人 — Mon, 16 May 2011 08:05:00 GMT

在没有安装matlab的机器上，要想运行matlab的dll要必须安装MCR环境。
在安装了matlab的机器上，在 MATLAB\R2010b\toolbox\compiler\deploy\win32下面有MCR 的安装程序。
在安装了MCR的机器上，就可以运行使用了matlab的dll的VC的可执行文件。

呆人 2011-05-16 16:05 发表评论

matlab生成dll后在vc中脱离matlab环境执行

呆人 — Mon, 16 May 2011 08:05:00 GMT

呆人 2011-05-16 16:05 发表评论

vs2008中调用matlab生成的dll

呆人 — Thu, 12 May 2011 09:28:00 GMT

matlab版本为:matlab7.11.0(R2010b)
vs2008

1.在matlab中生成dll

在m文件中实现如下功能：
获得N个魔方矩阵的秩。m文件的内容如下：
function r = mrank(n)

r = zeros(n,1);
for k=1:n
r(k) = rank(magic(k));
end

将上述内容保存为:mrank.m

在matlab的command 窗口键入：
>> mcc -B csharedlib:mrank mrank.m %该命令将在后面做说明

在matlab7.0中执行上述命令后生成下面几个文件：
mrank.exp mrank.exports mrank.h mrank.lib mrank.c mrank.dll

在vs2008中使用m文件的函数功能。
首先配置vs2008的环境
1.工具——> 选项——>项目和解决方案——>VC++目录
(1) 选择“可执行文件”下拉框，添加：C:\Program Files\MATLAB\R2010b\bin\win32（注意：当前的Mathlab安装在C:\Program Files下面）
(2)选择“包含文件”下拉框，添加：C:\Program Files\MATLAB\R2010b\extern\include
(3)选择“引用文件”下拉框，添加:C:\Program Files\MATLAB\R2010b\extern\lib
(4)选择“库文件”下拉框，添加：C:\Program Files\MATLAB\R2010b\extern\lib\win32\microsoft
上述环境只需要配置一次

对于每一个工程，做下面的设置
项目——>属性——>连接器——>输入
选择:附加依赖项：添加:
libmex.lib
libmx.lib
libmat.lib
mclmcrrt.lib

将mrank.h mrank.lib mrank.dll拷贝到当前目录下
cpp文件中中的内容如下：
#include "stdafx.h"
#include
#include"matrix.h"
#include"mrank.h"
#include "mclmcrrt.h"
#pragma comment(lib,"mrank.lib")

int main()
{
mxArray *N(NULL),*R(NULL);
int n =12;

mrankInitialize();//初始化动态链接库
N = mxCreateDoubleScalar(n);//用n来初始化生成的数组，其实标量就是一个1*1的数组
mlfMrank(1,&R,N);//执行m文件的主要功能

size_t num = mxGetM(R);//R的行的个数
double *res = new double[num];
memset(res,0,sizeof(double)*num);

memcpy(res,mxGetPr(R),sizeof(double)*num);

for(int i=0;i printf("%f\n",res[i]);

delete[] res;
mxDestroyArray(N);
mxDestroyArray(R);

mrankTerminate();//终止动态数据连接
return 0;
}

上述cpp文件使用了Matlab编译m文件生成的dll，在cpp中通过mxArray这个数据结构来和dll中的方法进行信息交换。
这样就在cpp中调用了matlab中的m文件实现的方法。

mcc命令说明：
http://www.cnblogs.com/juneja/archive/2008/10/31/1323423.html

呆人 2011-05-12 17:28 发表评论

插入排序vs希尔排序

呆人 — Wed, 23 Feb 2011 09:44:00 GMT

什么是插入排序？
在插入排序法中，将检查数组中的每个元素，将它插入排序中的元素的适当位置，当最后一个元素插入到它适当的位置时，这个数组就排好序了。例如，

假如我们要对一个有5个元素的数组进行升序排列，假设第一个元素的值被假定为已排好序了，那么我们将第2个元素插入到已排序好的数组中的适当位置上，使得数组应该是排序好的。依次类推，将第3个插入到到已排序好的数组中的适当位置，使得插入后数组仍然是排序好的，。。。。。。
下面是一个插入排序的Demo：

int tarArr[]={10,1,35,12,7,17,66,6,56,26};
int size = sizeof(tarArr)/sizeof(tarArr[0]);

void insertSort(void)
{
    int i=0,j=0;
    for(i=1;i<size;i++)
    {
        int nextValue = tarArr[i];
        for(j=i-1;j>=0;j--)
        {
            if(nextValue<tarArr[j])
                tarArr[j+1]=tarArr[j];
            else
            {
                break;
            }
        }
        tarArr[j+1]=nextValue;
    }
}

下面来介绍一下希尔排序：
希尔排序就是将要排序的数据先分成如果组，对每一组实行插入排序。
代码如下：

int tarArr[]={10,1,35,12,7,17,66,6,56,26};
int size = sizeof(tarArr)/sizeof(tarArr[0]);

void shellSort(void)
{
    int gap =0,i=0,j=0;
    for(gap = size/2;gap>0;gap/=2)
    {
        for(i=gap;i<size;i+=gap)
        {
            int nextValue = tarArr[i];
            for(j=i-gap;j>=0;j-=gap)
            {
                if(nextValue<tarArr[j])
                    tarArr[j+gap] = tarArr[j];
                else
                {
                    break;
                }

            }
            tarArr[j+gap] = nextValue;
        }
    }
}

呆人 2011-02-23 17:44 发表评论

[算法题]输出从1到1000的数[转载]

呆人 — Mon, 17 Jan 2011 02:30:00 GMT

有这样一个面试题——请把从1到1000的数打印出来，但你不能使用任何的循环语句或是条件语句。更不能写1000个printf或是cout。用C/C++语言。

个人比较赞赏的思路是下面两个：

1. 函数指针数组结合n/1000的结果作为数组的index。

1void yesprint(int i);
2void noprint(int i);
3
4typedef void(*fnPtr)(int);
5fnPtr dispatch[] = { yesprint, noprint };
6
7void yesprint(int i) {
8    printf("%d\n", i);
9    dispatch[i / 1000](i + 1);
10}
11
12void noprint(int i) { /* do nothing. */ }
13
14int main() {
15      yesprint(1);
16}
17

2. 构造函数结合静态变量结合数组。

1 class Printer
2 {
3 public:
4     Printer() { static unsigned i=1; cout << i++ << endl;; }
5
6 };
7
8 int main()
9 {
10     Printer p[1000];
11 }
12

呆人 2011-01-17 10:30 发表评论

同时求出最大值最小值的方法

呆人 — Thu, 02 Dec 2010 03:11:00 GMT

在O(3n/2)比较后求出最大值和最小值
思想:成对的处理元素，两者较大的和max比较，两者较小的和min比较。

GetMaxAndMin(A,n)
if n为奇数
max = min = A[0];
i = 1;

else
if A[0]>A[1] then max = A[0]; min = A[1]
else max = A[1]; min = A[0];
i =2;

for i to n-1

if(A[i]>A[i+1])
{
   max = max>A[i] ? max: A[i];
   min = A[i+1]}
else
{
   max = A[i+1]>max ? A[i+1]:max;
   min = A[i]}

i+=2;

呆人 2010-12-02 11:11 发表评论

O(n)的时间内找到第k个最大值（最小值）的算法

呆人 — Thu, 02 Dec 2010 03:02:00 GMT

下面介绍一种在O(n)的时间内找出第k个最大值(最小值)的方法
该方法和快速排序相似。不同在于每次只出理一边。
伪代码如下：
Random-select(A,p,r,i)//找到A中的第i个最小值
if p==r
then return a[p]
q = random-partition(A,p,r)
k = p-q+1
if(i==k)
then return A[q]
else if ithen return random-select(A,p,q-1,i)
else return random-select(A,q+1,r,i-k)
这个算法很不错。

呆人 2010-12-02 11:02 发表评论

浅谈排序算法

呆人 — Thu, 02 Dec 2010 03:01:00 GMT

最近在看《算法导论》，首先在这推荐一下这本书，写的确实很精彩。
《算法导论》的第二部分分析了多种排序算法。包括插入排序、归并排序、堆排序、快速排序以及线性排序的几个算法。
下面简要总结一下。
对于输入规模为n的数组。插入排序的复杂度为O(n^2)。
归并排序、堆排序、快速排序的复杂度为O(n㏒n);
线性排序的复杂度为O(n)
1.插入排序的性能和输入元素的的序列有很大的关系，如果输入已排序的序列，则复杂度是线性的，若输入是逆序的则是O(n^2)的。
2.堆排序用到了优先队列（优先队列是一种用来维护由一组元素构成的集合S的数据结构）。
3.快速排序的关键是主元的选取(pivot)。在排序过程中元素被分成四部分：小于等于主元的序列、大于主元的序列、未比较的序列、主元。
当未比较的序列未空时，再分别对小于等于主元的序列进行排序、对大于主元的序列进行排序。
以上三种排序都是原地排序。所谓的原地排序(in-place)是指这些元素是在原数组中重排序的，在任何时刻，至多其中的常数个数字是存储在数组之外的。
4.归并排序是将原数组划分成子序列，对子序列进行排序，然后将排序好的子序列合并到一起从而使得原序列重排。
归并排序不是原地排序，它需要额外的内存资源。

以上四种是比较常用的排序，对于输入序列没有特殊的要求，并且都是比较排序，也就是说通过比较各个元素而进行的排序。它们的时间复杂度最好为O(n㏒n);

下面介绍能在时间内完成的排序。
1.计数排序
适用条件：输入序列中的元素取值在一个范围之内0-k
基本思想:对于每一个元素确定比它小的的元素的个数。
排序A序列，将结果放入B中，元素的取值范围为0-k
伪代码如下：
Count-sort(A,B,k)
for i=0 to k
do C[i]=0
for j=1 to length(A)
do C[A[j]] = C[A[j]]+1;计算A[j]的个数。

for i=1 to k
do C[i] = C[i-1]+C[i];计算小于和等于i的元素个数

for j=length(A) downto 1
do B[C[A[j]]] = A[j];
C[A[j]] = C[A[j]]-1;

我们可以明显看到计数排序不是原地排序。同时计数排序是稳定的（即相同的元素输入和输出的相对位置不变。）

呆人 2010-12-02 11:01 发表评论