if (pb > pe) return NULL;

TreeNode *root = new TreeNode(preorder[pb]);
int rootIndex = mp[root->val]; //获取中序的位置
int leftSize = rootIndex - ib; //左子树大小
int rightSize = ie - rootIndex; //右

root->left = dc(preorder,pb+1,pb+leftSize, inorder,ib, rootIndex-1);
root->right = dc(preorder,pb+leftSize+1, pe, inorder, rootIndex+1, ie);

int min(int a, int b){
    return a > b ? b : a;
}

int max(int a, int b){
    return a < b ? b : a;
}

int trap(int* height, int heightSize){

    int left_max;
    int right_max;
    int ans=0;
    //从1到n-1即可，因为第一个和最后一个不能有水
    for (int i = 1; i < heightSize - 1; i++){
        left_max = height[i];
        right_max = height[i];
        for (int j = 0; j < i; j++){
            left_max = max(left_max, height[j]);
        }
        for (int j = heightSize - 1; j > i; j--){
            right_max = max(right_max, height[j]);
        }
        //计算接水面积
        ans += min(left_max, right_max) - height[i];

    }
    return ans;

}

int min(int a, int b){
    return a > b ? b : a;
}
int max(int a, int b){
    return a > b ? a: b;
}

int largestRectangleArea(int* heights, int heightsSize){

    int max_area = 0;

    for (int i = 0; i < heightsSize; i++){
        int min_height = heights[i];
        for (int j = i; j < heightsSize; j++){
            //找到i-j中的最小高度
            for ( int k = i; k <= j; k++){
                min_height = min(min_height, heights[k]);
            }
            //计算面积
            max_area = max(max_area, (j-i+1) * min_height);
        }
    }
    return max_area;

}

int largestRectangleArea(int* heights, int heightsSize){
    int min_height = 0;
    int max_area = 0;

    for ( int i = 0 ; i < heightsSize; i++){
        min_height = heights[i];
        for ( int j = i ; j < heightsSize; j++){
            min_height = min(min_height, heights[j]);
            max_area = max(max_area, (j-i+1) * min_height);
        }
    }
    return  max_area;

}

int largestRectangleArea(int* heights, int heightsSize){
    int max_area = 0;

    for ( int i = 0; i < heightsSize; i++){
        int left_border = 0;
        int right_border = heightsSize;

        for (int j = i; j < heightsSize; j++){
            if (heights[j] < heights[i]){
                right_border = j;
                break;
            }

        }
        for (int j = i; j >= 0; j--){
            if (heights[j] < heights[i]){
                left_border = j+1;
                break;
            }
        }
        max_area = max(max_area, (right_border-left_border) * heights[i]);

    }
    return max_area;

}

int max(int a, int b){
    return a > b ? a : b;
}

typedef struct {
    int *arr;
    int count;
} Stack;

Stack *create(int k){
    Stack *st = malloc(sizeof(Stack));
    st->arr = malloc(sizeof(int) * (k+2));
    st->count = 0;
    return st;
}


void push(Stack *st, int val){
    st->arr[st->count] = val;
    st->count++;
    return ;
}

int peek(Stack *st){

    return st->arr[st->count-1];

}
int pop(Stack *st){
    st->count--;
    return st->arr[st->count];
}

void destroy(Stack *st){
    free(st->arr);
    free(st);
    return;
}


int largestRectangleArea(int* heights, int heightsSize){

    Stack *st = create(heightsSize);
    push(st, -1);

    int max_area = 0;
    for (int i = 0; i < heightsSize; i++){

        //如果不为空，且当前元素小于栈顶元素
        while (  && heights[i] < heights[peek(st)]){

            max_area = max(max_area, heights[pop(st)] *( i -  peek(st)-1 )) ;

        }
        push(st, i);
    }
    while ( peek(st) != -1){
        max_area = max(max_area, heights[pop(st)] *( heightsSize -  peek(st) - 1) );
    }
    destroy(st);
    return max_area;
}

int maxW = 0; //最大重量
int n = 5; //物品数目
int w = 9; // 背包最大重量
int weight[] = {2,2,4,6,3};// 物品重量,2,2,4,6,3

void rucksack(int i, int cw)
{
    if ( cw == w || i == n ){
        if ( cw > maxW ) maxW= w;
        return ;
    }
    rucksack(i + 1, cw);//不装第i个物品
    if ( cw + weight[i] <= w){ //如果装的下
        rucksack(i + 1, cw + weight[i]);
    }
}

int rucksackDp(int *weight, int num, int w)
{
    //先定义一个二维数组
    int **status = (int **)malloc( sizeof(int *) * num);
    //初始化数组
    for (int i = 0; i < num; i++){
        status[i] = (int *)calloc( w+1, sizeof(int));
    }
    //初始化第一行的值
    status[0][0] = 1; //不放
    if ( weight[0] < w){
        status[0][weight[0]] = 1; //放
    }
    //从第二个开始考虑
    for (int i = 1; i < num; i++){
        //不放的情况，直接将上面的结果复制给当前
        for (int j = 0; j <= w; j++){
            if (status[i-1][j] == 1)  status[i][j] = status[i-1][j];
        }
        //上面循环可以写成
        //memcpy(status[i], status[i-1], sizeof(int) * num);
        //放: 在上一个状态基础上, 将增加后的重量对应位置设置为1
        for ( int j = 0; j <= w -weight[i]; j++){
            if ( status[i-1][j] == 1) status[i][j+weight[i]] = 1;
        }
    }
    //输出结果
    for ( int i = w; i >= 0; --i){
        if (status[n-1][i] == 1) return i;
    }
    return 0;
}

int rucksackDp2(int *weight, int num, int w)
{
    //先定义数组
    int *status = (int *)calloc( num, sizeof(int )  );

    //初始化第一行的值
    status[0]= 1; //不放
    if ( weight[0] < w){
        status[weight[0]] = 1; //放
    }
    //从第二个开始考虑
    for (int i = 1; i < num; i++){
        //不放: 保持状态不变
        //放: 在上一个状态基础上, 将增加后的重量对应位置设置为1
        for ( int j = 0; j <= w -weight[i]; j++){
            if ( status[j] == 1) status[j+weight[i]] = 1;
        }
    }
    //输出结果
    for ( int i = w; i >= 0; --i){
        if (status[i] == 1) return i;
    }
    return 0;
}

struct _Node;
typedef struct _Node Node;

struct _Node{
    int data; //记录整型数据
    Node *next;
};

typedef struct _List {
    Node *head;  //记录头地址
    Node *tail;  //记录尾巴地址
    int num;
} List;

// 创建链表
List *CreateList()
{
    List *list;
    list = (List*)malloc( sizeof(List) );
    list->num = 0;
    return list;
}

bool AddNode(List *list, int data)
{
    Node *node;
    Node *new_node;

    new_node = (Node *)malloc( sizeof(Node) );
    if ( new_node == NULL) return false;
    new_node->data = data;
    new_node->next = NULL;

    //获取链表head
    node = list->head ;
    //如果head指向NULL, 则直接插入到下一个
    if ( node == NULL){
        list->head = new_node;
        list->tail = new_node;
        list->num = 1;
        return true;
    }
    // 否则在尾部插入节点
    node = list->tail ;
    node->next = new_node;
    list->tail = new_node;
    list->num+=1;

    return true;

}

void DestroyList(List *list)
{
    Node *current;
    Node *next;
    current = list->head;
    while (current->next != NULL){
        next = current->next;
        free(current);
        current = next;
    }
    free(list);
}

//打印整个链表
void dump(List *list){
    Node *node;
    node = list->head;
    while (node != NULL){
        printf("%08d\n", node->data);
        node = node->next;
    }
}

int main(int argc, char const *argv[])
{
    /* code */
    if (argc == 1) exit(EXIT_FAILURE);

    FILE *fp;
    fp = fopen(argv[1], "r");
    if (fp == NULL){
        perror(argv[1]);
        exit(EXIT_FAILURE);
    }
    int data;
    List *list;
    list = CreateList();
    while (fscanf(fp, "%d", &data) != EOF){
        AddNode(list, data);
    }
    dump(list)
    return 0;

// 查找元素
// situ=true时, 返回当前位置, false, 则返回上一个位置
Node *Search(List *list, int data, bool situ)
{
    Node *node;
    node = list->head;
    if ( situ ){
        while ( node->next != NULL ){
            if ( node->data == data)
                return node;
            node = node->next;
        }
    } else {
        while ( node->next->next != NULL) {
            if (node->next->data == data) 
                return node;
            node = node->next;
        }
    }
    return NULL;
}

//删除节点
bool DeleteNode( List* list, int data){

    Node *node;
    Node *tmp;
    node = list->head;
    // 判断这个节点是否是首节点
    if ( node->data == data ){
        free(list->head);
        list->head = NULL;
        list->tail = list->head;
        list->num = 0;
        return true;
    }
    // 查找给定节点的前一个节点
    node = Search(list, data, false);
    // 找不到节点
    if (  node  == NULL){
        return false;
    }
    //删除
    tmp = node->next->next;
    free(node->next);
    node->next = tmp;
    return true;
}

//在给定元素前加节点
bool InsertNode( List* list, int query, int data){

    Node *node;
    Node *new_node;

    // 为新节点分配内存
    new_node = (Node *)malloc( sizeof(Node) );
    if ( new_node == NULL) return false;
    new_node->data = data;

    node = list->head;
    // 判断这个节点是否是首节点
    if ( node->data == query ){
        new_node->next = node->next ;
        node->next = new_node;
        return true;
    }

    // 查找给定节点的前一个节点
    node = Search(list, query, false);
    // 找不到节点
    if (  node  == NULL){
        return false;
    }
    new_node->next = node->next ;
    node->next = new_node;   

    return true;

}

//在给定元素后加
bool AppendNode( List* list, int query, int data){

    Node *node;
    Node *new_node;

    // 为新节点分配内存
    new_node = (Node *)malloc( sizeof(Node) );
    if ( new_node == NULL) return false;
    new_node->data = data;

    // 查找给定节点的位置
    node = Search(list, query, true);
    // 找不到节点
    if (  node  == NULL){
        return false;
    }
    new_node->next = node->next;
    node->next = new_node;

    return true;

}

List* reverseList(List* list){

    Node *curr, *res;
    res = NULL;
    curr = list->head;
    //尾巴是之前的开头
    list->tail = list->head;
    while ( curr ){
        //移动head
        list->head = list->head->next;
        //将当前位置指向前一个位置
        curr->next = res;
        //依次向后移动res和curr
        res = curr;
        curr = list->head;
    }
    list->head = res;
    return list;
}

Node *FindMidlle(List *list)
{
    if (list->num == 0) return NULL;
    Node *fast = list->head;
    Node *slow = list->head;
    while ( fast != NULL && fast->next != NULL){
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;

}

bool RemoveLastN(List *list, int n)
{
    //删除第一个
    if ( list->num == n){
        list->head = list->head->next;
        return true;
    }
    Node *fast = list->head;
    Node *slow = list->head;
    Node *tmp;
    while (n-- > 0){
        fast = fast->next;
    }
    while (fast->next != NULL){
        fast = fast->next;
        slow = slow->next;
    }
    tmp = slow->next;
    slow->next = slow->next->next;
    free(tmp);
    return true;
}

//合并两个链表
List *MergeSortedList(List *list_a, List *list_b)
{
    List *list_c;
    list_c = CreateList();
    Node *node_a, *node_b, *node_c;
    node_a = list_a->head;
    node_b = list_b->head;

    //确定新列表的head
    if ( node_a->data < node_b->data ){
        list_c->head = node_a;
        node_a = node_a->next;
    } else {
        list_c->head = node_b;
        node_b = node_b->next;

    }
    node_c = list_c->head;
    while( true ){
        if (node_a->data < node_b->data){
            node_c->next = node_a;
            node_a = node_a->next;
            if  (node_a == NULL) break;
        } else{
            node_c->next = node_b;
            node_b = node_b->next;
            if  (node_b == NULL) break;
        }
            node_c = node_c->next;
    }
    while ( node_a != NULL){
        node_c->next = node_a;
        node_a = node_a->next;
        node_c = node_c->next;

    }
    while ( node_b != NULL){
        node_c->next = node_b;
        node_b = node_b->next;
        node_c = node_c->next;
    }
    return list_c;
}

int MergeTest( const char *file1, const char *file2){
    FILE *f1;
    FILE *f2;

    int data;
    f1 = fopen(file1, "r");

    List *list1;
    list1 = CreateList();
    //读取数据
    while (fscanf(f1, "%d", &data) != EOF){
        AddNode(list1, data);
    }
    dump(list1);
    fclose(f1);

    f2 = fopen(file2, "r");
    if (f2 == NULL){
        perror(file2);
        exit(EXIT_FAILURE);
    }
    List *list2;
    list2 = CreateList();

    //读取数据
    while (fscanf(f2, "%d", &data) != EOF){
        AddNode(list2, data);
    }
    dump(list2);
    fclose(f2);

    List *res;
    res = MergeSortedList(list1, list2);
    dump(res);
    return 0;

}

//SET
#define KHASH_SET_INIT_INT(name)										\
	KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
#define KHASH_SET_INIT_INT64(name)										\
	KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
#define KHASH_SET_INIT_STR(name)										\
	KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
//MAP
#define KHASH_MAP_INIT_INT(name, khval_t)								\
	KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
#define KHASH_MAP_INIT_INT64(name, khval_t)								\
	KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
#define KHASH_MAP_INIT_STR(name, khval_t)								\
	KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)

#if UINT_MAX == 0xffffffffu
typedef unsigned int khint32_t;
#elif ULONG_MAX == 0xffffffffu
typedef unsigned long khint32_t;
#endif

#if ULONG_MAX == ULLONG_MAX
typedef unsigned long khint64_t;
#else
typedef unsigned long long khint64_t;
#endif

#define __KHASH_TYPE(name, khkey_t, khval_t) \
	typedef struct kh_##name##_s { \
	  //桶的数目, 哈希表大小, 占用数, 上限
		khint_t n_buckets, size, n_occupied, upper_bound; \
		khint32_t *flags; \ //记录当前位置是否被使用
		khkey_t *keys; \  //键的类型
		khval_t *vals; \ //值的类型
	} kh_##name##_t;

#include <stdio.h>
#include <string.h>
#include "klib/khash.h"

KHASH_MAP_INIT_STR(dict, char*)

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

	khiter_t k;

	khash_t(dict) *h = kh_init(dict);

	int ret;

	k = kh_put(dict, h, "abc", &ret);
	kh_key(h, k) = strdup("abc");
	kh_value(h,k) = strdup("aaa");

	k = kh_put(dict, h, "efg", &ret);
	kh_key(h, k) = strdup("efg");
	kh_value(h,k) = strdup("bbb");

	k = kh_get(dict, h, "abc");
	printf("%s\n", kh_value(h,k));

	for ( k = kh_begin(h); k != kh_end(h) ; k++){
		if (kh_exist(h,k)){
			free((char*)kh_key(h, k));
			free((char*)kh_value(h, k));
		}
	}

	kh_destroy(dict, h);

}

#include <stdio.h>
#include <string.h>
#include "klib/khash.h"

KHASH_MAP_INIT_STR(dict, char*)

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

	khiter_t k;

	khash_t(dict) *h = kh_init(dict);

	int ret;

	char *key[] = {"abc", "efg"};
	char *value[] = {"aaa", "bbb"};

  // h = {"abc":"efg"}
	k = kh_put(dict, h, "abc", &ret);
	kh_key(h, k) = key[0];
	kh_value(h,k) = value[0];

  // h["efg"] = "bbb"
	k = kh_put(dict, h, "efg", &ret);
	kh_key(h, k) = key[1];
	kh_value(h,k) = value[1];

  // h["abc"]
	k = kh_get(dict, h, "abc");
	printf("%s\n", kh_value(h,k));
	kh_destroy(dict, h);

}

typedef struct _heap {
    int *heap; //指向存放堆对数组
    int n; //堆的大小
    int count; //堆目前的元素
} heap;

heap*
createHeap(int n){

    heap *h;
    h->heap = (int*)malloc( sizeof(int) * (n+1));
    h->n = n;
    h->count = 0;
    return h;
}

heap*
createHeap(int n){

	heap *h;
	h = (heap*)malloc( sizeof(heap) );
	h->heap = (int*)malloc( sizeof(int) * (n+1));
	h->n = n;
	h->count = 0;
	return h;
}

void
insertElement(heap *h, int e){
    if (h->n >= h->count) return;

    // 在数组最后加入新的元素
    int *heap = h->heap;
    int count = h->count;
    heap[++count] = e;

    printf("Insert %d at %d\n", e,count+1);
    h->count = count;

    int i = count;// 数组索引
    //堆化,
    while( (i/2) > 0 && heap[i] > heap[i/2] ){
        swap(heap, i, i /2); //交换父子节点
    }
}

void removeTop(heap *h){

	if (h->count < 1) return ;

	int count = h->count;
	int *heap = h->heap;
	//用最后一个元素替代第一个元素
	heap[1] = heap[count];
	//删除最后一个元素
	h->count = --count;
	// 自上而下堆化
	int i = 1;
	while ( true ){
	    int max_pos = i;
		if ( i*2 <=count && heap[i] < heap[i*2]) max_pos = i*2; //和左子节点比较
		if ( i*2+1<=count && heap[i] < heap[i*2+1]) max_pos = i*2+1; //和右子节点比较
		if (max_pos == i) break; // 不再发生交换, 当前位置就是最大位置
		swap(heap, i, max_pos); //将当前节点和子节点进行交换
		i = max_pos ; //将i设置为子节点的索引
	}

}

#include "khash.h"
KHASH_MAP_INIT_INT(32, char) //利用宏构建函数和数据结构
int main() {
	int ret, is_missing;
	khiter_t k;
	khash_t(32) *h = kh_init(32); //初始化
	k = kh_put(32, h, 5, &ret);   //插入key
	kh_value(h, k) = 10;   //根据key设置值
	k = kh_get(32, h, 10); //根据值找key
	is_missing = (k == kh_end(h));
	k = kh_get(32, h, 5);
	kh_del(32, h, k); //删除key
	for (k = kh_begin(h); k != kh_end(h); ++k) //遍历哈希表
		if (kh_exist(h, k)) kh_value(h, k) = 1;  //判断桶是否有数据
	kh_destroy(32, h); //删除哈希表
	return 0;
}

#define KHASH_INIT(name, SCOPE, key_t, val_t, is_map, _hashf, _hasheq) \
  typedef struct { \
    int n_buckets, size, n_occupied, upper_bound; \
    unsigned *flags; \
    key_t *keys; \
    val_t *vals; \
  } kh_##name##_t; \
  SCOPE inline kh_##name##_t *init_##name() { \
    return (kh_##name##_t*)calloc(1, sizeof(kh_##name##_t)); \
  } \
  SCOPE inline int get_##name(kh_##name##_t *h, key_t k) \
  ... \
  SCOPE inline void destroy_##name(kh_##name##_t *h) { \
    if (h) { \
      free(h->keys); free(h->flags); free(h->vals); free(h); \
    } \
  }

#define _int_hf(key) (unsigned)(key)
#define _int_heq(a, b) (a == b)
#define khash_t(name) kh_##name##_t
#define kh_value(h, k) ((h)->vals[k])
#define kh_begin(h, k) 0
#define kh_end(h) ((h)->n_buckets)
#define kh_init(name) init_##name()
#define kh_get(name, h, k) get_##name(h, k)
#define kh_destroy(name, h) destroy_##name(h)
...
#define KHASH_MAP_INIT_INT(name, val_t) \
	KHASH_INIT(name, static, unsigned, val_t, is_map, _int_hf, _int_heq)

typedef struct {
  int n_buckets, size, n_occupied, upper_bound;
  unsigned *flags;
  unsigned *keys;
  char *vals;
} kh_m32_t;
static inline kh_m32_t *init_m32() {
  return (kh_m32_t*)calloc(1, sizeof(kh_m32_t));
}
static inline int get_m32(kh_m32_t *h, unsigned k)
...
static inline void destroy_m32(kh_m32_t *h) {
  if (h) {
    free(h->keys); free(h->flags); free(h->vals); free(h);
  }
}

int main() {
	int ret, is_missing;
	khint_t k;
	kh_m32_t *h = init_m32();
	k = put_m32(h, 5, &ret);
	if (!ret) del_m32(h, k);
	h->vals[k] = 10;
	k = get_m32(h, 10);
	is_missing = (k == h->n_buckets);
	k = get_m32(h, 5);
	del_m32(h, k);
	for (k = 0; k != h->n_buckets; ++k)
		if (kh_exist(h, k)) h->vals[k] = 1;
	destroy_m32(h);
	return 0;
}

#include "klib/khash.h"
KHASH_MAP_INIT_INT(m32, char)        // instantiate structs and methods
int main() {
    int ret, is_missing;
    khint_t k;
    khash_t(m32) *h = kh_init(m32);  // allocate a hash table
    k = kh_put(m32, h, 5, &ret);     // insert a key to the hash table
    if (!ret) kh_del(m32, h, k);
    kh_value(h, k) = 10;             // set the value
    k = kh_get(m32, h, 10);          // query the hash table
    is_missing = (k == kh_end(h));   // test if the key is present
    k = kh_get(m32, h, 5);
    kh_del(m32, h, k);               // remove a key-value pair
    for (k = kh_begin(h); k != kh_end(h); ++k)  // traverse
        if (kh_exist(h, k))          // test if a bucket contains data
			kh_value(h, k) = 1;
    kh_destroy(m32, h);              // deallocate the hash table
    return 0;
}

gcc -o test hash_test.c
./test

#include <stdio.h>
#include "klib/khash.h"
KHASH_MAP_INIT_INT(m32, char)        // instantiate structs and methods
int main() {
    int ret, is_missing;
    khint_t k;
    khash_t(m32) *h = kh_init(m32);  // allocate a hash table

	int i = 0;
	for ( i = 0 ; i < 10 ; i++ ){
        k = kh_put(m32, h, i, &ret);     // insert a key to the hash table
        if (!ret) kh_del(m32, h, k);
        kh_value(h, k) = i * i;             // set the value
	}

    for (k = kh_begin(h); k != kh_end(h); ++k)  // traverse
        if (kh_exist(h, k))          // test if a bucket contains data
			printf("%d\n", kh_value(h, k) );
    kh_destroy(m32, h);              // deallocate the hash table
    return 0;
}

#include <stdio.h>
#include <zlib.h>
#include "klib/kseq.h"

KSEQ_INIT(gzFile, gzread)

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

        gzFile fp;
        kseq_t *seq;
        int l;
        if (argc == 1){
                fprintf(stderr, "Usage: %s <in.fasta|in.fasta.gz>\n", argv[0]);
                return 1;
        }

        fp = gzopen(argv[1], "r");
        seq = kseq_init(fp); // 分配内存给seq
        while( (l = kseq_read(seq)) >= 0){ //读取数据到seq中
                printf(">%s\n", seq->name.s); //
                printf("%s\n", seq->seq.s);
        }

        kseq_destroy(seq); //释放内存
        gzclose(fp);

        return 0;


}

typedef struct __kstring_t {
        size_t l, m;
        char *s;
} kstring_t;
typedef struct {
        kstring_t name, comment, seq, qual;
        int last_char;
        kstream_t *f;
} kseq_t

#include <stdio.h>
#include <zlib.h>

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

	gzFile fi;
	fi = gzopen(argv[1], "r");
	char string[1000];

	while ( gzgets(fi, string, 1000) != NULL) {
		printf("%s", string);
	}
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "zlib.h"

#define MAX_LINE_LENGTH 1000

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

	gzFile fi;
	gzFile fo;
	if (argc < 2 ){
		return -1;
	}
	fi = gzopen( argv[1], "rb");
	if ( argc == 3 ){
	    fo = gzopen (argv[2], "wb");
	}

	char line[MAX_LINE_LENGTH];
	int count = 0;
	while ( gzgets(fi,line, MAX_LINE_LENGTH) != NULL) {
		if ( count == 0) {
			line[0] = '>';
		}
		if ( count < 2){
			if ( argc == 2) {
				fprintf(stdout, "%s", line);
			}
			if ( argc ==3 ){
			    gzprintf(fo, "%s", line);
			}
		}
		if ( ++count > 3 ){
			count = 0;
		}

	}
	gzclose(fi);
	if (argc == 3) gzclose(fo);
	return 0;
}

FILE *fi;
FILE *fo;

fi = fopen("input.txt", "r");
fo = fopen("output.txt", "w");

//确保文件能够正常打开
//否则退出
if ( fi == NULL ){
    perror(argv[1]);
    exit(EXIT_FAILURE);
}

fclose(fi);
fclose(fo);

#include <stdio.h>
#include <stdlib.h>

#define MAX_LINE_LENGTH 1000

int main(int argc, char *argv[])
{
	FILE *fi;
	FILE *fo;

	if ( argc == 2) {
	    fi = fopen(argv[1], "r");
	} else if (argc == 3){
	    fo = fopen(argv[2], "w");
	} else {
		exit(EXIT_FAILURE);
	}

	char line[MAX_LINE_LENGTH];
	int count=0;

	while ( fgets(line, MAX_LINE_LENGTH, fi) != NULL ){
		if (count == 0){
		    line[0] = '>';
		}
		if (count < 2){
			if ( argc == 2){
			    fprintf(stdout, "%s", line);
			} else{
			    fprintf(fo, "%s", line);
			}
		}
		if (++count > 3){
			count = 0;
		}
	}

	fclose(fi);
	if (argc == 3) fclose(fo);

	return 0;

}