排序算法
桶排序算法：时间复杂度较小，但占用内存较大。
冒泡排序：比较两个相邻元素，如果顺序错误就交换过来。双重嵌套循环是的时间复杂度高。
快速排序算法：每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于基准点的数全部放到基准点的右边。不断地递归调用。相比冒泡排序算法时间复杂度明显降低。
插入排序算法：在添加新的数时，使用顺序查找的方式找到其要插入的位置，然后将新数字插入。时间复杂度也是（n^2)。
数据结构（栈，队列，链表）
队列是一种特殊的线性结构，它只允许在队列的首部（head）金星删除操作，称为出队；而在队列的尾部（tail）进行插入操作，称为入队。当head == tail时，队列为空。遵循FIFO，先进先出原则。
链表：在存储一大波数据的时候，数组显得不够灵活。链表有无头链表和有头链表。有头链表头节点不存放数据区分开。

//创建表头，表示整个链表 struct Node* createListHead() { //链表的基本单元就是结构体变量 //结构体指针怎么表示结构体变量 //1，赋值结构体变量的地址 //2，动态内存申请 struct Node* ListHead = (struct Node*)malloc(sizeof(struct Node)); //为结构体变量初始化 //差异化处理，表头不使用数据 ListHead->next = NULL; return ListHead; } 

无头链表：

讯享网struct List { struct Node* frontNode; //头节点 struct Node* tailNode; //尾节点 int size; //链表的长度 }; //创建链表 struct List* createList() { struct List* list = (struct List*)malloc(sizeof(struct List)); list->frontNode = list->tailNode = NULL; list->size = 0; return list; } 

有头链表以头节点来表示整个链表，使用广，而且方便。
这里涉及到结点的插入和删除（头节点插入/删除，尾节点插入/删除和指定位置插入/删除）
栈是一种后进先出的数据结构。最近接触栈都跟链表有关

//链式 struct Node { int data; struct Node* next; }; //入栈：创建节点的过程 struct Node* createNode(int data) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node*)); newNode->data = data; newNode->next = NULL; return newNode; } //栈 struct stack { int stacksize; //万金油 struct stack* stackTop; //头节点，用栈顶表示 //无表头链表 }; //创建栈：描述这种结构的最初状态 struct stack* createStack() { struct stack* myStack = (struct stack*)malloc(sizeof(struct stack)); myStack->stacksize = 0; myStack->stackTop = NULL; return myStack; } //万金油函数 //获取栈大小，元素 int size(struct stack* myStack) { return myStack->stacksize; } //判断栈是否为空 int empty(struct stack* myStack) { //返回1，表示为NULL //返回0，表示不为NULL return myStack->stacksize == 0; } //出栈:无表头链表表头法删除 void pop(struct stack* myStack) { if (empty(myStack) == 1) { printf("栈为空！\n"); return 0; } //找到老二 struct Node* nextNode = myStack->stackTop->next; //删除 free(myStack->stackTop); myStack->stacksize = nextNode; myStack->stacksize--; } //获取栈顶元素 void top(struct stack* myStack) { if (empty(myStack) == 1) { printf("无法获取！\n"); return 0; } return myStack->stackTop->data; } 

DFS与BFS
DFS：深度优先搜索用栈（stack）来实现，整个过程可以想象成一个倒立的树形：
1、把根节点压入栈中。
2、每次从栈中弹出一个元素，搜索所有在它下一级的元素，把这些元素压入栈中。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。

讯享网

讯享网 //还可以利用深度优先搜索枚举出任意位自然数的全排列 #include <stdio.h> int a[10],book[10],n; void dfs(int step) { int i; if(step == n+1) { for(i = 1;i <= n;i++) printf("%d\n",a[i];); printf("\n"); return ; } for(i = 1;i <= n;i++) { if(book[i] == 0) { a[step] = i; book[i] = 1; dfs(step+1); book[i] = 0; } } return ; } int main() { scanf("%d",%n); dfs(1); getchar(); getchar(); return 0; } 

BFS：广度优先搜索使用队列（queue）来实现，整个过程也可以看做一个倒立的树形：
1、把根节点放到队列的末尾。
2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。
最短路径算法
Floyd算法虽然总体时间复杂度较高，但是可以解决负边权，编码复杂度较小；Dijkstra算法扩展后可以适应很多问题，弊端就是无法解决负边权的问题；Bellman-Ford算法或者队列优化的Bellman-Ford算法可以很好地解决负边权的问题。
图的遍历（可用二维矩阵或邻接表法存储图）
图的深度优先遍历和广度优先遍历…
树
二叉树：一种特殊的树，最多有两个儿子。

#include <stdio.h> #include <stdlib.h> struct treeNode { char data; struct treeNode* LChild; struct treeNode* RChild; }; //创建树 struct treeNode* createNode(char data) { struct treeNode* newNode = (struct treeNode*)malloc(sizeof(struct treeNode)) newNode->data = data; newNode->LChild == NULL; newNode->RChild == NULL; return newNode; } //连接节点 void insertNode(struct treeNode* curNode, struct treeNode* LChildNode, struct treeNode* RChildNode) { curNode->LChild = LChildNode; curNode->RChild = RChildNode; } //打印函数 void midOrder(struct treeNode* curNode) { printf("%c\t", curNode->data); } //中序遍历 void midOrder(struct treeNode* tree) { if (tree != NULL) { midOrder(tree->LChild); printData(tree); midOrder(tree->RChild); } } int main() { //创建所有节点 struct treeNode* A = createNode('A'); struct treeNode* B = createNode('B'); struct treeNode* C = createNode('C'); struct treeNode* D = createNode('D'); struct treeNode* E = createNode('E'); struct treeNode* F = createNode('F'); struct treeNode* G = createNode('G'); struct treeNode* K = createNode('K'); //做连接操作 InsertNode(A, B, C); insertNode(B, D, E); insertNode(C, F, G); insertNode(F NULL, K); //遍历 system("pause"); return 0; } 

Prim最小生成树算法：
1.将1号顶点加入生成树中，并用一维数组book来标记哪些点已经加入了生成树。
2.用一维数组dis记录生成树但各个顶点的距离。
3.从数组dis中选出离生成树最近的顶点（假如为j）加入到生成树中。再以j为中间点，更新生成树到每一个顶点的距离（即就是松弛），如果dis[k] > e[j][k],那么更新dis[k] = e[j][k]。
4.重复第三步，直到所有顶点加入生成树为止。