int main(void)
{
int count_a, count_b, i, len, j;
LinkList head_a, head_b;
count_a = 0;
count_b = 0;
printf("input la and -1 is over:\n");
head_a = CreatLink(&count_a);
printf("input lb and -1 is over:\n");
head_b = CreatLink(&count_b);
printf("la:");
print_link(head_a);
printf("lb:");
print_link(head_b);
while(1)
{
printf("input i, len, j(eg: 3,4,2):");
scanf("%d,%d,%d", &i, &len, &j);
if( (i + len > count_b) || (j > count_b) || (i < 1) || (j < 0) )
{
printf("input error!\n");
continue;
}
else{
break;
}
}
la_insert_lb(head_a, head_b, i, len, j);
printf("la:");
print_link(head_a);
printf("lb:");
print_link(head_b);
}
int main(int argc, const char *argv[])
{
link_t *head;
int i;
head = creat_link();
for(i = 9;i >= 0;i --){
ins_head_link(head,&i);
}
print_link(head);
i = 90;
ins_index_link(head,11,&i);
ins_index_link(head,15,&i);
print_link(head);
//del_head_link(head,&i);
del_index_link(head,10,&i);
printf("del:%d\n",i);
print_link(head);
dis_link(&head);
return 0;
}
int main(void)
{
stu *p = NULL;
p = creat_link(p);
print_link(p);
p = delete_link(p);
print_link(p);
return 0;
}
int main()
{
node_t *link = create_link();
print_link(link);
node_t *link2 = reverse_link(link);
print_link(link2);
destroy_link(link2);
return 0;
}
int main(int argc, const char *argv[])
{
DT *head ;
head = creak_link(10);
print_link(head);
head = Delete_node(head);
printf("\n");
print_link(head);
return 0;
}
int main(void){
int a[] = {2, 4, 5, 5, 8, 9};
Node *root = NULL;
cp_array_link(&root, a, ARRAY_LEN(a));
print_link(root);
reverse2(&root);
print_link(root);
return 0;
}
int main(int argc, const char *argv[])
{
V_NODE *head=NULL;
int n=0;
printf("input a number:\n");
scanf("%d",&n);
head = create_link(n);
print_link(head);
link_add(head);
print_link(head);
head = delete_link(head);
print_link(head);
return 0;
}
int main()
{
int a[8]={1,2,3,4,5,6,7,8};
pLink L1,L2;
init_link(&L1);
init_link(&L2);
creat_link(a,L1,8);
print_link(L1);
// reverse_link(L1,L2);
L1=reverse2(L1);
print_link(L1);
return 0;
}
void print_list(PSLL_ENTRY a) {
PSLL_ENTRY x = a;
printf("(");
if(x != NULL) {
print_link(x);
x = x->Flink;
while(x != NULL) {
printf(", ");
print_link(x);
x = x->Flink;
};
};
printf(")");
}
void print_listseg(PSLL_ENTRY a, SLL_ENTRY* y) {
PSLL_ENTRY x = a;
printf("(");
if(x != y) {
print_link(x);
x = x->Flink;
while(x != y) {
printf(",\n ");
print_link(x);
x = x->Flink;
};
};
printf(")\n");
}
void print_files_long(t_files *file, char *options,
int links_column, int size_column)
{
ft_putchar(file->type);
ft_putstr(file->permissions);
ft_putchar(' ');
pad_with_spaces(file, links_column, 1);
ft_putnbr(file->links);
ft_putchar(' ');
if (!ft_strchr(options, 'g'))
{
ft_putstr(file->owner);
ft_putchar(' ');
}
ft_putstr(file->group);
ft_putchar(' ');
print_file_size(file, size_column);
ft_putchar(' ');
ft_putstr(file->date);
ft_putchar(' ');
if (ft_strchr(options, 'G'))
add_color(file);
ft_putstr(file->name);
ft_putstr("\033[0m");
if (file->type == 'l')
print_link(file);
ft_putchar('\n');
}
int main(void)
{
int count_a, count_b;
LinkList la, lb, merge;
count_a = count_b = 0;
la = Creat_LinkList(&count_a);
lb = Creat_LinkList(&count_b);
printf("la:");
print_link(la);
printf("lb:");
print_link(lb);
merge = merge_list(la, lb, count_a, count_b);
printf("merge:");
print_link(merge);
return 0;
}
int main(int argc, char *argv[])
{
pnode_t phead = NULL;
int choice = 0;
phead = create_link();
#ifndef __NDEBUG__
print_link(phead);
#endif
while (1)
{
#ifdef __NDEBUG__
system("clear");
#endif
choice = menu();
if (choice == SEARCH_WORD)
search_for_word(phead);
else if (choice == ADD_WORD)
phead = add_word(phead);
else if (choice == EXIT_DICT)
break;
}
free_link(phead);
return 0;
}
int
show_interface_detail_msg(struct imsg *imsg)
{
struct ctl_iface *iface;
switch (imsg->hdr.type) {
case IMSG_CTL_SHOW_INTERFACE:
iface = imsg->data;
printf("\n");
printf("Interface %s, line protocol is %s\n",
iface->name, print_link(iface->flags));
printf(" Internet address %s Area %s\n",
log_in6addr(&iface->addr), inet_ntoa(iface->area));
printf(" Link type %s, state %s",
get_media_descr(get_ifms_type(iface->if_type)),
get_linkstate(iface->if_type, iface->linkstate));
if (iface->linkstate != LINK_STATE_DOWN &&
iface->baudrate > 0) {
printf(", ");
print_baudrate(iface->baudrate);
}
printf("\n");
printf(" Router ID %s, network type %s, cost: %d\n",
inet_ntoa(iface->rtr_id),
if_type_name(iface->type), iface->metric);
printf(" Transmit delay is %d sec(s), state %s, priority %d\n",
iface->transmit_delay, if_state_name(iface->state),
iface->priority);
printf(" Designated Router (ID) %s\n",
inet_ntoa(iface->dr_id));
printf(" Interface address %s\n",
log_in6addr(&iface->dr_addr));
printf(" Backup Designated Router (ID) %s\n",
inet_ntoa(iface->bdr_id));
printf(" Interface address %s\n",
log_in6addr(&iface->bdr_addr));
printf(" Timer intervals configured, "
"hello %d, dead %d, wait %d, retransmit %d\n",
iface->hello_interval, iface->dead_interval,
iface->dead_interval, iface->rxmt_interval);
if (iface->passive)
printf(" Passive interface (No Hellos)\n");
else if (iface->hello_timer < 0)
printf(" Hello timer not running\n");
else
printf(" Hello timer due in %s\n",
fmt_timeframe_core(iface->hello_timer));
printf(" Uptime %s\n", fmt_timeframe_core(iface->uptime));
printf(" Neighbor count is %d, adjacent neighbor count is "
"%d\n", iface->nbr_cnt, iface->adj_cnt);
break;
case IMSG_CTL_END:
printf("\n");
return (1);
default:
break;
}
return (0);
}
int main(int argc, const char *argv[])
{
V_NODE *head = NULL;
int flag = 0;
print_test();
head = load_link();
while(!flag)
{
print_list();
switch(get_choice())
{
case 1:
head = add_link(head);
break;
case 2:
head = delete_link(head);
break;
case 3:
print_link(head);
break;
case 4:
flag = 1 ;
save_link(head);
break;
default :
break;
}
}
return 0;
}
int main(int argc, const char *argv[])
{
int counter = 0;
STU *head = NULL;
head = create_link(10);
print_link(head);
head = add_node(head);
print_link(head);
counter = get_num(head);
printf("counter = %d\n",counter);
return 0;
}//const 禁止修改内容
void recursive_print_r(Point * pnt){
if(pnt != NULL){
print_link(pnt->parent);
if(pnt->pos <= pnt->next->pos && pnt != pnt->next){
recursive_print_r(pnt->next);
}
}
}
int main(int argc, const char *argv[])
{
stu *head=NULL;
stu *p=delete_link(add_link(head));
print_link(p);
return 0;
}
int main(int argc, const char *argv[])
{
STU *head = NULL;
head = create_link(10);
print_link(head);
printf("crunode = %d\n",crunode);
return 0;
}//const 禁止修改内容
int main(void)
{
STU *head = NULL;
head = create_link(10);
//head=add_note(head);
head = remove_link(head);
print_link(head);
return 0;
}
int main(void)
{
STU *head = NULL;
head = create_link(10);
print_link(head);
return 0;
}
int main()
{
struct node *h, *t;
init();
tree2link(root, &h, &t);
print_link(h);
return 0;
}
int main()
{
link *head=NULL;
head = insert_sort_link(head, 3);
head = insert_sort_link(head, 1);
head = insert_sort_link(head, 4);
head = insert_sort_link(head, 6);
head = insert_sort_link(head, 2);
head = insert_sort_link(head, 5);
print_link(head);
head = link_reverse_2(head, 4);
print_link(head);
return 0;
}
int main(void)
{
int n;
int couter;
STU *head = NULL;
n = howmanyN();
head = create_link(n);
couter = tongjijiedianshu(head);
print_link(head);
printf("total link:%d\n",couter);
return 0;
}
int main(){
// In production code, of course, we won't hardcode this
struct Link * link = load("data.txt");
printf("Print as ordered by genome A\n");
recursive_print(link, 0);
printf("\nPrint as ordered by genome B\n");
recursive_print(link, 1);
printf("\nLowest position on genome A\n");
print_link(get_minimum(link, 0));
printf("\nLowest position on genome B\n");
print_link(get_minimum(link, 1));
printf("\nAll links with scores above 50\n");
recursive_print(winnow(link, 50), 0);
return EXIT_SUCCESS;
}
int main() {
LinkNode *head = NULL;
add_to_tail(&head, 3);
add_to_tail(&head, 5);
add_to_tail(&head, -2);
add_to_tail(&head, 10);
print_link(head);
reverse_print_linklist(head);
LinkNode *null = NULL;
reverse_print_linklist(null);
print_reverse_recursively(head);
printf("\n");
return 0;
}
int main()
{
linknode *head;
head = create_link();
int i;
for(i=0; i<30; i++){
insert_link(head, i);
}
print_link(head);
linknode *tmp = NULL;
tmp = find_node(head, 8);
printf("the top:%d\n", tmp->num);
return 0;
}
int main()
{
int array[] = {4,1,5,3,7,8,2,9,10,11};
/*
4
1 5
3 7 8 2
9 10 11
9 3 10 1 7 11 4 8 5 2
*/
int len = 10;
tree_t* tree_array = tree_create(array,len);//creat a tree.
link_t* root = DFS2LINK(tree_array);
print_link(root);
return 0;
}
static void putlf(t_list *lst, t_max buff, t_opt opt)
{
ft_putchar(((t_ls*)(lst->content))->type);
ft_putendchar(((t_ls*)(lst->content))->rights, ' ');
ft_putstr_right(ft_itoa(((t_ls*)(lst->content))->nb_hlink), buff.mx_hl);
ft_putchar(' ');
if (!opt.g)
{
ft_putstr_left(((t_ls*)(lst->content))->u_name, buff.mx_un);
ft_putstr(" ");
}
ft_putstr_left(((t_ls*)(lst->content))->g_name, buff.mx_gn);
ft_putstr(" ");
ft_putstr_right(ft_itoa(((t_ls*)(lst->content))->size), buff.mx_sz);
ft_putchar(' ');
puttime(lst, opt);
ft_putstr(((t_ls*)(lst->content))->name);
print_link(((t_ls*)(lst->content))->link);
}
/* ARGSUSED */
static void
show_link(void *arg, const char *name)
{
dladm_attr_t dlattr;
boolean_t legacy = B_TRUE;
show_link_state_t *state = (show_link_state_t *)arg;
if (get_if_info(name, &dlattr, &legacy) < 0) {
(void) fprintf(stderr, gettext("%s: invalid device '%s'\n"),
progname, name);
exit(1);
}
if (state->ls_parseable) {
print_link_parseable(name, &dlattr, legacy);
} else {
print_link(name, &dlattr, legacy);
}
}
