二叉树

loopnlink

#include<stdio.h>
#include<stdlib.h>
/*带哨兵头结点和tail的环形链表*/
typedef struct node
{
	int item;
	struct node *next;
}node;

node sentinel = {0,NULL};
node *head = &sentinel;
node * tail;

node *mk_node(int item)
{
	node *p = (node *)malloc(sizeof(node));
    if(p == NULL)
    {
    	printf("malloc filed");
    	exit(1);
    }
    p->item = item;
    p->next = NULL;
    return p;
}

void insert_node(node *p)
{
	node *pre = head->next;

	 if(pre == NULL)
    {
    	head ->next = p;
    	tail = p;
    	tail->next = head->next;
        return ;
    }

    if(p->item < pre->item)
    {
        p->next = pre;
        head ->next = p;
        tail->next = head->next;
        return ;
    }

..
    pre->next = p;
    p->next = head->next;
    tail = p;
	
}

void traverse()
{
    node *p = head->next;

    while(p != tail)
    {
    	printf("%d ",p->item);
        p = p->next;
    }
    printf("%d\n",p->item);
}

void reverse()
{
	node *nhead = NULL;
	node * p;
	node *pp;

	while(head->next  != tail)
	{
        p = head ->next;
        head->next = p->next;
       p->next = nhead;
        nhead = p;
	}
	tail ->next = nhead;

	pp = nhead;
	while(pp->next !=NULL)
	{
		pp = pp->next;
	}

	tail = pp;
	tail ->next = head ->next; 
}

node * search_node(int target)
{
	node *p = head->next;

	while(p != tail)
	{
		if(p->item == target)
        {
        	return p;
        }	
        p = p->next;
	}

	if( target == tail->item)
	{
		return tail;
	}
return NULL;

}

void remove_node(node *p)
{
	node *pre = head->next;

if(p == head->next)
{
	head->next = p->next;
	return ;
}
	while(pre->next != tail)
	{ 
		if(pre->next == p)
		{
			pre->next = p->next;
			p->next = NULL;
			return ;
		}
		pre = pre->next;

	}
	if(tail == p)
	{
		p->next = NULL;
		tail  = pre;
		tail ->next = head->next;
       return ;
	}
}

void free_node(node *p)
{
	free(p);
	p = NULL;
}

void destory()
{
	node *p;
    
    tail ->next = NULL;

	while(head->next != NULL)
		{
            p = head ->next;
            head ->next = p -> next;
            free_node(p);
		}
}

int main()
{
	node *p;
	int target;

	p = mk_node(1);
	insert_node(p);
	traverse();

	p = mk_node(2);
	insert_node(p);
	traverse();

	p = mk_node(3);
	insert_node(p);
	traverse();

	p = mk_node(4);
	insert_node(p);
	traverse();

	p = mk_node(5);
	insert_node(p);


	traverse();

	reverse();
	traverse();

  scanf("%d",&target);
	p = search_node(target);
    if(p == NULL)
    {
    	printf("can't find%d\n",target);
    }
    else
    {
    	printf("%p %d %d\n",p,target,p->item);
    	remove_node(p);
    	free_node(p);
    }
    traverse();

    destory();
    traverse();

	return 0;
}

loop plink

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

typedef struct node
{
	int item;
	struct node *next;
}node;

node *head;
node *nhead;
node *tail;

node *mk_node(int item)
{
	node *p = (node *)malloc(sizeof(node));

	if(p == NULL)
	{
		printf("molloc filed\n");
		exit(1);
	}

	p->item = item;
	p->next = NULL;

	return p;
}

void insert_node(node *p)
{
    if(head == NULL)
    {
    	p->next = head;
    	head = p;
    	tail = p;
    	tail->next = head;
        return ;
    }

    p->next = head;
    head = p;
    tail->next =head;

}

void sort_insert(node *p)
{
	node *pp = head;

    if(head == NULL)
    {
    	p->next = head;
    	head = p;
    	tail = p;
    	tail->next = head;
        return ;
    }

    if(p->item < head->item)
    {
        p->next = head;
        head = p;
        tail->next = head;
        return ;
    }

    while(pp->next != head)
    {
        if((p->item) < (pp->next->item))
        {
            p->next = pp->next;
            pp->next = p;
            return ;
        }
        pp = pp->next;
    }
    pp->next = p;
    p->next = head;
    tail = p;
}

void traverse()
{
	node *p = head;

	if( head == NULL)
	{
		return ;
	}

	while(p->next != head)
	{
		printf("%d ",p->item);
		p = p->next;
	}
	printf("%d ",p->item);
	printf("\n");
}

void free_node(node *p)
{
	free(p);
	p = NULL;
}

node *search_node(int item)
{
	node *p = head;

	while(p->next != head)
	{
		if(p->item == item)
        {
        	return p;
        }
        p = p->next;
	}

	if(p->item == item)
	{
		return p;
	}
	return NULL;
}

void remove_node(node *p)
{
   node *pre = head;

   if(p == head)
   {
   	head  = head->next;
   	tail ->next = head;
   	return ;
   }

   while(pre->next != tail)
   {
   	 if(pre->next == p)
   	 {
   	 	pre->next = p->next;
   	 	p->next = NULL;
   	 	return ;
   	 }
   	 pre = pre ->next;
   }

   if(tail == p)
   {
      pre->next = head;
      tail = pre;
      return;
   }

}

void reverse()
{
	node *p;
	node *pp;

	while(head != tail)
	{
		p = head;
		remove_node(p);
		p->next = nhead;
		nhead = p;
	}

	head->next = nhead;
	nhead = head;
		
    pp = nhead;
	while(pp->next != NULL)
	{
		pp = pp->next;
	}

	tail = pp;
	tail ->next = head;
}

void destory()
{
   node *p;
   tail ->next =NULL;

   while(head != NULL)
   {
   	p = head;
   	head= head->next;
   	p->next = NULL;
   	free_node(p);
   }
   
}

int main()
{
	node *p;

	p = mk_node(1);
	//insert_node(p);
	sort_insert(p);
	p = mk_node(2);
	//insert_node(p);
	sort_insert(p);
	p = mk_node(3);
	//insert_node(p);
	sort_insert(p);

	traverse();

    p = search_node(1);
    if(p != NULL)
    {
    	printf("%p %d\n",p,p->item);
    	remove_node(p);
    	free(p);
    }
    else
    {
    	printf("not found\n");
    }
    
    traverse();

   reverse();
   traverse();

   destory();
   traverse();

	return 0;
}

16 kmp

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

//打印一个数组
void print_array(int *a, int len)
{
	int i;

	for (i = 0; i < len; i++)
	{
		printf("%5d", a[i]);
	}
	printf("\n");
}

int str_index(const char *s, const char *t, int pos)
{
	int i = pos;
	int j = 0;

	while (s[i] != '\0' && t[j]!= '\0')
	{
		if (s[i] == t[j])
		{
			i++;
			j++;
		}else
		{
			i = i - j + 1;
			j = 0;
			//printf("%d\n", i);
		}
	}

	if (t[j] == '\0')
	{
		return i - j;
	}else
	{
		return -1;
	}
}

void get_next(const char *t, int *next, int len)
{
	int j = 0;
	int k = -1;

	next[j] = -1;

	while (t[j] != '\0')
	{
		if (k == -1 || t[j] == t[k])
		{
			next[++j] = ++k;
		}else
		{
			k = next[k];
		}
	}	
}

void get_next2(const char *t, int *next, int len)
{
	int j = 0;
	int k = -1;

	next[j] = -1;

	while (t[j] != '\0')
	{
		if (k == -1 || t[j] == t[k])
		{
			++j;
			++k;
			if (t[j] == t[k])
			{
				next[j] = next[k];
			}else
			{
				next[j] = k;
			}
		}else
		{
			k = next[k];
		}
	}
}


int str_index_kmp(const char *s, const char *t, int pos)
{

	int i = pos;
	int j = 0;
	int len = strlen(t);
	
	int *next = (int *)malloc(sizeof(int) * (len + 1));
	if (next == NULL)
	{
		printf("malloc failed\n");
		exit(1);
	}

	get_next(t, next, len);
	print_array(next, len);

	get_next2(t, next, len);
	print_array(next, len);

	while (s[i] != '\0' && t[j]!= '\0')
	{
		if (s[i] == t[j])
		{
			i++;
			j++;
		}else if (j == 0)
		{
			i++;
		}else
		{
			j = next[j];
			printf("%d\n", i);
		}
	}

	free(next);

	if (t[j] == '\0')
	{
		return i - j;
	}else
	{
		return -1;
	}

}


int main()
{
	int pos;
	char buf[20] = "ABACCCCABABCDHI";
	const char *t = "ABAB";
	pos = str_index(buf, t, 0);
	if (pos  > 0)
	{
		printf("%s\n", buf  + pos);
	}
	
	pos =  str_index_kmp(buf, t, 0);
	if (pos  > 0)
	{
		printf("%s\n", buf  + pos);
	}
	

	return 0;
}

17bst-二叉搜索树

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

typedef struct node
{
    int item;
    struct node *left;
    struct node * right;
}node;

node *root = NULL;

node *mk_node(int item)
{
    node *p = (node *)malloc(sizeof(node));
    if (p == NULL)
    {
        printf("insert_node:malloc failure\n");
        exit(1);
    }

    p->item = item;
    p->left = NULL;
    p->right = NULL;

    return p;    
}

void free_node(node *p)
{
    free_node(p);
}

#if 0
void insert_node(int item)
{
    node *pre;
    node *parent;
    node *p = mk_node(item);

    parent = pre = root;
    if (root == NULL)
    {
        root = p;
        return ;
    }

    while (pre != NULL)
    {
        parent = pre;
        if (item > pre->item)
        {
            pre = pre->right;
        }else if(item < pre->item)
        {
            pre = pre->left;
        }else
        {
            free_node(p);
            return;
        }
    }

    if (p->item > parent->item)
    {
        parent->right = p;
    }else
    {
        parent->left = p;
    }
}
#endif


void insert_node_r(node *current, node *p)
{
    if (p->item > current->item)
    {
        if (current->right == NULL)
        {
            current->right = p;
        }else
        {
            insert_node_r(current->right, p);     
        }
    }else if (p->item < current->item)
    {
        if (current->left == NULL)
        {
            current->left = p;
        }else
        {
            insert_node_r(current->left, p);         
        }
    }else
    {
        free_node(p);
    }
}
 
void insert_node(int item)
{
    node *p = mk_node(item);
    if (root == NULL)
    {
        root = p;
    }else
    {
        insert_node_r(root, p);   
    }
}

void traverse_m(node *p)
{
    if (p == NULL)
    {
        return ;
    }
    traverse_m(p->left);
    printf("%d ",p->item);
    traverse_m(p->right);
}

void traverse_b(node *p)
{
    if (p == NULL)
    {
        return ;
    }
    printf("%d ",p->item);
    traverse_b(p->left);
    traverse_b(p->right);
}

void traverse_a(node *p)
{
    if (p == NULL)
    {
        return ;
    }
    traverse_a(p->left);
    traverse_a(p->right);
    printf("%d ",p->item);
}

node *search_node(node *current, int item)
{
    if (item < current->item)
    {
        if (current->left == NULL)
        {
            return NULL;
        }
        return search_node(current->left,item);
    }else if(item > current->item)
    {
        if (current->right == NULL)
        {
            return NULL;
        }
        return search_node(current->right,item);
    }

    return current;
}

int main()
{
    insert_node(8);
    insert_node(4);
    insert_node(9);
    insert_node(13);
    insert_node(11);
    printf("中序遍历\n");
    traverse_m(root);
    printf("\n");
    printf("后序遍历\n");
    traverse_a(root);
    printf("\n");
    printf("前序遍历\n");
    traverse_b(root);
    printf("\n");
    int item ;
    printf("please input you item:\n");
    scanf("%d",&item);

    node *p = search_node(root,item);
    if (p != NULL)
    {
        printf("node:%p: item %d\n",p,p->item);
    }else
    {
        printf("can't find %d in this tree\n",item);
    }

}