#include #define MAXLINE 4096int first_no_repeat(const char *from){ char hash_table[256]; int cur = 0; int tmp = 0; for(; tmp < 256; hash_table[tmp++] = 0); for(;*from != '\0';

队列的基本操作跟栈类似，有如下几种：入队列，出队列，判断队列满，判断队列空，遍历队列。但是跟栈不一样的是：栈的入栈和出栈操作始终是在栈顶，但是队列的入队列是在队列尾部，出队列是在队列的头部。详情请见testcase：#include #include #include #define QUEUE_MAX 3typedef struct queue { char d

只用一个额外的节点实现单链表的反转testcase如下：#include #include typedef struct num {    int data;    struct num *next;} *num_ptr;void print_num(num_ptr head) {      num_ptr tmp = head;      wh

链表的基本操作有四种：建立，插入，删除，遍历在程序里面如下：#include #include #include typedef struct student { char name[10]; struct student *next;}* st_ptr;void print_st(st_ptr head) { st_ptr tmp = head; while (tm

链栈的基本操作有如下几种：入栈，出栈，判断栈满，判断栈空，遍历栈详情请见testcase：#include #include #include #define STACK_MAX 3typedef struct stack { char data[10]; struct stack *next;} *st_ptr;int is_stack_empty(st_p

快速排序，性能不错，但是稳定性比较差的一种排序，小弟的表达比较差，具体的算法请自行wiki，我这边贴出自己的实现：#include void quick_sort(int num[], int start, int end) { int pos, mov; int tmp, middle; if (start < end) { middle = s

归并排序是效率仅次于快速排序的一种稳定排序，缺点是需要一块额外的空间用来存放需要处理的数据，具体代码如下：#include void merge(int num[], int start, int middle, int end) { int tmp1[10], tmp2[10]; int i, j, cur, len1, len2; int pos1, pos2;

插入排序，这个排序平时用的不多，主要是把数组分为两堆，一堆排序ok，一堆未排序，把未排序的整数逐个插入到排序ok的整数中，最终两堆合并为一堆排序ok的数组，具体代码实现如下：#include int main(void){ int num[] = {4,1,2,7,3,9,6,5,8}; int i, j; int tmp, cur; for (i =

选择排序是除了冒泡排序之后又一最基本的排序算法，具体算法小弟表达能力有限，为了不误导大家，请自行wiki，此处紧贴出代码：#include int main(void) { int num[] = {4,1,2,7,3,9,6,5,8}; int i, j; int min, tmp, cur = 0; for (i = 0; i < 9; i++) {

冒泡排序估计是所有面试题里面出现概率最高的一道基础题，小弟献丑的再此贴出来做个纪念：#include int main(void) { int num[] = {4,1,2,7,3,9,6,5,8}; int i, j; int temp = 0, cur = 0; for (j = 9; j > 0; j--) { for (i = 0;

#include #define MAXLINE 4096void moven(char *to, const char *from, const int n){ const char *tmp = from; for (; *(tmp + n) != '\0'; tmp++); for (; (*to = *tmp) != '\0'; to++, tmp++);

#include #include #define MAXLINE 4096void get_all_sub_str(const char *str, char result[][MAXLINE]){ char temp[MAXLINE]; int len = strlen(str); int num = 0; for (int head = 0; head < len; hea

寻找最大不重复子串

#include #define MAXLINE 4096void rmsame(char *to, const char *from, const char same){ const char *tmp = from + 1; for(; *from != '\0'; from++, tmp++) { if ((*tmp == *from) && (*fr

#include                                                                  #define MAXLINE 4096void reverse(char *to, const char *from){    for (; *from != '\0'; from++);    from--;    fo

cheny@cheny-laptop:~/string$ cat max_sub_str.c #include #include #define MAXLINE 4096void max_sub_str(const char str1[], const char str2[], char max_sub_str[]){ int max_len = 1; int pos = 0;

#include #include #define MAXLINE 4096void reverse(char *to, const char *from){    for (; *from != '\0'; from++);    from--;    for (; (*to = *from) != '\0'; --from, ++to);    *to++ = '\0';}

void replace(char *to, const char *from, const char *src, const char *dest){ size_t len = strlen(src); do { if (strncmp(from, src, len) == 0) { from = from + len - 1;

本文只说二叉树的最基本操作，建树和遍历，其他的只是后续再讲testcase如下：#include #include typedef struct biTreeNode { int data; struct biTreeNode *lchild, *rchild;} *btNode;void preorder(btNode head) {