博客园_前进的道路不是一帆风顺的，要随时迎接挑战，敢于战胜困难！

判断整数序列是不是二元查找树的后序遍历结果

2010-08-11T08:29:00Z

#include <iostream>

using namespace std;

bool verifySquenceOfBST(int squence[], int length)
{
if (squence==NULL||length<=0)
{
return false;
}

int root=squence[length-1];
int i=0;
for(; i<length-1; ++i)
{
  if (squence[i]>root)
  {
   break;
  }
}

int j=i;
for (; j<length-1; ++j)
{
  if (squence[j]<root)
  {
   return false;
  }
}

bool left=true;
if (i>0)
{
left=verifySquenceOfBST(squence, i);
}

bool right=true;
if (i<length-1)
{
right=verifySquenceOfBST(squence, length-i-1);
}

return left&&right;
}

int main()
{
int squence1[]={5, 7, 6, 9, 11, 10, 8};
int squence2[]={7, 4, 6, 5};

int length1=sizeof(squence1)/sizeof(int);
int length2=sizeof(squence2)/sizeof(int);

if (verifySquenceOfBST(squence1, length1))
{
cout<<"squence1 is BST"<<endl;
}
else
{
cout<<"squence1 is not BST"<<endl;
}

if (verifySquenceOfBST(squence2, length2))
{
cout<<"squence2 is BST"<<endl;
}
else
{
cout<<"squence2 is not BST"<<endl;
}

return 0;
}

本文链接

查找最小的k个元素

2010-08-11T07:25:00Z

算法中使用到了堆，即stl中的multiset。

#include <iostream>
#include <vector>
#include <set>
using namespace std;

typedef multiset<int, greater<int>> IntHeap;

void FindKLeastNumbers(
const vector<int>& data,
IntHeap& leastNumbers,
unsigned int k)
{
leastNumbers.clear();

if (k==0||data.size()<k)
{
return;
}

vector<int>::const_iterator iter=data.begin();
for (; iter!=data.end(); ++iter)
{
  if (leastNumbers.size()<k)
  {
   leastNumbers.insert(*iter);
  }
  else
  {
   IntHeap::iterator iterFirst=leastNumbers.begin();
   if (*iter<*iterFirst)
   {
    leastNumbers.erase(iterFirst);
    leastNumbers.insert(*iter);
   }
  }
}
}

int main()
{
vector<int> data;
data.push_back(7);
data.push_back(2);
data.push_back(8);
data.push_back(1);
data.push_back(5);
data.push_back(3);
data.push_back(6);
data.push_back(-4);

IntHeap leastNumbers;

FindKLeastNumbers(data, leastNumbers, 4);

IntHeap::iterator iter=leastNumbers.begin();
for (; iter!=leastNumbers.end(); ++iter)
{
cout<<*iter<<'\t';
}

cout<<endl;

return 0;
}

本文链接

在二元树中查找和为某一值的所有路径

2010-08-11T06:25:00Z

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

struct BinaryTreeNode
{
int m_nValue;
BinaryTreeNode* m_pLeft;
BinaryTreeNode* m_pRight;
};

int count=0; //print control

void FindPath(
BinaryTreeNode* pTreeNode,
int expectedSum,
vector<int>& path,
int& currentSum)
{
if (!pTreeNode)
{
return;
}

currentSum+=pTreeNode->m_nValue;
path.push_back(pTreeNode->m_nValue);

bool isLeaf=!(pTreeNode->m_pLeft)&&!(pTreeNode->m_pRight);

if (currentSum==expectedSum && isLeaf)
{
  vector<int>::iterator iter;
  for (iter=path.begin(); iter!=path.end(); iter++)
  {
   cout<<*iter<<'\t';
  }
  cout<<endl;
}

if (pTreeNode->m_pLeft)
{
FindPath(pTreeNode->m_pLeft, expectedSum, path, currentSum);
}
if (pTreeNode->m_pRight)
{
FindPath(pTreeNode->m_pRight, expectedSum, path, currentSum);
}

//when finish visiting a node and return to its parent node,
//should delete this node from the path and
//minus the node's value from the current sum
currentSum-=pTreeNode->m_nValue;
path.pop_back();
}

void AddTree(BinaryTreeNode** T, int num)
{
if (*T==NULL)
{
  *T=(BinaryTreeNode*)malloc(sizeof(BinaryTreeNode));
  (*T)->m_nValue=num;
  (*T)->m_pLeft=NULL;
  (*T)->m_pRight=NULL;
}
else if ((*T)->m_nValue>num)
{
  AddTree(&((*T)->m_pLeft), num);
}
else
{
  AddTree(&((*T)->m_pRight), num);
}
}

void MidTraversal(BinaryTreeNode* T)
{
if(T!=NULL)
{
  MidTraversal(T->m_pLeft);
  count++;
  if (count%5==0)
  {
   cout<<T->m_nValue<<endl;
  }
  else
  {
   cout<<T->m_nValue<<"\t";
  }

MidTraversal(T->m_pRight);
}
}

int main()
{
BinaryTreeNode* T=NULL;

AddTree(&T, 10);
AddTree(&T, 12);
AddTree(&T, 5);
AddTree(&T, 7);
AddTree(&T, 4);

cout<<"Mid reversal tree is:\n";
MidTraversal(T);

vector<int> path;
int sum=0;
FindPath(T, 22, path, sum);

return 0;
}

本文链接

求子数组的最大和

2010-08-11T05:34:00Z

#include <iostream>

using namespace std;

bool FindGreatestSumOfSubArray(int *pData, unsigned int nLength, int &nGreatestSum)
{
if (!pData||0==nLength)
{
return false;
}

int nCurrentSum=nGreatestSum=0;
for (unsigned int i=0; i<nLength; i++)
{
nCurrentSum+=pData[i];

//if the sum is negative, discard it.
  if (nCurrentSum<0)
  {
   nCurrentSum=0;
  }

if (nCurrentSum>nGreatestSum)
  {
   nGreatestSum=nCurrentSum;
  }
}

//if all data are negative, find the greatest element in array
if (nGreatestSum==0)
{
  nGreatestSum=pData[0];
  for (unsigned int i=1; i<nLength; ++i)
  {
   if (pData[i]>nGreatestSum)
   {
    nGreatestSum=pData[i];
   }
  }
}

return true;
}

int main()
{
int data[]={1, -2, 3, 10, -4, 7, 2, -5};
int greatest=0;
unsigned int length=sizeof(data)/sizeof(int);
cout<<"length = "<<length<<endl;

if (FindGreatestSumOfSubArray(data, length, greatest))
{
cout<<"the greatest sum of the sub array is: "<<greatest<<endl;
}

for (int i=0; i<5; i++)
{
cout<<i<<"\t";
}
cout<<endl;

for (int j=0; j<5; ++j)
{
cout<<j<<"\t";
}
cout<<endl;

return 0;
}

本文链接

把二元查找树转变成排序的双向链表

2010-08-11T04:59:00Z

#include <iostream>
#include <time.h>

#define MAX_NUM 10

using namespace std;

struct BSTreeNode
{
int m_nValue;
BSTreeNode *m_pLeft;
BSTreeNode *m_pRight;
};

int count=0;

void AddTree(BSTreeNode** T, int num)
{
if (*T==NULL)
{
  *T=(BSTreeNode*)malloc(sizeof(BSTreeNode));
  (*T)->m_nValue=num;
  (*T)->m_pLeft=NULL;
  (*T)->m_pRight=NULL;
}
else if ((*T)->m_nValue>num)
{
  AddTree(&((*T)->m_pLeft), num);
}
else
{
  AddTree(&((*T)->m_pRight), num);
}
}

void MidTraversal(BSTreeNode* T)
{
if(T!=NULL)
{
  MidTraversal(T->m_pLeft);
  count++;
  if (count%5==0)
  {
   cout<<T->m_nValue<<endl;
  }
  else
  {
   cout<<T->m_nValue<<"\t";
  }

MidTraversal(T->m_pRight);
}
}

void ConvertNode(BSTreeNode* pNode, BSTreeNode** pLastNodeInList)
{
if (pNode==NULL)
{
return;
}

BSTreeNode* pCurrent=pNode;

if (pCurrent->m_pLeft!=NULL)
{
ConvertNode(pCurrent->m_pLeft, pLastNodeInList);
}

//Put the current node into the double-linked list
//pLastNodeInList<--pCurrent
//pLastNodeInList-->pCurrent
pCurrent->m_pLeft=*pLastNodeInList;
if (*pLastNodeInList!=NULL)
{
(*pLastNodeInList)->m_pRight=pCurrent;
}

*pLastNodeInList=pCurrent;

if (pCurrent->m_pRight!=NULL)
{
ConvertNode(pCurrent->m_pRight, pLastNodeInList);
}
}

void PrintList(BSTreeNode* L, int flag)
{
BSTreeNode* p=L;
while (p!=NULL)
{
  count++;
  if (count%5==0)
  {
   cout<<p->m_nValue<<endl;
  }
  else
  {
   cout<<p->m_nValue<<"\t";
  }

if (1==flag)
  {
   p=p->m_pRight;
  }
  else
  {
   p=p->m_pLeft;
  }
}
}

BSTreeNode* ConvertSolution(BSTreeNode* pHeadOfTree)
{
BSTreeNode* pLastNodeInList=NULL;
ConvertNode(pHeadOfTree, &pLastNodeInList);

cout<<"Last node is: "<<pLastNodeInList->m_nValue<<endl;
pLastNodeInList->m_pRight=NULL;

cout<<"Revert list is:\n";
PrintList(pLastNodeInList, 2);

BSTreeNode* pHeadOfList=pLastNodeInList;
while(pHeadOfList&&pHeadOfList->m_pLeft)
pHeadOfList=pHeadOfList->m_pLeft;
cout<<"Normal list is: \n";
PrintList(pHeadOfList, 1);

return pHeadOfList;
}

int main()
{
BSTreeNode* T=NULL;
int num, i;

srand((unsigned int)time(NULL));
for (i=0; i<MAX_NUM; i++)
{
num=rand()%100+1;
AddTree(&T, num);
}

cout<<"Mid reversal tree is:\n";
MidTraversal(T);

cout<<"\ndouble list is:\n";
PrintList(ConvertSolution(T), 1);

return 0;
}

本文链接

编写String类的构造函数，析构函数，赋值函数

2010-08-10T09:40:00Z

#include <iostream>

using namespace std;

class String
{
public:
String(const char* str=NULL);
String(const String& other);
~String(void);
String & operator =(const String& other);
const char* getString() const;

private:
char* m_data;
};

String::~String(void)
{
delete [] m_data;
}

String::String(const char *str)
{
if (str==NULL)
{
  m_data=new char[1];
  *m_data='\0';
}
else
{
  int length=strlen(str);
  m_data=new char[length+1];
  strcpy(m_data, str);
}
}

String::String(const String& other)
{
int length=strlen(other.m_data);
m_data=new char[length+1];
strcpy(m_data, other.m_data);
}

String& String::operator=(const String& other)
{
if (this==&other)
{
return *this;
}

delete [] m_data;
int length=strlen(other.m_data);
m_data=new char[length+1];
strcpy(m_data, other.m_data);

return *this;
}

const char* String::getString() const
{
return m_data;
}

int main()
{
String str("hello");
String str1(" meng");
String str2(str1);
String str3(" jun.");
String str4(str3);
String str5=str4;

cout<<str.getString()<<str2.getString()<<str5.getString()<<endl;

return 0;
}

本文链接

设计包含min函数的栈（源码）

2010-08-10T05:53:00Z

采用两个双端队列实现，一个存数据，一个是辅助栈，存第一个栈的最小元素的地址，实现技巧在于辅助栈存放的是第一个栈的最小元素的地址，难度在于使用模板实现。

#include <deque>
#include <assert.h>
#include <iostream>

using namespace std;

template <typename T>class CStackWithMin
{
public:
CStackWithMin(void){}
virtual ~CStackWithMin(void){}

T& top(void);
const T&top(void)const;

void push(const T& value);
void pop(void);

const T& min(void) const;

const T& size(void) const;

private:
deque<T> m_data;//the element of the stack
deque<size_t> m_minIndex; //the index of minimum elements
};

template<typename T> T& CStackWithMin<T>::top()
{
return m_data.back();
}

template<typename T> const T& CStackWithMin<T>::top() const
{
return m_data.back();
}

template<typename T> void CStackWithMin<T>::push(const T& value)
{
m_data.push_back(value);

if (m_minIndex.size()==0)
{
  m_minIndex.push_back(0);
}
else
{
  if(value<m_data[m_minIndex.back()])
   m_minIndex.push_back(m_data.size()-1);
  else
   m_minIndex.push_back(m_minIndex.back());
}
}

template<typename T> void CStackWithMin<T>::pop()
{
m_data.pop_back();

m_minIndex.pop_back();
}

template<typename T>const T& CStackWithMin<T>::min()const
{
assert(m_data.size()>0);
assert(m_minIndex.size()>0);

return m_data[m_minIndex.back()];
}

template<typename T>const T& CStackWithMin<T>::size() const
{
assert(m_data.size()>0);
assert(m_minIndex.size()>0);

return m_data.size();
}

int main()
{
CStackWithMin<int> cs;

cs.push(3);
cs.push(4);
cs.push(2);
cs.push(1);
cs.push(5);
cs.push(6);
cs.push(0);
cout<<"cs.size() = "<<cs.size()<<endl;
int len=cs.size();
for (int i=0; i<len; i++)
{
  cout<<"cs.min() = "<<cs.min()<<endl;
  cout<<"cs.top() = "<<cs.top()<<endl;
  cs.pop();
}

return 0;
}

本文链接

自己写的大整数乘法C++程序，请指正。

2010-08-09T10:02:00Z

#include <iostream>

using namespace std;

int multi(const int a[], const int b[], int c[], const int len)
{
for (int k=0; k<2*len-1; k++)
{
  for (int i=0; (i<k+1)&&(i<len); i++)
  {
   if (k-i<len)
   {
    int temp=a[i]*b[k-i];
    c[k]+=temp;
   }
  }
  cout<<"c["<<k<<"] = "<<c[k]<<endl;
}

return 0;
}

int out(int c[], const int len)
{
for (int i=2*len-2; i>0; i--)
{
  if (c[i]>9)
  {
   c[i-1]+=c[i]/10;
   c[i]=c[i]%10;
  }
}

return 0;
}

int main()
{
const int a[]={1, 2, 3, 4, 5, 5, 1, 2, 3, 4};
const int b[]={6, 7, 8, 9, 0, 5, 1, 2, 3, 4};

static const int len = 9;
int c[2*len+2]={0};
multi(a, b, c, len+1);
out(c, len+1);

for(int i=0; i<2*len+1; i++)
cout<<c[i];
cout<<endl;

return 0;
}

本文链接

DLL中导出函数的两种方式(dllexport与.def文件)

2010-08-04T05:31:00Z

DLL中导出函数的声明有两种方式：

一种方式是：在函数声明中加上__declspec(dllexport)；
另外一种方式是：采用模块定义(.def)文件声明，(.def)文件为链接器提供了有关被链接程序的导出、属性及其他方面的信息。

方式一：在函数声明中加上__declspec(dllexport)
/// 在动态链接库程序中
/// 声明动态链接库(**.dll)的对外接口函数TestFuction
extern "C" __declspec(dllexport) int TestFuction(int nType,char *strPath,std::vector<string> &vecData)
{
////do anything here////
return 0;
}

/// 在外部希望调用动态链接库的程序中
/// 加载动态链接库(**.dll)并调用其对外接口TestFuction
void func()
{
//typedef与函数TestFuction类型相同的函数指针为TESTDLL
typedef int (_cdecl * TESTDLL)(int nType,char *strPath,std::vector<string> &vecData);
HINSTANCE hmod;
//加载动态链接库**.dll
hmod =::LoadLibrary(_TEXT("dll相对路径\\**.dll"));
if(NULL == hmod)
{
     TRACE("加载**.dll失败");
}
//定义一个与函数TestFuction类型相同的函数指针lpproc
TESTDLL lpproc;
//搜索**.dll中函数名为TestFuction的对外接口
lpproc = (TESTDLL)GetProcAddress (hmod,"TestFuction");
//如果搜索成功
if(NULL != lpproc)
{
     int nType = 0;
     char* strPath = "Data";
     std::vector<string> vecData;
     //通过函数指针lpproc调用**.dll的接口函数TestFuction
     int nResult = (*lpproc)(nType,strPath,vecData);
}
//...
//在恰当的时候释放动态链接库**.dll
FreeLibrary(hmod);
}

方式二：采用模块定义(.def)文件声明
首先创建一个DLL程序(DllTestDef)
在*.cpp中
int __stdcall Add(int numa, int numb)
{
return (numa + numb);
}

int __stdcall Sub(int numa, int numb)
{
return (numa - numb);
}

然后创建一个.def的文件，在里面加上

;DllTestDef.lib : 导出DLL函数
;作者：----
LIBRARY DllTestDef
EXPORTS
Add @ 1
Sub @ 2

最后创建一个测试程序：.cpp文件如下：
#include <iostream>
#include <windows.h>

using namespace std;

typedef int (__stdcall *FUN)(int, int);
HINSTANCE hInstance;
FUN fun;

int main()
{
       hInstance = LoadLibrary("DLLTestDef.dll");
       if(!hInstance)
           cout << "Not Find this Dll" << endl;
       fun = (FUN)GetProcAddress(hInstance, MAKEINTRESOURCE(1));
       if (!fun)
       {
              cout << "not find this fun" << endl;
       }
       cout << fun(1, 2) << endl;
       FreeLibrary(hInstance);
       return 0;
}

说明：
.def文件的规则为：

(1)LIBRARY语句说明.def文件相应的DLL；

(2)EXPORTS语句后列出要导出函数的名称。可以在.def文件中的导出函数名后加@n，表示要导出函数的序号为n（在进行函数调用时，这个序号将发挥其作用）；

(3).def 文件中的注释由每个注释行开始处的分号 (;) 指定，且注释不能与语句共享一行。

(4)使用__declspec(dllexport)和使用.def文件是有区别的。

如果你的DLL是提供给VC用户使用的，你只需要把编译DLL时产生的.lib提供给用户，
它可以很轻松地调用你的DLL。但是如果你的DLL是供VB、PB、Delphi用户使用的，那么会产生一个小麻烦。
因为VC++编译器对于__declspec(dllexport)声明的函数会进行名称转换，如下面的函数：
__declspec(dllexport) int __stdcall Add()
会转换为Add@0，这样你在VB中必须这样声明：
Declare Function Add Lib "DLLTestDef.dll" Alias "Add@0" () As Long
@后面的数由于参数类型不同而可能不同。这显然不太方便。所以如果要想避免这种转换，就要使用.def文件方式导出函数了。

本文链接

Adding vertical guides to the Visual Studio text editor

2010-07-26T03:43:00Z

Adding vertical guides to the Visual Studio text editor

Something that I’ve done and liked since VS2005, has been to add vertical guides to the VS text editor. For example:

I like putting them at the first several tab stops as it helps keep track of indenting. I also have one at position 79 so I know where to wrap lines and comments. So, how do you do this? Well, it’s a registry entry. Here are the entries for each version of Visual Studio:

Visual Studio 2005:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\Text Editor]
"Guides"="RGB(230,230,255) 4, 8, 12, 16, 20, 24, 28, 32, 79"

Visual Studio 2008:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\Text Editor]
"Guides"="RGB(230,230,255) 4, 8, 12, 16, 20, 24, 28, 32, 79"

Visual Studio 2010:

Bad news, here. Since the text editor is VS2010 is now a WPF control – this same registry entry doesn’t have any affect. If I find the equivalent of this for VS2010, I will try to post it up here.

UPDATE (4/24/2010): I found this was reported for VS2010, but it will not be implemented. Although there is a link in there of how you might be able to write your own extension that does this. See: https://connect.microsoft.com/VisualStudio/feedback/details/490930/text-editor-guides

Meanwhile, I just found that on the Visual Studio Gallery, someone implemented this. It's just a quick download and the same registry entry (exception "10.0" vs "8.0", below) works!!!

Download: http://visualstudiogallery.msdn.microsoft.com/en-us/0fbf2878-e678-4577-9fdb-9030389b338c

You can either go modify the registry by hand (WARNING: standard “do not modify the registry!” warnings apply) – or you can copy/paste the contents above into a text file and name it something like “VerticalGuides.reg” – then double-click it to run it.

Also, the RGB is what you might expect – this is what sets the color of the line. So (255,0,0) is all red, (0,255,0) is all green, and (0,0,255) is all blue – and combinations of those are somewhere in-between. After that, the comma-separated list is a list of the vertical positions where you want the actual lines.

Lastly, to remove the guides, just create another file called “RemoveVerticalGuides.reg”, paste the contents below and double-click to run:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\Text Editor]
"Guides"=-

Setting a value to “-“ in a .reg file deletes that entry. Anyhow, I find this very useful so I thought I would post it.
本文链接