学习编程艺术的心得、知识总结1（长期更新）

本文章用于记录阅读七月大神的博客编程艺术的心得、知识，在看了两三章节的过程中，每次都是先看思路，自己编写调试后和他的代码对比，在自己编写过程中，发现了自己对编程知识方法的许多错误使用，同时学习到了简洁的编程方式。在整个阅读过程，想到遇到什么都记录一下，在反思中学习进步！！

七月的编程艺术github版网址：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/Readme.md。

一、字符串包含

知识点：

1、对string类型的变量a使用sort排序：

sort(a.begin(),a.end());

2、算法的位运算实现，比较经典，对位操作比较陌生，代码记录在此，方便随时学习。

// “最好的方法”，时间复杂度O(n + m)，空间复杂度O(1)
bool StringContain(string &a,string &b)
{
    int hash = 0;
    for (int i = 0; i < a.length(); ++i)
    {
        hash |= (1 << (a[i] - 'A'));
    }
    for (int i = 0; i < b.length(); ++i)
    {
        if ((hash & (1 << (b[i] - 'A'))) == 0)
        {
            return false;
        }
    }
    return true;
}

二、字符串转换为整数

按照最初的想法，直接读取字符串中的一个，然后转为数字，然后以num=num*10+m更新即可，自己写了如下的函数来实现。

int StrToInt1(const char *str)
{
	int num=0;
	while(str)
	{
		int m=*str-'0';
		num=num*10+m;
		str++;
	}
	return num;
}

结果发现运行出错。原因是，str指针已经被赋值了，在str++的过程中，str始终不为一个空指针，while循环的判断条件一直成立，因此出错。此时，参考博客，将while判断改为*str==0即可，即指针指向的值为0。

知识点：

设置int型数的最大值和最小值，用位运算实现如下：

    static const int MAX_INT = (int)((unsigned)~0 >> 1);
    static const int MIN_INT = -(int)((unsigned)~0 >> 1) - 1;

三、回文判断

当实现函数的参数形式如下为string类型时：

bool palind(string *s, int n)

此时直接看成数组，设定i从0到s.length()/2即可。

当实现函数的参数形式如下时：

bool palind(const char *s, int n)

字符串用字符指针s来表示的，此时用两个指针指示首尾，依次改变指针指向进行比较。此时对两个指示指针赋值如下：

char *first,*last;
	first=s;
	last=s+n-1;

结果出现了如下错误：

error C2440: '=' : cannot convert from 'const char *' to 'char *'
在网上查找解决办法是进行强制转化，修改如下：

char *first=(char *)s;
char* last=(char *)(s+n-1);

四、字符串全排列

输入一个字符串，打印出该字符串中字符的所有排列。例如输入字符串abc，则输出由字符a、b、c 所能排列出来的所有字符串abc、acb、bac、bca、cab 和 cba。

在看到题目后，想到以前做过的一个深度优先遍历题目，此题也可使用此思路，从a开始查找到b再到底部c返回一条路径，然后向上返回，查找到c再到b。然后返回到最开始，从b开始查找。

下面是基于此深度搜索的实现代码：

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

string a="abcd";
int lu[4];  //保存路径
int rest[4];//剩余未访问的字符
int j=0,restone_temp=-1; //j为路径计数，restone_temp为剩余一个未访问时，此未访问节点的下标，

<span style="white-space:pre">		</span>//因为剩余一个未访问时，路径已经确定，此设置方便返回到上一步选择的节点
bool restone()  //判断是否剩余一个未访问
{
	int count=0;
	int k=-1;
	for(int i=0;i<a.length();i++)
	{
		if(rest[i]==1)
		{
			count++;
			k=i;
		}
			
	}
	if(count==1)
	{
		restone_temp=k;  //记录还有一个未访问时，此节点的下标
		return true;
	}		
	else
		return false;
}
void strsort()
{
	if(restone())   //剩余一个即确定了组合方式，打印结果
	{
		for(int i=0;i<a.length()-1;i++)
			cout<<a[lu[i]];
		cout<<a[restone_temp];
		cout<<endl;
		return;
	}
	
	for(int i=0;i<a.length();i++)
	{
		if(rest[i])
		{
			rest[i]=0;
			lu[j++]=i;
			strsort();  //递归

			rest[i]=1;  //返回上一步选择的节点，如果访问到最后一个才返回，需要向上返回两次，
			j--;<span style="white-space:pre">	</span>//但返回两次时，向上返回的节点难以确定
		}		
	}
}

int main()
{
	for(int i=0;i<a.length();i++)
		rest[i]=1;
	strsort();
	return 0;
}

(⊙﹏⊙)汗。。检查了一下代码，发现上述的代码判断剩余一个未访问的操作完全多余，在递归过程中，在向上返回一次时，因为没有其他路径可走，又会自动向上返回一次，因此上述代码严重冗余。 对深度搜索的递归实现认识还不足，需要进一步学习。 改进的代码如下：

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

string a="abcd";
int lu[4];
int rest[4];
int j=0;

bool norest()  //判断是否所有点已经被访问
{
	for(int i=0;i<a.length();i++)
	{
		if(rest[i]==1)
			return false;			
	}
	return true;
}

void strsort()
{
	if(norest())  //所有点被访问，打印路径
	{
		for(int i=0;i<a.length();i++)
			cout<<a[lu[i]];
		cout<<endl;
		return;
	}
	for(int i=0;i<a.length();i++)
	{
		if(rest[i])
		{
			rest[i]=0;
			lu[j++]=i;
			strsort();

			rest[i]=1;
			j--;
		}		
	}
}

int main()
{
	for(int i=0;i<a.length();i++)
		rest[i]=1;
	strsort();

	return 0;
}

而作者文中的递归实现，使用了交换操作，勉强理解了，感觉实现有点复杂。

第二种方法是基于字典序排列，即使用了STL中的next_permutation算法思想来实现的，再往后的实现中，可直接循环调用此函数来实现全排列，可大大简化代码，下面用此函数实现字符串的全排列如下：

#include<iostream>
#include<string>
#include <algorithm>
using namespace std;

int main()
{
	char ch[200];
	cin>>ch;
	sort(ch,ch+strlen(ch));
	do{
		cout<<ch<<endl;
	}while(next_permutation(ch, ch+strlen(ch)));

	return 0;
}

思考题中，已知字符串里的字符是互不相同的，现在任意组合，比如ab，则输出aa，ab，ba，bb，作者提供的解决方法非常巧妙，也是基于递归实现的，记录在此：

#include<iostream>
#include<string>
#include <algorithm>
using namespace std;

void perm(char* result, char *str, int size, int resPos)
{
  if(resPos == size)
    printf("%s\n", result);
  else
    {
      for(int i = 0; i < size; ++i)
        {
          result[resPos] = str[i];
          perm(result, str, size, resPos + 1);
        }
    }
}

int main()
{
	char ch[200];
	cin>>ch;
	sort(ch,ch+strlen(ch));
	char result[200]={0};
	perm(result,ch,strlen(ch),0);

	return 0;
}

五、最小的K个数

其中使用堆来维护K个数的集合还没实现，因为一直以来对堆就很陌生，所以没实现。下面是直接根据快速选择思路实现的代码：

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

int median3(int a[],int first,int last)
{
	int midium=(first+last)/2;
	if(a[first]>a[midium]&&a[first]>a[last])
	{
		if(a[midium]>a[last])
			return midium;
		else 
			return last;
	}
	if(a[first]<a[midium]&&a[first]<a[last])
	{
		if(a[midium]<a[last])
			return midium;
		else 
			return last;
	}
	return first;
}

void quickselect(int s[],int first,int last,int k)
{
	int m=0,n=0;
	int piv=0;
	int s1[100],s2[100];
	
	piv=median3(s,first,last);
	for(int i=0;i<=last;i++)
	{
		if(s[i]>=s[piv])
		{
			s2[n++]=s[i];
		}
		else 
			s1[m++]=s[i];
	}
	if(k>m)
	{
		for(int j=first;j<n;j++)
			cout<<s1[j]<<" ";
		quickselect(s2,0,n-1,k-m);
	}		
	else if(k<m)
		quickselect(s1,0,m-1,k);
	else
	{
		for(int j=first;j<m;j++)
			cout<<s1[j]<<" ";
		cout<<endl;
	}
}

int main()
{
	int arr[100]={462359,161047,2346,716099,189159,264108,905891,115240,473403,221514,
				723403,684465,257361,34611,535903,478932,345173,117798,693203,593953};
	quickselect(arr,0,19,10);	
	return 0;
}