作业-11.1

1、课上代码

#include "looplink.h"

//创建单向循环链表
linklist *loop_creat()
{
linklist *p = (linklist *)malloc(sizeof(linklist));
if(!p)
{
printf("申请失败\n");
return NULL;
}else
{
p->len = 0;
p->next = p;

return p;
}
}

//创建节点
linklist *loop_node_creat()
{
linklist *l = (linklist *)malloc(sizeof(linklist));
if(!l)
{
printf("申请失败\n");
return NULL;
}
else
{
return l;
}
}

//判空
int loop_empty(linklist *p)
{
if (!p)
{
printf("入参为空\n");
return 0;
}else
{
return 1;
}
}

//头插
int loop_insert_head(linklist *p, int in_data)
{

if(loop_empty(p))
{
linklist *l = loop_node_creat();
linklist *tmp = p->next;
p->next = l;
l->next = tmp;
l->data = in_data;
p->len++;
}

return 0;
}

//尾插
int loop_insert_tail(linklist *p, int in_data)
{
if(loop_empty(p))
{
linklist *l = loop_node_creat();
l->next = p;
l->data = in_data;
linklist *tmp = p;
while(tmp != p->next)
{
p = p->next;
}
p->next = l;
tmp->len++;
}
return 0;

}

//遍历
int loop_all_printf(linklist *p)
{
if(loop_empty(p))
{
linklist *tmp = p->next;
while(tmp != p)
{
printf("%d\n", tmp->data);
tmp = tmp->next;
}
}
return 0;
}

//尾删
int loop_del_tail(linklist *p)
{
if(loop_empty(p))
{
linklist *tmp = p;
while(p != tmp->next->next)
{
tmp = tmp->next;
}
free(tmp->next);
tmp->next = p;
p->len--;

return 0;
}
}

//删除头结点
linklist * lopp_del_head_node(linklist *p)
{
if(loop_empty(p))
{
linklist *head = p->next;
linklist *tail = p;
while (tail->next != p)
{
tail = tail->next;
}
tail->next = head;
free(p);
p=NULL;

return head;
}
}

//删除头结点的遍历
int loop_no_head_node_printf(linklist *p)
{
if(loop_empty(p))
{
printf("%d.\n", p->data);
linklist *tmp = p->next;
while(p != tmp)
{
printf("%d.\n", tmp->data);
tmp = tmp->next;
}
return 0;
}
}

#ifndef __LOOPLINK_H__
#define __LOOPLINK_H__
#include <stdlib.h>
#include <stdio.h>
typedef struct looplink
{
union
{
int data;
int len;
};
struct looplink *next;
}linklist;

//判空
int loop_empty(linklist *p);
//创建单向循环链表
linklist *loop_creat();
//创建节点
linklist *loop_node_creat();
//头插
int loop_insert_head(linklist *p, int in_data);
//尾插
int loop_insert_tail(linklist *p, int in_data);
//遍历
int loop_all_printf(linklist *p);
//尾删
int loop_del_tail(linklist *p);
//删除头结点
linklist * lopp_del_head_node(linklist *p);
//删除头结点的遍历
int loop_no_head_node_printf(linklist *p);



#endif

#include "looplink.h"

int main(int argc, const char *argv[])
{
linklist *P = loop_creat();
loop_insert_head(P,5201314);
loop_insert_head(P,520);
loop_insert_tail(P,1314);
loop_insert_tail(P,130014);
loop_all_printf(P);
printf("len = %d.\n", P->len);
printf("----------------\n");
loop_del_tail(P);
printf("len = %d.\n", P->len);
loop_all_printf(P);
printf("----------------\n");
P = lopp_del_head_node(P);
loop_no_head_node_printf(P);

return 0;
}
#include "dblist.h"

//判空
int dblink_empty_YN(dblinklist *p)
{
if(!p)
{
printf("入参为空\n");

return 0;
}
else
{
return 1;
}
}

//创建双链表
dblinklist  *dblink_creat()
{
dblinklist *p = (dblinklist *)malloc(sizeof(dblinklist));
if(dblink_empty_YN(p))
{
p->len = 0;
p->pro = NULL;
p->next = NULL;

return p;
}else
{
return NULL;
}
}

//创建节点
dblinklist *dblink_node_creat()
{
dblinklist *p = (dblinklist *)malloc(sizeof(dblinklist));
if(dblink_empty_YN(p))
{
return p;
}else
{
return NULL;
}
}

//头插
int dblink_insert_head(dblinklist *p, int in_data)
{
if(dblink_empty_YN(p))
{
dblinklist *tmp = p->next;
dblinklist *l = dblink_creat();
if(tmp)
{
p->next = l;
l->pro = p;
tmp->pro = l;
l->next = tmp;
}else
{
p->next = l;
l->pro = p;
l->next = NULL;
}
l->data = in_data;
p->len++;

return 0;

}else
{
return -1;
}
}

//尾插
int dblinklist_insert_tail(dblinklist *p, int in_data)
{
if(dblink_empty_YN(p))
{
dblinklist *l = dblink_node_creat();
dblinklist *tmp = p;
if(dblink_empty_YN(l))
{
while(tmp->next)
{
tmp = tmp -> next;
}
tmp->next = l;
l->pro = tmp;
l->next = NULL;
l->data = in_data;
p->len++;

return 0;

}else
{
return -1;
}
}else
{
return -1;
}
}

//遍历
int dblink_all_printf(dblinklist *p)
{
if(dblink_empty_YN(p))
{
p = p->next;
while(p)
{
printf("%d.\n", p->data);
p = p->next;
}

}else
{
return -1;
}
}

//按位置查找
dblinklist *dblink_find_bit(dblinklist *p, int bit)
{
if(bit<1 || bit>p->len)
{
printf("位置不合理\n");

return NULL;
}
if(dblink_empty_YN(p))
{
while(bit)
{
p = p->next;
bit--;
}
return p;
}
}

//任意位置插入
int dblink_insert_bit(dblinklist *p, int bit, int in_data)
{
if(dblink_empty_YN(p))
{
dblinklist *l = dblink_creat();
dblinklist *tmp = dblink_find_bit(p, bit);
if(dblink_empty_YN(l) && tmp)
{
l->next = tmp;
l->pro = tmp->pro;
tmp->pro->next = l;
tmp->pro = l;

l->data = in_data;
p->len++;

return 0;
}
else
{
return -1;
}

}
else
{
return -1;
}
}

//任意位置删除
int dblink_del_bit(dblinklist *p, int bit)
{
if(dblink_empty_YN(p))
{
dblinklist *tmp = dblink_find_bit(p, bit);
if(tmp)
{
if(tmp->next)
{
tmp->pro->next = tmp->next;
tmp->next->pro = tmp->pro; 
}else
{
tmp->pro->next = NULL;
tmp->pro = NULL;
}
free(tmp);
tmp = NULL;

}else
{
return -1;
}
}else
{
return -1;
}
}

#ifndef __DBLIST_H__
#define __DBLIST_H__

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

typedef struct dblink
{
union
{
int data;
int len;
};
struct dblink *pro;
struct dblink *next;
}dblinklist;

//判空
int dblink_empty_YN(dblinklist *p);
//创建双链表
dblinklist  *dblink_creat();
//创建节点
dblinklist *dblink_node_creat();
//头插
int dblink_insert_head(dblinklist *p, int in_data);
//尾插
int dblinklist_insert_tail(dblinklist *p, int in_data);
//遍历
int dblink_all_printf(dblinklist *p);
//按位置查找
dblinklist *dblink_find_bit(dblinklist *p, int bit);
//任意位置插入
int dblink_insert_bit(dblinklist *p, int bit, int in_data);
//任意位置删除
int dblink_del_bit(dblinklist *p, int bit);

#endif

#include "dblist.h"

int main(int argc, const char *argv[])
{
dblinklist *P = dblink_creat();
dblink_insert_head(P,100);
dblinklist_insert_tail(P,500);
printf("--------1----------\n");
dblink_all_printf(P);

printf("---------2----------\n");
dblink_insert_bit(P, 2, 199);
dblink_all_printf(P);

printf("----------3---------\n");
dblink_insert_bit(P, 1, 128);
dblink_all_printf(P);

printf("-----------4--------\n");
dblink_insert_bit(P, 3, 648);

dblink_all_printf(P);
printf("-----------5-----\n");
dblinklist *p1 = dblink_find_bit(P,2);
printf("%d.\n", p1->data);

printf("------------6-------\n");
dblink_insert_bit(P, 5, 1996);
dblink_all_printf(P);

printf("-----------7--------\n");
dblink_del_bit(P,1);
dblink_all_printf(P);

return 0;
}


#include "stack.h"

//创建顺序栈
stack *creat_stack()
{
stack *p = (stack *)malloc(sizeof(stack));
if(!p)
{
return NULL;
}
memset(p->data,0,sizeof(p->data));
p->top = -1;
return p;
}

//判空
int empty_stack(stack *p)
{
if(!p)
{
printf("入参为空\n");

return 0;
}else
{
return 1;
}
}

//判满
int full_stack(stack *p)
{
if(empty_stack(p))
{
return p->top==MAX-1?0:1;
}else
{
return -1;
}
}

//入栈:先加后压，先把栈顶元素下标+1，
//再压入
int pash_stack(stack *p, int in_data)
{
if(empty_stack(p) && full_stack(p))
{
p->top++;
p->data[s->top] = in_data;

return 0;
}else
{
return -1;
}

}

//出栈
int pop_stack(stack *p)
{
if(empty_stack(p) && full_stack(p))
{
printf("%d.\n", p->data[p->data]);
p->top--;
}else
{
return -1;
}
}

//遍历
int print_stack(stack *p)
{
if(empty_stack(p))
{
int i = top-1;
while(i>=0)
{
printf("%d.\n", p->data[i]);
i--;
}
return 0;
}else
{
return -1;
}
}

//销毁栈
int del_stack(stack *p)
{
if(empty_stack(p))
{
free(p);
p = NULL;
}else
{
return -1;
}
}

2、实现双向链表的任意位置删除

//任意位置删除
int dblink_del_bit(dblinklist *p, int bit)
{
if(dblink_empty_YN(p))
{
dblinklist *tmp = dblink_find_bit(p, bit);
if(tmp)
{
if(tmp->next)
{
tmp->pro->next = tmp->next;
tmp->next->pro = tmp->pro; 
}else
{
tmp->pro->next = NULL;
tmp->pro = NULL;
}
free(tmp);
tmp = NULL;

}else
{
return -1;
}
}else
{
return -1;
}
}

3、输入一个三位数，使用递归实现，按位输出

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

int num_printf(int n)
{
char next=0;
if(n==1)
{
next = getchar();
putchar(next);
putchar(10);

return 0;
}
next = getchar();
putchar(next);
putchar(10);

return num_printf(n-1);
}
int main(int argc, const char *argv[])
{
printf("请输入三位数\n");
num_printf(3);

return 0;
}

4、思维导图