[简单异或]
下面是一个简单异或的对称加解密算法。明文用一个关键字做异或运算以产生密文。因为用同一值去异或两次就可以恢复出原来的值 ，所以加密和解密都严格采用同一程序。即：
P XOR K = C
C XOR K = P
这种方法比较简单，没有实际的保密性，甚至没有计算机也能够破译。
一种思路是使用重合码计数法 找出密钥的长度，按此长度移动密文，并且和自身异或。

[异或的好处]
在算法中经常会用到异或运算。比如下面两种常见的情况：
(1) 在1,1,2,2,3,3…k,k…n,n个数的序列中，删除任意一数并求此数。
此时用XOR就比较方便，如果通过求和的话，要考虑溢出的情况，而用XOR绝对不会发生溢出。
(2) 交换两个整形变量。
x^=y;
y^=x;
x^=y;

运行结果：

PS: 老邓的写法，也记录在这里

01.#include <iostream>
02.using namespace std;
03.int main()
04.{
05.    char Msg[133] = “This is a plaintext”;
06.    cout << Msg << endl;
07.    char Key[8] = “abcde”;
08.    for (int i = 0; i < 133; ++i)
09.        Msg[i] ^= Key[i % 8];
10.    cout << Msg << endl;
11.    for (int i = 0; i < 133; ++i)
12.        Msg[i] ^= Key[i % 8];
13.    cout << Msg << endl;
14.    return 0;
15.}

from http://blog.csdn.net/delphiwcdj/article/details/5921771#comments

// 常量
#define C1 52845
#define C2 22719
CString Encrypt(CString S, WORD Key) // 加密函数
{
CString Result,str;
int i,j;

Result=S; // 初始化结果字符串
for(i=0; i<S.GetLength(); i++) // 依次对字符串中各字符进行操作
{
   Result.SetAt(i, S.GetAt(i)^(Key>>8)); // 将密钥移位后与字符异或
   Key = ((BYTE)Result.GetAt(i)+Key)*C1+C2; // 产生下一个密钥
}
S=Result; // 保存结果
Result.Empty(); // 清除结果
for(i=0; i<S.GetLength(); i++) // 对加密结果进行转换
{
   j=(BYTE)S.GetAt(i); // 提取字符
   // 将字符转换为两个字母保存
   str="12"; // 设置str长度为2
   str.SetAt(0, 65+j/26);//这里将65改大点的数例如256，密文就会变乱码，效果更好，相应的，解密处要改为相同的数
   str.SetAt(1, 65+j%26);
   Result += str;
}
return Result;
}

CString Decrypt(CString S, WORD Key) // 解密函数
{
CString Result,str;
int i,j;

Result.Empty(); // 清除结果
for(i=0; i < S.GetLength()/2; i++) // 将字符串两个字母一组进行处理
{
   j = ((BYTE)S.GetAt(2*i)-65)*26;);//相应的，解密处要改为相同的数

   j += (BYTE)S.GetAt(2*i+1)-65;
   str="1"; // 设置str长度为1
   str.SetAt(0, j);
   Result+=str; // 追加字符，还原字符串
}
S=Result; // 保存中间结果
for(i=0; i<S.GetLength(); i++) // 依次对字符串中各字符进行操作
{
   Result.SetAt(i, (BYTE)S.GetAt(i)^(Key>>8)); // 将密钥移位后与字符异或
   Key = ((BYTE)S.GetAt(i)+Key)*C1+C2; // 产生下一个密钥
}
return Result;
}
用法
CString text=_T("192.168.18.14");//需要加密的字符串
WORD key=1314;//key
CString jiami=Encrypt(text,key);//加密
AfxMessageBox(_T("密文:")+jiami);
CString jiemi=Decrypt(jiami,key);//解密
AfxMessageBox(_T("原文:")+jiemi);

#include <iostream> 
using namespace std; 
int main( ) 
{ 
    double dSalary ,dTax =0,dNetIncome=0; 
    cout<<"请输入您本月的收入总额（元）:"; 
    cin>>dSalary; 
    if(dSalary<3500) 
        cout<<"您不需要缴纳个人所得税:"<<endl; 
    else 
    { 
        if(dSalary>=3500&&dSalary<5000) 
            dTax=(dSalary-3500)*0.03-0; 
        if(dSalary>=5000&&dSalary<8000) 
            dTax=(dSalary-3500)*0.1-105; 
        if(dSalary>=8000&&dSalary<12500) 
            dTax=(dSalary-3500)*0.2-555; 
        if(dSalary>=12500&&dSalary<38500) 
            dTax=(dSalary-3500)*0.25-1005; 
        if(dSalary>=38500&&dSalary<58500) 
            dTax=(dSalary-3500)*0.3-2755; 
        if(dSalary>=58500&&dSalary<83500) 
            dTax=(dSalary-3500)*0.35-5505; 
        if(dSalary>=83500) 
            dTax=(dSalary-3500)*0.45-13505; 
    } 
    dNetIncome=dSalary-dTax; 
    cout<<"您本月应缴纳个人所得税"<<dTax<<"元,税后收入是"<<dNetIncome<<"元。n"; 
    cout<<"依法纳税，共享繁荣！谢谢使用！n"; 
    return 0; 
}

一、快速排序原理

       快速排序也和合并排序一样，基于分治法，分为分解、解决、合并三个步骤；

       分解：数组array[low...high]被分为两个(可能空)子数组array[low...temp-1]和array[temp+1...high]，使得array[low...temp-1]中的每一个元素都小于等于array[temp]，而array[temp+1...high]中的每一个元素都大于array[temp]，下标temp也是在这个过程中被计算出来；

       解决：通过递归的调用快速排序，对子数组array[low...temp-1]，array[temp+1...high]进行排序；

       合并：因为两个子数组是就地排序的，将他们的合并不需要操作，整个数组array[low...high]是已经排好序的。

二、快速排序实现

#include <iostream>
#include <ctime>
#include <cstdlib>
#define N 10

using namespace std;

//快速排序的递归算法
void quickSort(int * array , int low , int high);
//求分割点
int partition(int * array , int low , int high);
//交换两个变量的值
void exchange(int &a,int &b);

int main()
{
	//声明一个待排序数组   
    int array[N];  
    //设置随机化种子，避免每次产生相同的随机数    
    srand(time(0));   
    for(int i=0 ; i<N ; i++)    
    {    
        array[i] = rand()%101;//数组赋值使用随机函数产生1-100之间的随机数      
    }    
    cout<<"排序前："<<endl;    
    for(int j=0;j<N;j++)    
    {    
        cout<<array[j]<<"  ";    
    }   
    cout<<endl<<"排序后："<<endl;    
    //调用快速排序函数对该数组进行排序      
    quickSort(array,0,N-1);   
    for(int k=0;k<N;k++)    
    {    
        cout<<array[k]<<"  ";    
    }    
    cout<<endl;    
    return 0;    
}//main

void quickSort(int * array , int low , int high)
{
	if(low < high)
	{
		int temp = partition(array , low , high);
		quickSort(array , low , temp-1);
		quickSort(array , temp+1 , high);
	}
}

int partition(int * array , int low , int high)
{
	int i = low - 1;
	int x = array[high];

	for(int j=low ; j<high ; j++)
	{
		if(array[j] <= x)//在array[i]左边都是小于x即array[high]的数，右边均是大于它的数
		{
			i += 1;
			exchange(array[i],array[j]);
		}
	}
	exchange(array[i+1],array[high]);
	return i+1;//所以循环完毕后，i+1就是该数组的分割点
}
void exchange(int &a,int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

       堆排序还引入了另外一种算法设计技术，利用某种数据结构(在此算法中为“堆”)来管理算法执行中的信息。堆数据结构不只在堆排序算法中有用，还可以构成一个有效的优先队列。堆数据结构是一种数组对象，它可以被视为一颗完全二叉树，树种每个结点与数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外(最后一层从一个结点的左子树开始填)。

 一、堆排序算法原理

       开始时，堆排序算法先用BuildMaxHeap()函数将n个元素的输入数组array[0...n-1]建造成一个大顶堆。因为数组中最大元素在对应堆树的根A[1]，所以可以通过把它与A[n]互换来达到最终正确的位置。现在如果从堆中“去掉”结点n(通过减小堆大小HeapSize)，可以很容易的将这一数组转换成一个最大堆。原来根的子女仍是最大堆，而新的堆元素可能违背了最大堆性质。这时调用MaxHeapify(array ,temp)函数就可以保持这一性质，由此在A[1...n-1]中构造出最大堆。堆排序算法不断重复这个过程，堆的大小从n-1一直降到2。

二、堆排序算法的实现

#include <iostream>
#include <time.h>
#include <stdlib.h>
#define N 10
using namespace std;

//声明建大顶堆函数
void BuildMaxHeap(int * array);
//声明堆排序函数
void HeapSort(int * array);
//声明调整为大顶堆函数
void MaxHeapify(int * array,int n);
//返回堆的数据个数
int HeapSize;

int main()
{
	//声明一个待排序数组
	int array[N];
	//设置随机化种子，避免每次产生相同的随机数 
	srand(time(0));	
	for(int i=0 ; i<N ; i++)  
    {  
        array[i] = rand()%101;//数组赋值使用随机函数产生1-100之间的随机数   
    }  
    cout<<"排序前："<<endl;  
    for(int j=0;j<N;j++)  
    {  
        cout<<array[j]<<"  ";  
    } 
    cout<<endl<<"排序后："<<endl;  
    //调用堆排序函数对该数组进行排序   
    HeapSort(array); 
    for(int k=0;k<N;k++)  
    {  
        cout<<array[k]<<"  ";  
    }  
    cout<<endl;  
    return 0;  
}

void HeapSort(int * array)
{
	BuildMaxHeap(array);
	for(int i=N-1 ; i>=0 ; i--)//数组中下标从0  -  N-1
	{
		int temp = array[0];
		array[0] = array[i];
		array[i] = temp;		
		HeapSize -= 1;
		MaxHeapify(array,1);//在堆中，堆顶元素下标从1开始
	}
}

void BuildMaxHeap(int * array)
{
	HeapSize = N;
	for(int i = (N-1)/2 ; i>=1 ; i--)//注意i的取值,堆的高度从1  -  (N-1)/2
	{
		MaxHeapify(array,i);
	}
}

void MaxHeapify(int * array,int temp)
{
	int largest;//以temp为顶点的子树的堆顶
	int l = 2*temp ;//求以temp为顶点的子树左儿子
	int r = 2*temp+1;//求以temp为顶点的子树右儿子

	if(l <= HeapSize && array[l-1] > array[temp-1])//首先判断左儿子是否存在，即l<=HeapSize
	{
		largest = l;
	}else{
		largest = temp;
	}

	if(r <= HeapSize && array[r-1] > array[largest-1])//首先判断右儿子是否存在，即r<=HeapSize
	{
		largest = r;
	}

	if(largest != temp)
	{
		int t = array[temp-1];
		array[temp-1] = array[largest-1];
		array[largest-1] = t;
		MaxHeapify(array,largest);//调整为大顶堆
	}
}

#include <iostream>
#include <algorithm>
using namespace std;
void insert(int a[], int len)
{
	/*
		1.从第二个开始，把第二个抽出来当临时变量，这时假设这个位置是空的
		2.当左边的数据比这个临时变量大时，将左边的数值向右移动，
		  直到遇到左边，直到左边的数据小于这个临时变量为止
		3.将这个临时变量插入到这个空位置上
		  排序数组：5 7 4 2 6
		  第一次  
			temp = 7
			5 0 4 2 6--》左边的比这个临时变量小，且已经到达了最左端
			5 7 4 2 6（结束）

		  第二次
			temp = 4
			5 7 0 2 6
			5 5 7 2 6
			5 5 7 2 6
			4 5 7 2 6 (结束)

		  第三次
			temp = 2
			4 5 7 7 6
			4 5 5 7 6
			4 4 5 7 6
			2 4 5 7 6 (结束)

		 第四次
			temp = 6
			2 4 5 7 7
			2 4 5 6 7 (结束) 因为左边的5比6小，所以就停止将左边的数据右移了，将临时变量插入到这里
	*/
	for (int i=1; i<len; i++)
	{
		cout<<"第"<<i<<"次排序："<<endl;

		int temp = a[i];		//定义临时变量
		cout<<"temp = "<<temp<<endl;
		
		int j;		
		//当 (j>0) 遇到最左端时，或者，(a[j-1] > temp) 左边的数据比这个临时变量小时，停止
		for (j=i; j>0&&a[j-1]>temp; j--)
		{
			a[j] = a[j-1];//将左边的数值向右移到右边

			//循环输出，看看排序经过
			for (int y=0; y<len; y++)
			{
				cout<<a[y]<<" ";
			}
			cout<<endl;
		}
		cout<<"要插入的位置 j = "<<j<<endl;
		cout<<"要插入的位置上的值 a[j] = "<<a[j]<<endl;
		a[j] = temp;	//将这个临时变量插入到这个空位上

		//循环输出，看看排序经过
		cout<<"第"<<i<<"次排序后的结果："<<endl;
		for (int k=0; k<len; k++)
		{
			cout<<a[k]<<" ";
		}
		cout<<endl<<endl;
	}
}

void show(int a[], int len)
{
	for (int i=0; i<len; i++)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}

int main()
{
	int a[5] = {5,7,4,2,6};

	cout<<"插入排序："<<endl;
	cout<<"排序前："<<endl;
	show(a, 5);
	cout<<endl;
	insert(a, 5);
	cout<<endl;
	cout<<"排序后："<<endl;
	show(a, 5);
	return 0;
}

插入排序InsertionSort，参数是一个数组包含了n个待排序的数，输入的各个数字是原地排序的（sorted in place），意即这些数字就是在数组A中进行重新排序的，在任何时刻，至多只有其中的常数个数字是存储在数组之外的，当过程InsertionSort执行完毕后，输入数组A中就包含了已排好序的数组输出序列。

下面是利用C++语言实现的插入排序代码:

#include <iostream>
#define N 10
using namespace std;
//声明插入排序函数
int* insertionSort(int *array,int length);
int main()
{
	int array[N] = {2,1,3,67,35,12,9,7,45,0};
	insertionSort(array,N);
	for(int i=0;i<N;i++)
	{
		cout<<array[i]<<endl;
	}
	return 0;
}

int * insertionSort(int * array,int length)
{
	for(int i=1;i<length;i++)
	{
		int key = array[i];
		int j = i-1;
		while(j>=0 && array[j]>key)//注意j的取值>=0
		{
			array[j+1] = array[j];	
			j=j-1;
		}//while
			array[j+1] = key;
	}//for
	return array;
}

插入排序的算法复杂性分析：对于插入排序，它的复杂性依赖于待排序数组的一些属性，待排序数组长度、已排好序程度等。我们一般考察最坏情况下即逆序排序和最佳情况下即已排好序的复杂性。

最佳情况下：此时待排序数组已经是一个排好序的数组，推理可得程序运行时间可以表示为an+b；因此，它是n的一个线性函数。

最坏情况下：此时待排序数组是一个逆序数组，此时，我们必须把每个元素array[i]与整个已排序的子数组array[1...i-1]中的每个元素进行比较，因而，最坏情况下程序的运行 时间为an^2+bn+c，这是一个关于n的二次函数。

一般来说，如同插入排序一样，一个算法的运行时间对某一给定的输入来说，往往是固定的。

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

void select(int a[], int len)
{
	/*
		1. 将第一个数的位置设为最小位置，然后将这个数与后面所有的数进行比较
		2. 如果这个最小数大于后面的数， 则将后面这个值所在的位置设为最小位置
		3. 再用这个新的最小位置的最小值向后比较，直到没有比最小值更小的
	
			排序数组: 5 7 4 2 6
			第一次排序：
				min = 0   最小值：a[0] = 5
				5(最小)  7  4  2  6
				5  7  4(最小)  2  6		min = 2   比较：5<-->4
				5  7  4  2(最小)  6		min = 3	  比较：4<-->2
				排序后：2  7  4  5  6

			第二次排序：
				min = 1   最小值：a[1] = 7
				2  7(最小)  4  5  6  
				2  7  4(最小)  5  6		min = 2   比较：7<-->4
				2  7  4(最小)  5  6		min = 3	  比较：4<-->5
				2  7  4(最小)  5  6     min = 4   比较：4<-->6
				排序后：2  4  7  5  6

			第三次排序:
				min = 2   最小值：a[2] = 7
				2  4  7(最小  5  6
				2  4  7  5(最小)  6		min = 3   比较：7<-->5
				2  4  7  5(最小)  6     min = 3   比较：5<-->6
				排序后：2  4  5  7  6

			第四次排序：
				min = 3   最小值：a[3] = 7
				2  4  5  7(最小)  6
				2  4  5  7  6(最小)		min = 4   比较：7<-->6
				排序后：2  4  5  6  7
				
	*/
	for (int i=0; i<len; i++)
	{
		cout<<"第"<<i+1<<"次排序："<<endl;
		int min = i;	//制定第一个位置为最小值

		//循环依次向后比较
		for (int j=i+1; j<len; j++)
		{
			cout<<"旧的最小值 a[min] = "<<a[min];
			if (a[j]<a[min])//将后面的位置和最小值比较
				min = j;	//如果比最小值还小，则将新的位置设为最小位置
							//用交换后的这个最小值，再与后面的值进行比较
			cout<<", 新的最小值 a[min] = "<<a[min]<<endl;
			cout<<"交换后的最小位置 min = "<<min<<endl;
		}
		swap(a[min], a[i]);//将最小值排到最前

		//输出一轮排序后的结果
		cout<<"第"<<i+1<<"次排序的结果：";
		for (int x=0; x<len; x++)
		{
			cout<<a[x]<<" ";
		}
		cout<<endl<<endl;;
	}
}

void show(int a[], int len)
{
	for (int i=0; i<len; i++)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}

int main()
{
	int a[5] = {5,7,4,2,6};

	cout<<"选择排序："<<endl;
	cout<<"排序前："<<endl;
	show(a, 5);
	cout<<endl;
	select(a, 5);
	cout<<endl;
	cout<<"排序后："<<endl;
	show(a, 5);
	return 0;
}

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

void bubble(int a[], int len)
{
	/*   
	* 从头开始向后，一次结束后，最后的那个数就是最大的，   
	* 然后长度减一，就是减去最后那个最大的数，因为它不需要再排序了   

	* 当一次排序结束后，再从头开始，依次往后，结束后，最后一个又是最大的   

	7  4  2  6   
	4  7  2  6  
	5  4  2  7  6   

	5  4  2  6  7(最大)  第一轮结束   

	4  5  2  6   
	4  2  5  6(最大) 第二轮结束   
	2  4  5(最大)  第三轮结束   
	2  4(最大) 第思轮结束   
	2(最大)   
	*/   
	cout<<"冒泡排序法："<<endl;
	int flag;//判断是否发生了交换 0：无交换  1：交换 
	do
	{
		flag = 0;//清零 
		for (int i=1; i<len; i++)
		{
			cout<<"第"<<i<<"次排序: "<<endl;
			if (a[i] < a[i-1])
			{
				swap(a[i], a[i-1]);
				for (int j=0; j<len; j++)
				{
					cout<<a[j]<<"  ";
				}
				cout<<endl;
				flag = 1;
			}   
		}
		--len;  //每次排序后都是长度减少1，提高效率 
	} while(flag == 1);

	//cout<<"第 "<<i<<" 次排序"<<endl; 
}
void show(int a[], int len)
{
	for (int i=0; i<len; i++)
	{
		cout<<a[i]<<"  ";
	}
	cout<<endl;
}

int main(int argc, char* argv[])

{
	int a[5] = {5,7,4,2,6};
	cout<<"排序前："<<endl;
	show(a, 5);
	bubble(a, 5);
	cout<<"排序后："<<endl;
	show(a, 5);
	getchar();
	return 0;
}