#include<stdio.h>
#include<time.h>clock_t start,stop;
//clock_t是clock（）函数返回的变量类型
double duration;
//记录被测函数运行时间，以秒为单位
int main(）
{//不在测试范围内的准备工作写在clock（）调用之前start=clock();//开始计时MyFunction()；//把被测函数加在这里stop=clock()；duration=((double)(stop-start))/CLK_TCK;//其他不再被测范围的处理写在后面，例如输出duration的值return 0;

typedef struct Node{int data;//这里默认的是int型，如需其他类型那个可直接修改struct Node *next;//指向Node型变量的指针
}Node;

 typedef struct BTNode{int data;struct BTNode *lchild;struct BTNode *rchild;}BTNode;

//BF算法，暴力算法
int index(Str str,Str substr)
{int i=0,j=0,k=i;while(i<str.length&&j<substr.length){if(str.ch[i]==substr.ch[j]){++i;++j;}else{j=0;i=++k;//匹配失败，i从主串下一位置开始，k种记录了上一次的启示位置
        }}if(j==substr.length)return k;else return -1;
}
//KMP算法
int KMP(Str str,Str substr,int next[])
{int i=0,j=0;while(i<str.length&&j<substr.length){if(str.ch[i]==substr.ch[j]){++i;++j;}else{j=next[i];if(j==-1){j=0;++i;}}}if(j==substr.length)return i-substr.length;else return -1;
}
求next数组的算法如下
void getnext(Str sbustr,int next[])
{int i=0;j=-1;next[0]=-1;while(i<substr.length){if(j==-1||substr.ch[i]==sbustr.ch[j]){++i;++j;next[i]=j;}elsej=next[j];}
}

#include<stdio.h>
#include<math.h>
#define MAXNUM 10//希尔排序void shellSort(int array[],int n,int t){int a,dk;for(a=1;a<=t;a++){dk=(int)(pow(2,t-a+1)-1);//计算增量 int i,j,temp;for(i=dk;i<n;i++)//分别向每组的有序区域进行插入
           {temp=array[i];for(j=i-dk;(j>=i%dk)&&array[j]>temp;j-=dk)//比较与记录后移同时进行array[j+dk]=array[j];if(j!=i-dk)array[j+dk]=temp;//插入
            }    }} void main(){void shellSort(int array[],int n,int t);//t为排序的趟数int array[MAXNUM],i;for(i=0;i<MAXNUM;i++)scanf("%d",&array[i]);shellSort(array,MAXNUM,(int)(log(MAXNUM+1)/log(2)));//排序趟数应为long2（n+1）的整数部分for(i=0;i<MAXNUM;i++)printf("%d ",array[i]);printf("\n"); }

#include <stdio.h>
#include <stdlib.h>#define MAXNUM 10
/* run this program using the console pauser or add your own getch, system("pause") or input loop */void maopaoInsert(int R[],int n)
{int i,j,temp;for(j=0;j<n-1;j++)//总共需要排序的次数
    {for(i=0;i<n-1-j;i++)//此趟需要排序的个数，也就是从0 .....n-1-j。进行比较
        {if(R[i]>R[i+1])//每次进行两两比较
            {temp=R[i];R[i]=R[i+1];R[i+1]=temp;}}}} void main(){int array[MAXNUM],i;for(i=0;i<MAXNUM;i++)scanf("%d",&array[i]);maopaoInsert(array,MAXNUM);//排序趟数应为long2（n+1）的整数部分for(i=0;i<MAXNUM;i++)printf("%d ",array[i]);printf("\n"); }

#include <stdio.h>
#include <stdlib.h>#define MAXNUM 10void kuaisuSort(int a[],int left,int right)
{if(left>=right)//如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了
    {return; } int i=left;int j=right;int key=a[left];//以a[left]为轴中心while(i<j)//控制在当组内寻找一遍
    {while(i<j&&key<=a[j])//而寻找结束的条件就是，1，找到一个小于或者大于key的数，没有符合条件1的，并且i与j的大小没有反转
        {j--;//向前寻找
        } a[i]=a[j];// 找到一个这样的数后就把他赋给前面的被拿走的i的值（如果第一次循环且key是a[left],那么就是key) while(i<j&&key>=a[i])//这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，因为排序思想就是把数组网两边礽，所以左右两边的数大小与key的关系相反
        {i++;}a[j]=a[i];}      a[i]=key;//当在当组内找完一遍以后就把中间数key回归kuaisuSort(a,left,i-1);//最后用同样的方式把对分出来的左边的小组进行同上的做法kuaisuSort(a,i+1,right);//最后用同样的方式把对分出来的右边的小组进行同上的做法 //当然最后可能会出现很多分左右，直到每一组的i=j为止。
 }
void main(){int array[MAXNUM],i;for(i=0;i<MAXNUM;i++)scanf("%d",&array[i]);kuaisuSort(array, 0,MAXNUM-1); for(i=0;i<MAXNUM;i++)printf("%d ",array[i]);printf("\n"); }

#include <stdio.h>
#include <stdlib.h>#define MAXNUM 10
/* run this program using the console pauser or add your own getch, system("pause") or input loop */void jiandanxuanzeSort(int R[],int n)
{int i,j,min;int minR;//储存最小的数组 int temp;for(i=0;i<n;i++){minR=R[i];////假设R[i]为本轮最小值 min=i;//将 最小值下标存储在min中 for(j=i+1;j<n;j++)//从i到n查找最小值
        {if(R[j]<minR)//如果有R[j]小于最小值
            {minR=R[j];//那么把R[j]赋值给minR行调换 min=j;}}//将寻找到的最小值R[min]与本轮的R[i]对换 temp=R[i];R[i]=R[min];R[min]=temp;}
}void main(){int array[MAXNUM],i;for(i=0;i<MAXNUM;i++)scanf("%d",&array[i]);jiandanxuanzeSort(array,MAXNUM); for(i=0;i<MAXNUM;i++)printf("%d ",array[i]);printf("\n"); }

//最大公约数
int gcd(int v1,int v2)
{while(v2){int temp=v2;v2=v1%v2;v1=temp; }    return v1;
} 

#include <iostream>using namespace std;void swap(int *px, int *py)
{int temp;temp=*px;*px=*py;*py=temp;
}int main()
{int a,b;a = 1;b = 10;cout << "传指针的方法: " << endl;cout << "a = " << a << ", b = " << b << endl;//拷贝的指针(地址) swap(&a,&b);cout << "a = " << a << ", b = " << b << endl;return 0;
}

#include <iostream>#define SWAP(x,y,t) ((t)=(x),(x)=(y),(y)=(t))
using namespace std;int main()
{int a, b, temp;a = 1;b = 10;cout << "使用宏定义函数: " << endl;cout << "a = " << a << ", b = " << b << endl;SWAP(a,b,temp);cout << "a = " << a << ", b = " << b << endl;return 0;
}

#include <iostream>using namespace std;//引用就是别名
void swap(int &a,int &b)
{int temp;temp=a;a=b;b=temp;}
int main()
{int a,b;a = 1;b = 10;cout << "传引用: " << endl;cout << "a = " << a << ", b = " << b << endl;swap(a,b);cout << "a = " << a << ", b = " << b << endl;return 0;
}

#include <iostream>using namespace std;int main()
{int a, b;a = 1;b = 10;cout << "使用std::swap函数: " << endl;cout << "a = " << a << ", b = " << b << endl;std::swap(a,b);cout << "a = " << a << ", b = " << b << endl;return 0;
}

#include <iostream>using namespace std;#define MAX_VERTS 20 //保存最多的顶点数 //顶点
class Vertex
{public:Vertex(char lab){Label=lab;    } private:char Label;};//图  邻接矩阵 (对称)
class Graph
{public:Graph();~Graph();void addVertex(char lab);//增加顶点 void addEdge(int start,int end);//增加边void printMatrix();//打印矩阵 private:Vertex* vertexList[MAX_VERTS];//数组(保存最多的定点数) int nVerts;//实际上的顶点数 int adjMat[MAX_VERTS][MAX_VERTS]; //邻接矩阵
} ;//构造函数，有效点为0，初始化矩阵
Graph::Graph()
{nVerts=0;for(int i=0;i<MAX_VERTS;i++){for(int j=0;j<MAX_VERTS;j++){adjMat[i][j]=0;}    }} //增加点 void Graph::addVertex(char lab){vertexList[nVerts++]=new Vertex(lab);}// 增加边 (对称)
void Graph::addEdge(int start,int end){adjMat[start][end]=1;adjMat[end][start]=1;}//打印 void Graph::printMatrix(){for(int i=0;i<nVerts;i++){for(int j=0;j<nVerts;j++){cout<<adjMat[i][j]<<" ";}cout<<endl;}}//析构函数 Graph::~Graph(){for(int i=0;i<nVerts;i++){delete vertexList[i];}}
int main()
{Graph a;a.addVertex('A');//下标 0 a.addVertex('B');//下标 1a.addVertex('C');//下标 2 a.addVertex('D');//下标 3 a.addVertex('E');//下标 4
    a.addEdge(0,1);//连线 A-B a.addEdge(0,3);//连线 A-D a.addEdge(1,0);//连线 B-A a.addEdge(1,4);//连线 B-E a.addEdge(2,4);//连线 C-Ea.addEdge(3,0);//连线 D-Aa.addEdge(3,4);//连线 D-Ea.addEdge(4,1);//连线 E-B a.addEdge(4,2);//连线 E-C a.addEdge(4,3);//连线 E-D
    a.printMatrix(); return 0;
}

#include <iostream>
#include <list>using namespace std;class Vertex
{
public:char Label;Vertex(char lab) { Label = lab; }
};ostream& operator<<(ostream& out, const Vertex& v)
{cout << v.Label;return out;
}template<class T>
class Graph
{
public:Graph(const int vertices) : n(vertices){VertexList = new T*[n];HeadNodes = new list<int>[n];nVerts = 0;}~Graph(){delete[] VertexList;delete[] HeadNodes;}void addVertex(T* v);void addEdge(int start, int end);void printVertice();void printAdjList();
private:T** VertexList;list<int>* HeadNodes;int n;int nVerts;
};template<class T>
void Graph<T>::addVertex(T* v)
{VertexList[nVerts++] = v;
}template<class T>
void Graph<T>::addEdge(int start, int end)
{HeadNodes[start].push_back(end);
}template<class T>
void Graph<T>::printVertice()
{for(int i=0; i<nVerts; i++)cout << *VertexList[i] << " ";cout << endl;
}template<class T>
void Graph<T>::printAdjList()
{for(int i=0; i<nVerts; i++){cout << i << " -> ";for(list<int>::iterator iter = HeadNodes[i].begin(); iter != HeadNodes[i].end(); ++iter)cout << *iter << " -> ";cout << "end" << endl;}
}int main()
{//Graph<char> g(5);//char a = 'A';//char b = 'B';//char c = 'C';//char d = 'D';//char e = 'E';Graph<Vertex> g(5);Vertex a('A');Vertex b('B');Vertex c('C');Vertex d('D');Vertex e('E');g.addVertex(&a);g.addVertex(&b);g.addVertex(&c);g.addVertex(&d);g.addVertex(&e);g.printVertice();g.addEdge(0,1);g.addEdge(0,3);g.addEdge(1,0);g.addEdge(1,4);g.addEdge(2,4);g.addEdge(3,0);g.addEdge(3,4);g.addEdge(4,1);g.addEdge(4,2);g.addEdge(4,3);g.printAdjList();system("pause");return 0;
}

#include <iostream>
#include<stack>#define MAX_VERTS    20using namespace std;class Vertex
{
public:Vertex(char lab) { Label = lab; wasVisited=false;//新构造的顶点没有访问过
    }
public:bool wasVisited; char Label;
};class Graph
{
public:Graph();~Graph();void addVertex(char lab);void addEdge(int start, int end);void printMatrix();void showVertex(int v);//显示顶点 void DFS();//深度优先搜索
private:Vertex* vertexList[MAX_VERTS];int nVerts;int adjMat[MAX_VERTS][MAX_VERTS];int getAdjUnvisitedVertex(int v); //获得临接的下一个且没有访问的顶点
};void Graph::DFS()
{stack<int> gStack;vertexList[0]->wasVisited=true;//顶点 showVertex(0);gStack.push(0);//顶点放入到堆栈 int v;while(gStack.size()>0){v=getAdjUnvisitedVertex(gStack.top());//总是以堆栈中最上一个为准 if(v==-1)// 如果没有，则返回
            gStack.pop();else//找到
        {vertexList[v]->wasVisited=true;showVertex(v);gStack.push(v); //找到放入到堆栈中
        }}cout<<endl;for(int j=0;j<nVerts;j++)//设置false 可以多次进行搜索 vertexList[j]->wasVisited=false;
}//获得临接的下一个且没有访问的顶点
//是否是邻接的？是否访问过
int Graph::getAdjUnvisitedVertex(int v)
{for(int j=0;j<nVerts;j++)if((adjMat[v][j]==1)&&(vertexList[j]->wasVisited==false))return j;return -1;
}
void Graph::showVertex(int v)
{cout<<vertexList[v]->Label<<" ";
}
Graph::Graph()
{nVerts = 0;for(int i=0; i<MAX_VERTS; i++)for(int j=0; j<MAX_VERTS; j++)adjMat[i][j] = 0;
}void Graph::addVertex(char lab)
{vertexList[nVerts++] = new Vertex(lab);
}void Graph::addEdge(int start, int end)
{adjMat[start][end] = 1;adjMat[end][start] = 1;
}void Graph::printMatrix()
{for(int i=0; i<nVerts; i++){for(int j=0; j<nVerts; j++)cout << adjMat[i][j] << " ";cout << endl;}
}Graph::~Graph()
{for(int i=0; i<nVerts; i++)delete vertexList[i];
}int main()
{Graph g;g.addVertex('A');// 0g.addVertex('B');// 1g.addVertex('C');// 2g.addVertex('D');// 3g.addVertex('E');// 4
g.addEdge(0,1); // A-Bg.addEdge(0,3); // A-Dg.addEdge(1,0); // B-Ag.addEdge(1,4); // B-Eg.addEdge(2,4); // C-Eg.addEdge(3,0); // D-Ag.addEdge(3,4); // D-Eg.addEdge(4,1); //E-B g.addEdge(4,2);//E-Cg.addEdge(4,3);//E-D
g.printMatrix();cout << "深度优先搜索的结果: ";g.DFS();system("pause");return 0;
}

#include <iostream>
#include <stack>
#include<queue> #define MAX_VERTS    20using namespace std;class Vertex
{
public:Vertex(char lab) { Label = lab; wasVisited = false;}
public:bool wasVisited;char Label;
};class Graph
{
public:Graph();~Graph();void addVertex(char lab);void addEdge(int start, int end);void printMatrix();void showVertex(int v);void DFS();void BFS();//广度优先
private:Vertex* vertexList[MAX_VERTS];int nVerts;int adjMat[MAX_VERTS][MAX_VERTS];int getAdjUnvisitedVertex(int v);
};void Graph::DFS()
{stack<int> gStack;vertexList[0]->wasVisited = true;showVertex(0);gStack.push(0);int v;while(gStack.size() > 0){v = getAdjUnvisitedVertex(gStack.top());if(v == -1)gStack.pop();else{vertexList[v]->wasVisited = true;showVertex(v);gStack.push(v);}}cout << endl;for(int j=0; j<nVerts; j++)vertexList[j]->wasVisited = false;
}void Graph::BFS()
{queue<int>gQueue;vertexList[0]->wasVisited=true; //设置顶点为访问过了，showVertex(0);gQueue.push(0);//把顶点放入到队列中 int vert1,vert2;while(gQueue.size()>0){vert1=gQueue.front();//把队列中顶点拿出来 gQueue.pop();//队列顶点删除 vert2=getAdjUnvisitedVertex(vert1);//邻接且没有访问过的 while(vert2!=-1)//有 邻接且没有访问过的
        {vertexList[vert2]->wasVisited=true;showVertex(vert2);gQueue.push(vert2);//放入到队列中 vert2=getAdjUnvisitedVertex(vert1);//继续寻找vert1中其他符合条件的//(因为getAdjUnvisitedVertex这个函数只是保证找到符合条件就返回)
        }} cout<<endl;for(int j=0; j<nVerts; j++)vertexList[j]->wasVisited = false;}
int Graph::getAdjUnvisitedVertex(int v)
{for(int j=0; j<nVerts; j++)if((adjMat[v][j] == 1) && (vertexList[j]->wasVisited == false))return j;return -1;
}void Graph::showVertex(int v)
{cout << vertexList[v]->Label << " ";
}Graph::Graph()
{nVerts = 0;for(int i=0; i<MAX_VERTS; i++)for(int j=0; j<MAX_VERTS; j++)adjMat[i][j] = 0;
}void Graph::addVertex(char lab)
{vertexList[nVerts++] = new Vertex(lab);
}void Graph::addEdge(int start, int end)
{adjMat[start][end] = 1;adjMat[end][start] = 1;
}void Graph::printMatrix()
{for(int i=0; i<nVerts; i++){for(int j=0; j<nVerts; j++)cout << adjMat[i][j] << " ";cout << endl;}
}Graph::~Graph()
{for(int i=0; i<nVerts; i++)delete vertexList[i];
}int main()
{Graph g;g.addVertex('A');// 0g.addVertex('B');// 1g.addVertex('C');// 2g.addVertex('D');// 3g.addVertex('E');// 4
g.addEdge(0,1); // A-Bg.addEdge(0,3); // A-Dg.addEdge(1,0); // B-Ag.addEdge(1,4); // B-Eg.addEdge(2,4); // C-Eg.addEdge(3,0); // D-Ag.addEdge(3,4); // D-Eg.addEdge(4,1); // E-B g.addEdge(4,2); // E-Cg.addEdge(4,3); // E-D
g.printMatrix();cout << "深度优先搜索的结果: ";g.DFS();cout << "广度优先搜索的结果: ";g.BFS();cout <<endl;system("pause");return 0;
}

#include <set>
#include <map>using namespace std;int main()
{//C++标准库容器（数据结构）：红黑树set<int>            a;multiset<int>        b;map<int,int>        c;multimap<int,int>    d;a.insert(50);a.insert(40);a.insert(30);return 0;
}

#include <iostream>
#include <sstream>
#include <string>
#include <vector>// SEE UPDATE COMMENTS AT END OF FILE
// 2006-01.29 fixed memory leaks// eliminate need to qualify standard library with std::
using namespace std;// ===============================================================
// C++ NEEDS SOME DECLARATIONS BEFORE THE MAIN RedBlackTree class.
// skip down a little to line this up with the other side
// ===============================================================
// requires forward declaration to resolve cycle between NodeVisitor and RedBlackTree
template<class T> class RedBlackTree;// use an abstract class for the node visitor. it is templatized to match the templated RedBlackTree declaration
template<class T> class NodeVisitor {
public:// need a virtual destructor for the concrete classesvirtual ~NodeVisitor() {}// ise a pure virtual function so a concrete class must implement// the proper signaturevirtual void visit(const RedBlackTree<T> *node,int depth) = 0;
};// =============================================
// >>>>>>>>>>>>>>>>> RED BLACK TREE STARTS HERE
// =============================================
// in line with the STL conventions, this template uses 'by-value' semantics for the contained
// object. This means that the 'T' object will need to have the correct constructor and copy assignment
// semantics or it won't work. primitive types are OK but object instances would have to be
// put together correctly.
template<class T> class RedBlackTree {private:    /*Red/Black tree implementation based on Algorithms in C++, SedgewickIntroduction To Algorithms Cormen, Thomas H. / Leiserson, Charl es E . / Rivest, Ronald L . The MIT Press 07/1990NOTE : LOOK AT END OF FILE TO SEE DIFFERENCES IN TRAVERSAL IDIOMS    */// yes, i could use an enum but since i want to print the values, using an enum is more// trouble than it is worth.static const int red   = 0;static const int black = 1;// use a common instance variable naming convention 'm_'. others use a single leading '_'int               m_color;T                 m_val;RedBlackTree      *m_left;RedBlackTree     *m_right;RedBlackTree(RedBlackTree *b) {m_val      = b->m_val;m_left     = b->m_left;m_right    = b->m_right;m_color    = red;}void copy(RedBlackTree *x) {m_val     = x->m_val;m_left    = x->m_left;m_right   = x->m_right;m_color   = x->m_color;// UPDATE 2006-01-28// node pointed to by 'x' is no longer needed, delete it. // first make sure the delete won't descend into other nodesx->m_left  = 0;x->m_right = 0;delete x;}RedBlackTree *RBinsertLeft(T k,int sw) {RedBlackTree *l;RedBlackTree *b;l = m_left;if (l == 0) {m_left = b = new RedBlackTree(k);}else {b = l->RBinsert(k,sw);}return b;}RedBlackTree *RBinsertRight(T k,int sw) {RedBlackTree *r;RedBlackTree *b;r = m_right;if (r == 0) {m_right = b = new RedBlackTree(k);}else {b = r->RBinsert(k,sw);}return b;}RedBlackTree *rotLeft(){RedBlackTree *x;RedBlackTree *me;if (m_right == 0) return 0;// make the changes in a copy of current node __self// on return, the caller will copy in 'me' to current nodeme          = new RedBlackTree(this);x           = me->m_right;me->m_right = x->m_left;x->m_left   = me;return   x;}RedBlackTree *rotRight(){RedBlackTree *x;RedBlackTree *me;if (m_left == 0) return 0;// make the changes in a copy of current node __self// on return, the caller will copy in 'me' to current nodeme          = new RedBlackTree(this);x           = me->m_left;me->m_left  = x->m_right;x->m_right  = me;return x;}RedBlackTree *RBinsert(T k,int sw) {RedBlackTree *b = 0;RedBlackTree *x;RedBlackTree *l;RedBlackTree *ll;RedBlackTree *r;RedBlackTree *rr;// if current node is a 4 node, split it by flipping its colors// if both children of this node are red, change this one to red// and the children to blackl = m_left;r = m_right;if ((l != 0)&&(l->m_color==red)&&(r != 0)&&(r->m_color==red)) {m_color = red;l->m_color = black;r->m_color = black;}// go left or right depending on key relationshipif (k < m_val) {// recursively insertb = RBinsertLeft(k,0);// on the way back up check if a rotation is needed// if search path has two red links with same orientation// do a single rotation and flip the color bitsl = m_left;if ((m_color == red)&&(l != 0)&&(l->m_color == red)&&(sw == 1)) {x = rotRight();if (x != 0) {// copy returned node to 'this'
                    copy(x);}}// flip the color bitsl = m_left;if (l != 0) {ll = l->m_left;if (ll != 0) {if ((l->m_color == red)&&(ll->m_color == red)) {x = rotRight();if (x != 0) {copy(x);}m_color = black;r = m_right;if (r != 0) {r->m_color = red;}}}}}else {b = RBinsertRight(k,1);// on the way back up check if a rotation is needed// if search path has two red links with same orientation// do a single rotation and flip the color bitsr = m_right;if ((m_color == red)&&(r != 0)&&(r->m_color == red)&&(sw == 0)) {x = rotLeft();if (x != 0) {// copy returned node to 'this'
                    copy(x);}}// flip the color bitsr = m_right;if (r != 0) {rr = r->m_right;if (rr != 0) {if ((r->m_color == red)&&(rr->m_color == red)) {x = rotLeft();if (x != 0) {// copy returned node to 'this'
                            copy(x);}m_color = black;l = m_left;if (l != 0) {l->m_color = red;}}}}}            return b;}// ==================================================
// PUBLIC METHODS
// ==================================================
public:// construct with an initial value
    RedBlackTree(T x) {m_val      = x;m_left     = 0;m_right    = 0;m_color    = red;}~RedBlackTree() {if (m_left != 0) {delete m_left;}if (m_right != 0) {delete m_right;}}// return a string representation string str() const {stringstream s(stringstream::out);// m_val (type T) must have the proper ostream insertion operator// or this implementation won't works << "[" << m_val << "," << m_color << "]";return s.str();}// 'const' means this method doesn't change the object stateT val() const {return m_val;}// 'const' means this method doesn't change the object stateint color() const {return m_color;}// 'const' means this method doesn't change the object state// and it returns a pointer to a const node that the caller// cannot change, only inspectconst RedBlackTree *find(const T &key) const {const RedBlackTree *result = 0;if (key == m_val) {result = this;}else if (key < m_val) {if (m_left != 0) {result = m_left->find(key);}}else {if (m_right != 0) {result = m_right->find(key);}}return result;}// 'const' means this method doesn't change the object state// and the visitor is not allowed to change the object state.// that may not be what is desired but is used here to // illustrate something you can do in C++ that you can't do// in the other languages and that illustrates the bias towards// extensive static type checkingvoid inorder(NodeVisitor<T> *visitor,int depth) const {if (m_left != 0) {m_left->inorder(visitor,depth+1);}visitor->visit(this,depth);if (m_right != 0) {m_right->inorder(visitor,depth+1);}}RedBlackTree *insert(T k) {RedBlackTree *b;b = RBinsert(k,0);m_color = black;return b;}
};// define a concrete class for the node visitor
class IntNodeVisitor : public NodeVisitor<int> {
public:virtual ~IntNodeVisitor() {}// the node is 'const' so the visitor can't change it, only look at itvirtual void visit(const RedBlackTree<int> *node,int depth) {if (node->val() != 0) {cout << "(" << node->val() << ":" << node->color() << ":" << depth << "), ";}}
};// ==================================
// test program
// ==================================
int main(int argc,char *argv[]) {int nodelist[] = {11,4,8,14,17,6,9,7,16,15,13,5,19,18,12,10,3,20,1};NodeVisitor<int> *v;// anonymous class implementing the NodeVisitor interfacev = new IntNodeVisitor;// insert all the data into the treeRedBlackTree<int> *root = new RedBlackTree<int>(2);root->insert(11);root->insert(4);root->insert(8);root->insert(14);root->insert(17);root->insert(6);//显示红黑树里的数据root->inorder(v,0);return 0;// need to do an ugly calculation to figure out length of the nodelist array// if i used a collection object instead of an array, then I couldn't have// done static initialization. so its a tradeofffor(int i=0;i<(sizeof(nodelist)/sizeof(nodelist[0]));i++) {root->insert(nodelist[i]);}// print the headercout << "C++      = ";    // visit all the nodes in orderroot->inorder(v,0);// print a newlinecout << endl;// find the specified element and print its valueconst RedBlackTree<int> *x = root->find(16);cout << x->str() << endl;// no garbage collection, need to explicitly deletedelete root; // will recursively delete all the nodesdelete v;
}// ===================================================================
// UPDATE 2006-01-29
// there are memory leaks that need to be fixed.
// 1. the algorithm leaks nodes after a rotate
//  two possible fixes :
//  find where the leaks occur and do the needed deletes
//      in this case the 'copy' method handles
//              deleting unused nodes
//      use an appropriate smart pointer to handle deleteing
// 2. the tree is not properly disposed of when the program completes
//     In the STL tradition a delete of the tree should
//     delete all tree resources but not the contained data. the application
//     should handle deleting the contained data elements, if needed, prior
//     to deleting the tree. In this case a recursive delete of the
//     nodes works gets rid of the tree resources
//
// these issue show that one of the big difficulties in C++ is to
// handle disposing of data after you are done with it. that is indeed a
// source of many C++ program errors of the type that are related more to
// dealing with the complexity of the language rather than the solving
// the problem. In this code the leaks are probably fixed but there is always
// a lingering doubt "Did I get all the leaks?"
// Thats a problem with C++, its hard to be certain.
//
// a modern approach is to use smart pointers to simulate garbage
// collection. the Boost library referenced counted smart pointers
// will be included in the next standard revision of the C++ library
// so they are used here to handle all the cases.
// ===================================================================

#ifndef RED_BLACK_TREE_H_
#define RED_BLACK_TREE_H_#include "Wrapper.h"
#include "Except.h"// Red-black tree class.
//
// CONSTRUCTION: with negative infinity object
//
// ******************PUBLIC OPERATIONS*********************
// void insert( x )       --> Insert x
// void remove( x )       --> Remove x (unimplemented)
// Comparable find( x )   --> Return item that matches x
// Comparable findMin( )  --> Return smallest item
// Comparable findMax( )  --> Return largest item
// bool isEmpty( )        --> Return true if empty; else false
// void makeEmpty( )      --> Remove all items
// ******************ERRORS********************************
// Throws exceptions as warranted.
template <class Comparable>
class RedBlackTree;template <class Comparable>
class RedBlackNode;template <class Comparable>
class RedBlackTree
{public:RedBlackTree( const Comparable & negInf );RedBlackTree( const RedBlackTree & rhs );~RedBlackTree( );Cref<Comparable> findMin( ) const;Cref<Comparable> findMax( ) const;Cref<Comparable> find( const Comparable & x ) const;bool isEmpty( ) const;void makeEmpty( );void insert( const Comparable & x );void remove( const Comparable & x );enum { RED, BLACK };const RedBlackTree & operator=( const RedBlackTree & rhs );typedef RedBlackNode<Comparable> Node;private:Node *header;   // The tree header (contains negInf)Node *nullNode;// Used in insert routine and its helpers (logically static)Node *current;Node *parent;Node *grand;Node *great;// Usual recursive stuffvoid reclaimMemory( Node *t ) const;RedBlackNode<Comparable> * clone( Node * t ) const;// Red-black tree manipulationsvoid handleReorient( const Comparable & item );RedBlackNode<Comparable> * rotate( const Comparable & item,Node *parent ) const;void rotateWithLeftChild( Node * & k2 ) const;void rotateWithRightChild( Node * & k1 ) const;
};template <class Comparable>
class RedBlackNode
{Comparable    element;RedBlackNode *left;RedBlackNode *right;int           color;RedBlackNode( const Comparable & theElement = Comparable( ),RedBlackNode *lt = NULL, RedBlackNode *rt = NULL,int c = RedBlackTree<Comparable>::BLACK ): element( theElement ), left( lt ), right( rt ), color( c ) { }friend class RedBlackTree<Comparable>;
};// Construct the tree.
// negInf is a value less than or equal to all others.
template <class Comparable>
RedBlackTree<Comparable>::RedBlackTree( const Comparable & negInf )
{nullNode    = new Node;nullNode->left = nullNode->right = nullNode;header      = new Node( negInf );header->left = header->right = nullNode;
}// Copy constructor.
template <class Comparable>
RedBlackTree<Comparable>::RedBlackTree( const RedBlackTree<Comparable> & rhs )
{nullNode    = new Node;nullNode->left = nullNode->right = nullNode;header      = new Node( rhs.header->element );header->left = header->right = nullNode;*this = rhs;
}// Destroy the tree.
template <class Comparable>
RedBlackTree<Comparable>::~RedBlackTree( )
{makeEmpty( );delete nullNode;delete header;
}// Insert item x into the tree.
// Throws DuplicateItemException if x is already present.
template <class Comparable>
void RedBlackTree<Comparable>::insert( const Comparable & x )
{current = parent = grand = header;nullNode->element = x;while( current->element != x ){great = grand; grand = parent; parent = current;current = x < current->element ? current->left : current->right;// Check if two red children; fix if soif( current->left->color == RED && current->right->color == RED )handleReorient( x );}// Insertion fails if already presentif( current != nullNode )throw DuplicateItemException( );current = new Node( x, nullNode, nullNode );// Attach to parentif( x < parent->element )parent->left = current;elseparent->right = current;handleReorient( x );
}// Remove item x from the tree.
// Not implemented in this version.
template <class Comparable>
void RedBlackTree<Comparable>::remove( const Comparable & x )
{cout << "Sorry, remove unimplemented; " << x <<" still present" << endl;
}// Find the smallest item  the tree.
// Return the smallest item wrapped in a Cref object.
template <class Comparable>
Cref<Comparable> RedBlackTree<Comparable>::findMin( ) const
{if( isEmpty( ) )return Cref<Comparable>( );Node *itr = header->right;while( itr->left != nullNode )itr = itr->left;return Cref<Comparable>( itr->element );
}// Find the largest item in the tree.
// Return the largest item wrapped in a Cref object.
template <class Comparable>
Cref<Comparable> RedBlackTree<Comparable>::findMax( ) const
{if( isEmpty( ) )return Cref<Comparable>( );Node *itr = header->right;while( itr->right != nullNode )itr = itr->right;return Cref<Comparable>( itr->element );
}// Find item x in the tree.
// Return the matching item wrapped in a Cref object.
template <class Comparable>
Cref<Comparable> RedBlackTree<Comparable>::find( const Comparable & x ) const
{nullNode->element = x;Node *curr = header->right;for( ; ; ){if( x < curr->element )curr = curr->left;else if( curr->element < x )curr = curr->right;else if( curr != nullNode )return Cref<Comparable>( curr->element );elsereturn Cref<Comparable>( );}
}// Make the tree logically empty.
template <class Comparable>
void RedBlackTree<Comparable>::makeEmpty( )
{reclaimMemory( header->right );header->right = nullNode;
}// Test if the tree is logically empty.
// Return true if empty, false otherwise.
template <class Comparable>
bool RedBlackTree<Comparable>::isEmpty( ) const
{return header->right == nullNode;
}// Deep copy.
template <class Comparable>
const RedBlackTree<Comparable> &
RedBlackTree<Comparable>::operator=( const RedBlackTree<Comparable> & rhs )
{if( this != &rhs ){makeEmpty( );header->right = clone( rhs.header->right );}return *this;
}// Internal method to clone subtree.
template <class Comparable>
RedBlackNode<Comparable> *
RedBlackTree<Comparable>::clone( Node * t ) const
{if( t == t->left )  // Cannot test against nullNode!!!return nullNode;elsereturn new RedBlackNode<Comparable>( t->element, clone( t->left ),clone( t->right ), t->color );
}// Internal routine that is called during an insertion
// if a node has two red children. Performs flip and rotations.
// item is the item being inserted.
template <class Comparable>
void RedBlackTree<Comparable>::handleReorient( const Comparable & item )
{// Do the color flipcurrent->color = RED;current->left->color = BLACK;current->right->color = BLACK;if( parent->color == RED )      // Have to rotate
    {grand->color = RED;if( item < grand->element != item < parent->element )parent = rotate( item, grand ); // Start dbl rotatecurrent = rotate( item, great );current->color = BLACK;}header->right->color = BLACK;   // Make root black
}// Internal routine that performs a single or double rotation.
// Because the result is attached to the parent, there are four cases.
// Called by handleReorient.
// item is the item in handleReorient.
// parent is the parent of the root of the rotated subtree.
// Return the root of the rotated subtree.
template <class Comparable>
RedBlackNode<Comparable> *
RedBlackTree<Comparable>::rotate( const Comparable & item,Node *theParent ) const
{if( item < theParent->element ){item < theParent->left->element ?rotateWithLeftChild( theParent->left )  :  // LLrotateWithRightChild( theParent->left ) ;  // LRreturn theParent->left;}else{item < theParent->right->element ?rotateWithLeftChild( theParent->right ) :  // RLrotateWithRightChild( theParent->right );  // RRreturn theParent->right;}
}// Rotate binary tree node with left child.
template <class Comparable>
void RedBlackTree<Comparable>::
rotateWithLeftChild( Node * & k2 ) const
{Node *k1 = k2->left;k2->left = k1->right;k1->right = k2;k2 = k1;
}// Rotate binary tree node with right child.
template <class Comparable>
void RedBlackTree<Comparable>::
rotateWithRightChild( Node * & k1 ) const
{Node *k2 = k1->right;k1->right = k2->left;k2->left = k1;k1 = k2;
}// Internal method to reclaim internal nodes in subtree t.
template <class Comparable>
void RedBlackTree<Comparable>::reclaimMemory( Node *t ) const
{if( t != t->left ){reclaimMemory( t->left );reclaimMemory( t->right );delete t;}
}#endif

#include <iostream>using namespace std;void BubbleSort(int list[], int n);int main()
{int a[] = {2,4,6,8,0,1,3,5,7,9};BubbleSort(a,10);for(int k=0; k<10; k++)cout << a[k] << " ";cout << endl;return 0;
}void BubbleSort(int list[], int n)
{for(int i=0; i<n-1; i++){for(int j=0; j<n-i-1;j++){if(list[j] > list[j+1])std::swap(list[j],list[j+1]);}}
}

#include <iostream>using namespace std;void SelectSort(int *a, const int n);int main()
{int x[] = {1,3,5,7,9,0,2,4,6,8};SelectSort(x,10);for(int k=0; k<10; k++)cout << x[k] << endl;return 0;
}void SelectSort(int *list, const int n)
{//           i<nfor(int i=0; i<n-1; i++){int min = i; //min就是毛巾,毛巾是数组的下标for(int j=i+1; j<n; j++){if(list[j] < list[min])min = j;}swap(list[i],list[min]);}
}

 v#include <iostream>using namespace std;int BinarySearch(int *a, const int x, const int n);
int BinSearch(int *a, const int x, const int n);int main()
{int x[] = {1,2,3,4,5,6,7,8,9,10};int 结果;int num;num = 6;结果 = BinSearch(x, num, 10);if(结果 < 0)cout << "没找到! " << endl;elsecout << "在x[" << 结果 << "]找到" << num << endl;return 0;
}int BinSearch(int *a, const int x, const int n)
{int left = 0, right = n-1;while(left<=right){int middle = (left + right)/2;if(x < a[middle]) right = middle-1;else if(x > a[middle]) left=middle+1;else return middle;}return -1;
}int BinarySearch(int *a, const int x, const int n)
{int low, high, mid;low = 0, high = n-1;while(low<=high){mid = (low + high) / 2;if(a[mid] == x)return mid;else if(a[mid] < x)low = mid+1;else if(a[mid] > x)high = mid - 1;}return -1;
}

#include <iostream>using namespace std;int BinarySearch_I(int *a, const int x, const int n);
int BinarySearch_R(int *a, const int x, const int left, const int right);int main()
{int m[] = {1,2,3,4,5,6,7,8,9};int 结果;int num = 7;if((结果 = BinarySearch_R(m,num,0,8))<0){cout << "递归算法: 没找到!" << endl;}else{cout << "递归算法: 在m[" << 结果 << "]找到" << num << endl;}if((结果 = BinarySearch_I(m,num,9))<0){cout << "迭代算法: 没找到!" << endl;}else{cout << "迭代算法: 在m[" << 结果 << "]找到" << num << endl;}return 0;
}int BinarySearch_I(int *a, const int x, const int n)
{int left = 0, right = n-1;while(left <= right){int middle = (left+right)/2;if(x<a[middle]) right = middle-1;else if(x>a[middle]) left = middle + 1;else return middle;}return -1;
}int BinarySearch_R(int *a, const int x, const int left, const int right)
{if(left<=right){int middle = (left+right)/2;if(x<a[middle]) return BinarySearch_R(a,x,left,middle-1);else if(x>a[middle]) return BinarySearch_R(a,x,middle+1,right);else return middle;}return -1;
}

#include <iostream>using namespace std;
//字符，开始的下标，最后的下标
void Permutations(char *p,const int k,const int m)
{//k的变换， Permutations(p,k+1,m)中的k+1赋值给了k if(k==m)//已经到了最后一个，不需要递归
    {cout<<"ddddddddddddd"<<endl;for(int i=0;i<=m;i++)cout<<p[i];cout<<endl; } else{for(int i=k;i<=m;i++ ){swap(p[k],p[i]);//调换开头 abc，让 a,b,c依次开头 Permutations(p,k+1,m);//加入确定了 a  继续让bc依次递归 swap(p[k],p[i]);//还原
            } }
}int main()
{char s[]="abc";Permutations(s,0,2); return 0;
}

#include <iostream>using namespace std;template<class T>
void QuickSort(T *a, const int left, const int right)
{if(left<right){//选枢轴int i = left;int j = right+1; //为什么要加一?int pivot = a[left];//划分算法do{do i++; while(a[i]<pivot);do j--; while(a[j]>pivot);if(i<j) swap(a[i],a[j]);}while(i<j);swap(a[left],a[j]);QuickSort(a,left,j-1);QuickSort(a,j+1,right);}
}int main()
{int k[] = {8,6,4,2,0,1,3,5,7,9,99};QuickSort(k,0,9);for(int i=0; i<10; i++)cout << k[i] << endl;return 0;
}

//n个人围圈报数，报m出列，最后剩下的是几号？
#include <stdio.h>
#include <stdlib.h>typedef struct node
{int data;//存储了排列的序号。struct node *next;
}node;//创建循环链表
node *create(int n)
{node *p = NULL, *head;head = (node*)malloc(sizeof (node ));p = head;node *s;int i = 1;if( 0 != n ){//尾后插入法while( i <= n ){s = (node *)malloc(sizeof (node));s->data = i++;    // 为循环链表初始化，第一个结点为1，第二个结点为2。p->next = s;p = s;}s->next = head->next;//最后一个节点指向第一个节点(不是头节点)
    }free(head);//删除头节点return s->next ;//返回第一个节点
}int main()
{int n = 41;int m = 3;int i;node *p = create(n);node *temp;m %= n;   // m在这里是等于3while (p != p->next )//链表剩下最后一个
    {for (i = 1; i < m-1; i++)//找到第一个节点
        {p = p->next ;//p指向第二节点
        }printf("%d->", p->next->data );//打印第三个节点的数值
temp = p->next ;                //删除第m个节点p->next = temp->next ;free(temp);p = p->next ;//p是第四个节点
    }printf("%d\n", p->data );//打印最后一个return 0;
}