简洁之美 的专栏

#include using namespace std; #define N 400 void bubleSort(int num,int *p); void print(int num,int *p); int Number[N]; int main() { for(int i=0;i<N;i++) { Number[i]=N-i; cout<<Number[i]<<"\t";

void printOne2MaxNDigit(int n) { if (n<=0) { return; } int *pNum=new int[n+1]; memset(pNum,0,sizeof(int)*(n+1)); while(pNum[0]!=1) { //打印 for (int i=1;i<=n;i++) { if (pNum[i]!=0)

从低位到高位排序，用hash来实现 #include #define N 400 using namespace std; typedef struct Hdata { int data; struct Hdata *next; }Node; void radixSort(int *pData,unsigned int nLen); bool GetMax(int *p

void quickSort(int *pData,int nLow,int nHigh) //递归 { if (nLow<nHigh) { int i=partition(pData,nLow,nHigh); quickSort(pData,nLow,i-1); quickSort(pData,i+1,nHigh); } } void swap(int *pD

 给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为6的数组A{5， 6， 7， 1， 2， 8}，则其最长的单调递增子序列为{5，6，7，8}，长度为4

这个题目是个很常见的面试题，主要的解法之一是

关于链表逆序，

#include using namespace std; //创建一个链表，释放链表的内存,将链表反转 typedef struct node { struct node *next; int num; }Node; Node * create(int num); void print(Node *head); void freeNode(Node *&head);

递归程序简洁，但是不是很好理解，

二叉树的Morris遍历，

#include #include typedef struct node { int nData; struct node *next; }Node; Node * createLinklist(int *pData,int nLen); void printLinklist(Node *pHead); void printLinklistReverse(Node *pHead); vo

#include using namespace std; bool insertSort(int num, int *pNum ); void insert(int num , int *pNum); void print(int num,int *p); //插入排序 int number[400]; int main() { for (int i=0;i<400;i++) { n

// 1 2 8 9 // 2 4 9 12 // 4 7 10 13 // 6 8 11 15 bool findNR(int **pArray,int nRowSize,int nColSize,int k) { int nRowIndex=0; int nColIndex=nColSize-1; while(nRowIndex>=0&&nRowIndex=0&&nCo

输入：we are happy 输出we%20are%20happy 要求

两段代码，都是插入排序的代码

#pragma once #include #define N 10 using namespace std; typedef struct node { int val; struct node *next; }Node; void freeLinklist(Node *&head); void freeLinklist(Node *&head) { if (head==NULL)

#include using namespace std; void arrayPrint(int *p); void Muli(char *num1,char *num2); int main() { char num1[100]; char num2[100]; cin>>num1>>num2; Muli(num1,num2); getchar();

#include using namespace std; #define N 400 void chooseSort(int num,int *p); void print(int num,int *p); int findmax(int num,int *p); int Number[N]; int main() { for(int i=0;i<N;i++) { Number[i]=N

希尔排序是对插入排序的改进 “ 例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样： 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 然后我们对每

堆分最小堆，最大堆 最小堆是

二叉树的层次遍历是通过一个

这是一个利用数组来初始化一个二叉树，初始化的树是一个满

class stack { private: int stackTopIndex; int *stackBase; int size; public: stack(int num) { if (num>=1) { size=num; stackBase=new int[size]; stackTopIndex=-1; } e

使用链表实现的队列：typedef struct queueNode { int val; queueNode* next; }Node; class queue { public: queue() { front=NULL; back=NULL; }; bool empty() { if (front==NULL||back==NULL) { return t

比较简单： int depth(Node *head)//空二叉树的深度为-1，只有根节点为0，看连接线的个数就是其深度 { if (head==NULL) { return -1; } return max(depth(head->left),depth(head->right))+1; }

如何删除一个二叉树，释放每个节点的

思路： 对于二叉树中的某一节点，如果是叶子节点，将其加入到path中，（一个vector）

先来说下异或 1^1=0 0^1=

#pragma once using namespace std; void inverse(char *p); void printString(char *p); void rightMove(char *p,int n); void inverse2(char *p); void inverse(char *p) { if (p==NULL) { return; } if (*p

#include using namespace std; #define N 50000 void mergearray(int a[], int first, int mid, int last, int temp[]); void printArray(int *p,int size); void mergeSort(int a[],int first,int last,int temp[

这是二分搜索的一个应用，找到FirstK以及LastK