Installer/List.h at master · Funlang/Installer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/*========================================================================*/

/*		Huffman Statistic Coding ---- List			  */

/*========================================================================*/

/*========================================================================*/
#include	<alloc.h>


/*========================================================================*/
#define		_LIST_		0

#ifndef		_TREE_
#include	"tree.h"
#endif

#ifndef		false
#define		false		0
#define		true		1
typedef		int		bool;
#endif


/*========================================================================*/
typedef		struct	L
{
	Tree		*tree;			/* Tree.h */

	struct L	*next;
}
List;


/*========================================================================*/
bool	InitList	();
bool	InsertList	(Tree *t);
List	*SearchMini	();
Tree	*DeleteList	(List * l);


/*========================================================================*/
List		*head;


/*========================================================================*/
bool	InitList	()
{
	head=NULL;				/* alloc.h */

	return true;
}

/*========================================================================*/
bool	InsertList	(Tree *t)
{
	List		*l;

	l=malloc(sizeof(List));			/* alloc.h */

	if (l)
	{
		l->tree=t;
		l->next=head;

		head=l;

		return true;
	}
	else
		return false;
}

/*========================================================================*/
List	*SearchMini	()
{
	List		*l,*l1;
	unsigned long	c;

	l1=NULL;				/* alloc.h */

	if (!head)
		return l1;

	c=head->tree->count;

	for (l=head;l->next;l=l->next)
	{
		if (l->next->tree->count < c)
		{
			l1=l;
			c=l->next->tree->count;
		}
	}

	return l1;
}

/*========================================================================*/
Tree	*DeleteList	(List *l)
{
	List		*l1;
	Tree		*t;

	if (!l)
	{
		if (!head)
			return NULL;		/* alloc.h */

		l1=head;
		t=l1->tree;

		head=head->next;
	}
	else
	{
		l1=l->next;
		t=l1->tree;

		l->next=l1->next;
	}

	free (l1);				/* alloc.h */

	return t;
}


/*========================================================================*/