2023/4/3 二进制转换

栈的进制转换【链栈实现】

思路：循环把余数入栈

循环出栈，直到栈空为止

#ifndef __HEAD__
#define __HEAD__
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 10

typedef int datatype;
typedef struct Stack
{
	datatype data[MAXSIZE];
	int top;
}*stacklist;


stacklist  create_stack();
int stacklist_push(stacklist stack, datatype e);
int stacklist_output(stacklist stack);
int stacklist_pop(stacklist stack);
stacklist free_space(stacklist stack);


/**============================链栈========
 */
typedef struct Linkstack
{
	union
	{
		int len;
		datatype data;
	};
	struct Linkstack *next;
}*linkstack;


linkstack create_linkstack();
linkstack create_linknode();
int linkstack_push(linkstack link, datatype e);
void linkstack_output(linkstack link);
int linkstack_pop(linkstack link);
int output_bin(linkstack link, datatype e);
linkstack freelink_space(linkstack link);




#endif

#include "head.h"


int main(int argc, const char *argv[])
{
#if 0
	//创建栈
	stacklist stack = create_stack();
	char choise[10];
	datatype e;
	while(1)
	{
		printf("请输入值：");
		scanf("%d", &e);
		//入栈
		stacklist_push(stack, e);
		printf("是否继续：y/n：");
		scanf("%s", choise);
		if(strcmp(choise, "n") == 0)
		{
			break;
		}
	}
	
	stacklist_output(stack);
	//出栈
	stacklist_pop(stack);
	stacklist_output(stack);
	//释放空间
	stack = free_space(stack);
#endif
	linkstack link = create_linkstack();
	//链栈的创建
	char choise[10];
	datatype e;
	while(1)
	{
		printf("请输入值：");
		scanf("%d", &e);
		//入栈[头插]链栈的插入【头插】
		linkstack_push(link, e);
		printf("是否继续：y/n：");
		scanf("%s", choise);
		if(strcmp(choise, "n") == 0)
		{
			break;
		}
	}


	//链栈的删除【头删】
	linkstack_pop(link);
	//链栈的遍历
	linkstack_output(link);
	
	//输入十进度数转二进制
	printf("输入十进制数：");
	scanf("%d", &e);
	output_bin(link, e);
	//链栈的空间释放
	link = freelink_space(link);	

	return 0;
}

#include "head.h"
/*
 * function:    创建
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
stacklist  create_stack()
{
	stacklist stack=(stacklist)malloc(sizeof(struct Stack));
	if(stack == NULL)
	{
		return NULL;
	}
	stack->top = -1;
	return stack;
}

/*
 * function:    创建栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int stacklist_push(stacklist stack, datatype e)
{
	if(stack == NULL || stack->top == MAXSIZE-1)
	{
		printf("压栈失败\n");
		return -1;
	}
	stack->data[++stack->top] = e;
	return 0;
}

/*
 * function:    
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int stacklist_output(stacklist stack)
{
	if(stack==NULL || stack->top == MAXSIZE-1)
	{
		printf("数据为空\n");
		return -1;
	}
	printf("\n");
	for(int i=0; i<=stack->top; i++)
	{
		printf("%d\t", stack->data[i]);
	}
	printf("\n");
	for(int i=stack->top; i>=0 ; i--)
	{
		printf("%d\t", stack->data[i]);
	}
	printf("\n");
	return 0;

}

/*
 * function:    出栈
 * @param [ in] 栈
 * @param [out] 
 * @return      
 */
int stacklist_pop(stacklist stack)
{
	if(stack == NULL || stack->top <= -1)
	{
		printf("出栈失败\n");
		return -1;
	}
	printf("出栈：%d\n", stack->data[stack->top--]);
	return 0;
}

/*
 * function:    释放空间
 * @param [ in] 
 * @param [out] 
 * @return      返回NULL
 */
stacklist free_space(stacklist stack)
{
	if(stack == NULL)
	{
		return NULL;
	}
	free(stack);
	stack = NULL;
	return stack;
}

/**============链栈=====================
 */
/*
 * function:    创建链栈
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
linkstack create_linkstack()
{
	linkstack link=(linkstack)malloc(sizeof(struct Linkstack));
	if(link==NULL)
	{
		return NULL;
	}
	link->len = 0;
	link->next = NULL;
	return link;

}
/*
 * function:    创建链栈节点
 * @param [ in] 
 * @param [out] 
 * @return      返回地址
 */
linkstack create_linknode()
{
	linkstack node=(linkstack)malloc(sizeof(struct Linkstack));
	if(node==NULL)
	{
		return NULL;
	}
	node->data = 0;
	node->next = NULL;
	return node;

}
/*
 * function:    头部压入链栈
 * @param [ in] 链栈 值
 * @param [out] 
 * @return      成功0失败-1
 */
int linkstack_push(linkstack link, datatype e)
{
	if(link == NULL)
	{
		printf("压入栈失败\n");
		return -1;
	}
	linkstack s = create_linknode();
	if(s==NULL)
	{
		return -1;
	}
	s->data = e;
	s->next = link->next;
	link->next = s;
	link->len++;
	return 0;
}
/*
 * function:    遍历输出链栈
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void linkstack_output(linkstack link)
{
	if(link==NULL || link->len==0 )
	{
		printf("输出失败\n");
		return;
	}
	linkstack p=link;
	printf("\n");
	while(p->next!=NULL)
	{
		p = p->next;
		printf("%d\t", p->data);
	}
	printf("\n");
}
/*
 * function:    链栈的删除【弹出栈=》头删】
 * @param [ in] 
 * @param [out] 
 * @return      成功0失败-1
 */
int linkstack_pop(linkstack link)
{
	if(link==NULL || link->len==0)
	{
		printf("弹出失败\n");
		return -1;
	}
	linkstack p = link->next;
	link->next = p->next;
	printf("弹出栈元素是：%d\n", p->data);
	free(p);
	p = NULL;
	link->len--;
	return 0;
}
/*
 * function:    释放空间
 * @param [ in] 
 * @param [out] 
 * @return      返回NULL
 */
linkstack freelink_space(linkstack link)
{
	if(link == NULL)
	{
		return NULL;
	}
	int len = link->len;
	for(int i=0; i<len; i++)
	{
		linkstack_pop(link);
	}
	free(link);
	link = NULL;
	return link;
}
/*
 * function:    输出十进制数转二进制
 * @param [ in] 链栈 十进制
 * @param [out] 
 * @return      二进制
 */
int output_bin(linkstack link, datatype e)
{
	int n = 0;
	while(e>0)
	{
		linkstack_push(link, e%2);
		e /=2;
		n++;
	}
	for(int i=0; i<n; i++)
	{
		linkstack_pop(link);	
	}	
	return 0;
}