2019-08-20 10:48:51 weixin_38745434 阅读数 1112
  • Hadoop大数据从入门到精通

    Hadoop分布式文件系统(HDFS)和MapReduce的工作原理 如何优化Hadoop机群所需要的硬件配置 搭建Hadoop机群所需要考虑的网络因素 如何利用Hadoop配置选项进行系统性能调优 如何利用FairScheduler为多用户提供服务级别保障 Hadoop机群维护和监控 如何使用Flume从动态生成的文件加载数据到Hadoop

    54829 人正在学习 去看看 任亮

Python爬虫太火了,没写过爬虫,都不敢说自己学过Python?!

可是刚一开始学,我就遇到了难题----数据分析!听起来很高大上,有没有?

想要做爬虫,就得先学会使用数据分析工具,制作图表这是最基本的。网上发现一个讲Python数据分析实操的小视频,我觉得讲的超基础,很适合小白,特来分享给大家~

如果你也想学习数据分析,跟我一起看看下方视频,听知名技术专家李刚老师对Python Pygal模块的实操案例详细解析,

Python 数据分析之案例实操

李刚老师出版的《疯狂Java》系列图书曾得到市场的广泛认可,经过多次再版,已被多家高校选作教材。上方视频来自于李刚老师的在线视频课程《21天通关Python》第九章 数据分析之案例实操

鉴于大家都有学习Python的困惑,今天就给大家推荐一本巨有影响力的Python实战书,上线时间仅2个月,就超越了众多实力派,成京东和当当网上的长期畅销图书,并且收获了3.4W的五星好评。

这本书可谓是笔者独家私藏图书之一了,对我学习Python有着莫大的帮助,在京东上也常常"断货",这次拿出来给大家分享一下,希望能帮到大家。

《21天通关Python》视频课程以畅销图书为教材,由图书作者李刚亲自操刀讲解;上手门槛低,可作为0基础掌握Python教材;书籍+线上复合型学习场景特别适合Python小白学习!

点击查看课程:
https://edu.csdn.net/bundled/detail/49?utm_source=jiansuopy65_1
(含图书邮寄+视频教程+社群答疑+导师带队)

笔者跟大家分享一个福利!下单时输入优惠码csdn66,立减20元,券后仅需99元!

扫码入Python技术交流群,可免费听技术讲座+领学习资料+视频课免费看!
在这里插入图片描述

2018-12-04 16:12:57 s12117719679 阅读数 599
  • Hadoop大数据从入门到精通

    Hadoop分布式文件系统(HDFS)和MapReduce的工作原理 如何优化Hadoop机群所需要的硬件配置 搭建Hadoop机群所需要考虑的网络因素 如何利用Hadoop配置选项进行系统性能调优 如何利用FairScheduler为多用户提供服务级别保障 Hadoop机群维护和监控 如何使用Flume从动态生成的文件加载数据到Hadoop

    54829 人正在学习 去看看 任亮

//
//  main.cpp
//  利用栈的数据结构特点完成表达式的运算
//
//  Created by 柯木超 on 2018/12/4.
//  Copyright © 2018 柯木超. All rights reserved.
//

#include <iostream>

#define maxsize 20

/**
 解决思路:
 1、自左向右扫描表达式,凡是遇到操作数一律进操作数栈
 2、当遇到运算符时候,如果他的优先级比运算符栈的栈顶元素(它前面的那个操作符)的优先级低,就取出栈顶运算符和两个连续的操作数进行运算,并将结果存入操作数栈,然后继续比较该运算符与栈顶运算符(它前面的那个操作符)的优先级,反之,就进栈保存,继续往下扫描
 3、如果遇到左括号,一律进运算符栈,右括号一律不进运算符栈,而是取出运算符栈的栈顶运算符和操作数栈的两个操作数进行运算,并将结果押入操作数栈,直到取出左括号为止
 
 第一个例子:a + b * c,我们从前向后扫描,遇到a,压到操作数栈里,遇到 + ,压到操作符栈里,下一个是 b,此时,我们是不能像后缀表达式求值那样,直接计算 a + b,然后压栈的。因为我们不确定,b 是否会先参与后面的运算,所以我们只能把 b 先压栈,继续向后扫描。看到 * 以后,再把 * 压到操作符栈里;看到 c 以后,也要把 c 先压栈,理由与 b 压栈相同。接下来,再往下扫描,就发现已经到了末尾了。那我们就可以放心地从操作符栈里取出顶上的操作符,在这个例子中,就是 *,然后再从操作数栈里取出两个操作数,就是 b 和 c,然后把b和c的积,不妨记为d,放到操作数栈里。接下来,再去看操作符栈里,还有一个 +,那就把 + 取出来,然后去操作数栈里取出 a 和 d,计算它们的和,这就是最终的结果了。
 
 第二个例子:a + b + c,我们从前向后扫描,遇到a,压到操作数栈里,遇到 + ,压到操作符栈里,下一个是 b,压到操作数栈里。再下一个,又是 + ,由于加法的结合律,我们知道,先把a + b 的结果计算出来,或者后计算,都不会影响最终的结果。所以我们就把能做的化简先做掉。就是说,在扫描到第二个操作符是 + 以后,我们就把第一个操作符取出来,再把两个操作数取出来,求和并且把和送到操作数栈里。接下来的过程与第一个例子是相同的,不再赘述了
 
 总的来说就是:
 一个操作符究竟什么时候进行运算,并不取决于它前面的那个操作符是什么,而是取决于它后面的那个操作符是什么。更具体一点讲:如果后面的操作符的运算优化级比前面的操作符高,那么前面的操作符就必须延迟计算;如果后面的操作符优化级比前面的低或者相等,那么前面的操作符就可以进行计算了
 
 参考文章:https://zhuanlan.zhihu.com/p/24556103
 **/


// 数据栈
typedef struct {
    int data[maxsize];
    int top;
}dataStask, *seqDataStask;

// 运算符栈
typedef struct {
    int data[maxsize];
    int top;
}operatorStask, *seqOperatorStask;

// 创建空栈
seqDataStask createStask(){
    seqDataStask L = (seqDataStask)malloc(sizeof(dataStask));
    L->top = -1;
    return L;
}

//  设置空栈
seqDataStask setNULLStask(seqDataStask L){
    L->top = -1;
    return L;
}

// 元素入栈
seqDataStask pushStask(seqDataStask L, int data){
    
    L->data[L->top] = data;
    L->top++;
    
    return L;
}

// 元素出栈
seqDataStask popStask(seqDataStask L, int data){
    
    L->data[L->top] = data;
    L->top--;
    
    return L;
}

// 获取运算符的优先级
int getPri(char cp){
    switch (cp) {
        case '+':
        case '-':
            return 1;
            break;
        case '*':
        case '/':
            return 2;
        case '(':
            return 3;
        default:
            break;
    }
    return 0;
}

int main(int argc, const char * argv[]) {
    
    return 0;
}


// 未完,待续

 

2014-05-27 14:06:54 zhangxiangDavaid 阅读数 4698
  • Hadoop大数据从入门到精通

    Hadoop分布式文件系统(HDFS)和MapReduce的工作原理 如何优化Hadoop机群所需要的硬件配置 搭建Hadoop机群所需要考虑的网络因素 如何利用Hadoop配置选项进行系统性能调优 如何利用FairScheduler为多用户提供服务级别保障 Hadoop机群维护和监控 如何使用Flume从动态生成的文件加载数据到Hadoop

    54829 人正在学习 去看看 任亮

类似于 1*2-3+4-(5-6)-2/4 的式子,我们称为算术表达式。下面我们利用栈这种数据结构来解析它,即用栈来辅助计算算术表达式。

首先我们得明确计算规则:

  1. 先左后右:从左算到右
  2. 先乘除,后加减
  3. 先括号内,后括号外
原理:
  1. 使用两个栈来存储读入的字符:数字栈和符号栈
  2. 读入数字,则压入数字栈
  3. 读入符号,则把当前符号栈顶的符号与读入的符号进行优先级比较。若当前符号栈顶符号的优先级小,则继续把符号压入符号栈;若当前读入符号的优先级小,则数字栈依次出栈两个数,加上符号栈顶的符号,构成一算术表达式,通过计算得出结果,把结果压入数字栈。
  4. 当读入界限符或符号栈弹出界限符,如#,运算结束,数字栈弹栈,即最后的表达式值。
难点:
1、优先级数组priority的理解是难点。
  + - * / ( ) #
+ 1 1 2 2 2 1 1
- 1 1 2 2 2 1 1
* 1 1 1 1 2 1 1
/ 1 1 1 1 2 1 1
( 2 2 2 2 2 3 0
) 1 1 1 1 0 1 1
# 2 2 2 2 2 0 3
每一个位置可以用(i,j)表示,其中i是行,j是列。有一点要明确:符号i是先于符号j的。也就是说,在算术表达式中符号i位于符号j的左边。1:>,2:<,3:=。界限符#的优先级是最低的。举几个例子说明:
  • (+,+)=1,两个'+'是同级的,但第一个先于第二个,由上述的计算规则1知:>。
  • ((,#)=0,如果左括号'('出现了,至少右括号')'出现了之后,才会有界限符,否则出错。
  • (),()=0,我们不支持(...)(...)这种写法,两括号之间至少要有其它的操作符才行,如(...)*(...)。
  • (#,))=0,没遇到左括号'(',怎能出现右括号')',故出错。
2、当符号栈顶的符号优先级高于当前读入的操作符时,数字栈出栈的第一个数字作为第二个操作数,下一个出栈的数字才作为第一个操作数,这一点得明白。operand:操作数 operator:操作符
细节看代码:
#include<iostream>
#include<stack>
using namespace std;

char OP[7] = {'+','-','*','/','(',')','#'};  //运算符集合
int priority[7][7] =     //各运算符相遇时,优先级比较 1:大于,2:小于,3:等于,0:不可能,错误
{
	{ 1, 1, 2, 2, 2, 1, 1 },
	{ 1, 1, 2, 2, 2, 1, 1 },
	{ 1, 1, 1, 1, 2, 1, 1 },
	{ 1, 1, 1, 1, 2, 1, 1 },
	{ 2, 2, 2, 2, 2, 3, 0 },
	{ 1, 1, 1, 1, 0, 1, 1 },
	{ 2, 2, 2, 2, 2, 0, 3 }
};
bool isOpat(char c)   //是否是OP[]中的操作符
{
	for (int i = 0; i < 7; i++)
	{
		if (c == OP[i])
			return true;
	}
	return false;
}
int getPriority(char c1,char c2)  //比较优先级
{
	int i, j;
	for (int r = 0; r < 7; r++)
	{
		if (c1 == OP[r])
			i = r;
		if (c2 == OP[r])
			j = r;
	}
	return priority[i][j];
}
int compute(char a, char op, char b)
{
	switch (op)
	{
	case '+':
		return (a - '0') + (b - '0');
	case '-':
		return (a - '0') - (b - '0');
	case '*':
		return (a - '0')*( b - '0');
	case '/':
		if (b == '0')
		{
			cout << "错误!" << endl;
			exit(0);
		}
		return (a - '0')/(b - '0');
	}
}
void evaluateExpression()   //计算
{
	stack<char> opan,opat;    //构建两个栈 operand:操作数,operator:操作符
	opat.push('#');    // # 压入符号栈,作为界限符
	cout << "输入算术表达式" << endl;
	char op,a,b,c;
	c=getchar();
	while (c != '#' || opat.top() != '#')  //没有读到 '#',或者符号栈也没空,则继续读取字符
	{
		//对读入的字符进行判断:是操作数还是操作符?
		if (!isOpat(c))  //是操作数则压入操作数栈
		{
			opan.push(c);
			c = getchar();
		}
		else   //若是操作符,则需把符号栈顶的操作符与当前读入的操作符,进行优先级比较
		{
			switch(getPriority(opat.top(), c))
			{
			case 1:
				op = opat.top(); opat.pop();
				b = opan.top(); opan.pop();
				a = opan.top(); opan.pop();
				opan.push(char(compute(a,op,b)+'0'));
				break;
			case 2:
				opat.push(c);
				c = getchar();
				break;
			case 3:
				opat.pop();
				c = getchar();
				break;
			case 0:
				cout << "错误!" << endl;
				exit(0);
			}
		}
	}
	cout << "= " << opan.top()-'0' << endl;
}
int main()
{
	cout << "使用栈结构解析计算表达式"<<endl;
	evaluateExpression();
	system("pause");
	return 0;
}

运行:计算 1+2-3*(3-5)


说明:可以使用栈的实现:顺序栈中的代码,但这里为了方便,减少代码量,使用#include<stack>,其实效果是一样的。以上程序,只是完成了简单的运算。说它简单是因为:只能输入0-9的数字,并且不能处理以符号开头的表达式,如-3*4,+2-5,则出错。后续补充增强版,能处理诸如 34+34,多位数的运算。

update 2014-5-28 00:28

这次更新,解决了上述问题,并添加了求余%运算符。代码如下:
#include<iostream>
#include<stack>
using namespace std;
char OP[8] = {'+','-','*','/','%','(',')','#'};  //运算符集合
int priority[8][8] =   //各运算符相遇时,优先级比较 1:大于,2:小于,3:等于,0:不可能,错误
{
	{ 1, 1, 2, 2, 2, 2, 1, 1 },
	{ 1, 1, 2, 2, 2, 2, 1, 1 },
	{ 1, 1, 1, 1, 1, 2, 1, 1 },
	{ 1, 1, 1, 1, 1, 2, 1, 1 },
	{ 1, 1, 1, 1, 1, 2, 1, 1 },
	{ 2, 2, 2, 2, 2, 2, 3, 0 },
	{ 1, 1, 1, 1, 1, 0, 1, 1 },
	{ 2, 2, 2, 2, 2, 2, 0, 3 }
};
bool isOpat(char c)   //是否是OP[]中的操作符
{
	for (int i = 0; i < 8; i++)
	{
		if (c == OP[i])
			return true;
	}
	return false;
}
int getPriority(char c1,char c2)  //比较优先级
{
	int i, j;
	for (int r = 0; r < 8; r++)
	{
		if (c1 == OP[r])
			i = r;
		if (c2 == OP[r])
			j = r;
	}
	return priority[i][j];
}
int compute(int a, char op, int b)
{
	switch (op)
	{
	case '+':
		return a + b;
	case '-':
		return a - b;
	case '*':
		return a*b;
	case '/':
	case '%':
		if (b == 0)
		{
			cout << "错误!" << endl;
			exit(0);
		}
		if (op == '/')
			return a / b;
		else
			return a%b;

	}
}
void evaluateExpression()   //计算
{
	stack<int> opan;     //操作数栈
	stack<char> opat;    //操作符栈
	opat.push('#');    // # 压入符号栈,作为界限符
	cout << "输入算术表达式" << endl;
	char op,c,cn;    //cn:char next下一个字符
	int a,b,data;
	c=getchar();
	if (isOpat(c))   //如果第一个字符就是操作符,则把0压入数字栈
		opan.push(0);
	while (c != '#' || opat.top() != '#')  //没有读到 '#',或者符号栈也没空,则继续读取字符
	{
		//对读入的字符进行判断:是操作数还是操作符?
		if (!isOpat(c))  //是操作数则压入操作数栈
		{
			data = c - '0';
			while (!isOpat(cn = getchar()))   //下一个字符任为数字
			{
				data = data * 10 + cn - '0';
			}
			opan.push(data);
			c = cn;   //把cn中的操作符赋给c
		}
		else   //若是操作符,则需把符号栈顶的操作符与当前读入的操作符,进行优先级比较
		{
			switch(getPriority(opat.top(), c))
			{
			case 1:
				op = opat.top(); opat.pop();
				b = opan.top(); opan.pop();
				a = opan.top(); opan.pop();
				opan.push(compute(a,op,b));
				break;
			case 2:
				opat.push(c);
				c = getchar();
				break;
			case 3:
				opat.pop();
				c = getchar();
				break;
			case 0:
				cout << "错误!" << endl;
				exit(0);
			}
		}
	}
	cout << "= " << opan.top() << endl;
}
int main()
{
	cout << "使用栈结构解析计算表达式"<<endl;
	evaluateExpression();
	system("pause");
	return 0;
}
运行:  -4+34%3+5*(3-5)

大家可以测试一下其它的表达式。不过还有点问题:那就是除法,用的是计算机中整数的除法,得到的只是整数,为什么不可以使用实数的除法,这点还有待改进。


若是对你有所帮助,或是觉得有意思,希望顶一个哦。


专栏目录:


2018-03-30 15:32:58 CSDN_GIA 阅读数 11724
  • Hadoop大数据从入门到精通

    Hadoop分布式文件系统(HDFS)和MapReduce的工作原理 如何优化Hadoop机群所需要的硬件配置 搭建Hadoop机群所需要考虑的网络因素 如何利用Hadoop配置选项进行系统性能调优 如何利用FairScheduler为多用户提供服务级别保障 Hadoop机群维护和监控 如何使用Flume从动态生成的文件加载数据到Hadoop

    54829 人正在学习 去看看 任亮

利用栈实现进制转换

一、二进制转十进制

利用栈的数据结构特点,将二进制转换为十进制数。

二进制数是计算机数据的存储形式,它是由一串0和1组成的,每个二进制数转换成相应的十进制数方法如下:
(XnXn-1……X3X2X1)2 = X1*2^0+X2*2^1+…+Xn*2^(n-1)

一个二进制数要转换为相应的十进制数,就是从最低位起用每一位去乘以对应位的积,也就是说用第n位去乘以2^(n-1),然后全部加起来。

二进制转十进制.png

由于栈具有后进先出的特性,
例如输入11001001这样的二进制数,
如图:

栈中的二进制数.png

代码实现:

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

#define STACK_INIT_SIZE 20   
#define STACKINCREMENT  10

typedef char ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;  
}sqStack;

void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }
    }

    *(s->top) = e;
    s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
    {
        return;
    }
    *e = *--(s->top);
}

int StackLen(sqStack s)
{
    return (s.top - s.base);
}

int main()
{
    ElemType c;
    sqStack s;
    int len, i, sum = 0;

    InitStack(&s);

    printf("请输入二进制数,输入#符号表示结束!\n");
    scanf("%c", &c);
    while( c != '#' )
    {
        Push(&s, c);
        scanf("%c", &c);
    }

    getchar();  // 把'\n'(回车)从缓冲区去掉

    len = StackLen(s);
    printf("栈的当前容量是: %d\n", len);

    for( i=0; i < len; i++ )
    {
        Pop(&s, &c);
        sum = sum + (c-48) * pow(2, i);
    }

    printf("转化为十进制数是: %d\n", sum);

    return 0;
}

二、二进制转八进制

二进制是计算机唯一认识的,十进制是人们通常使用的。

观察二进制跟十六进制的对应关系:

二进制与十六进制的对应关系.png

可见一个字节(8bit)刚好用两个十六进制数可以表示完整,也大大的节省了显示空间。

八进制:因为早期的计算机系统都是三的倍数,所以用八进制比较方便。

在进行二进制到八进制的转换时,要将二进制数的每三位转换成一个八进制数来表示,然后按顺序输出即可。

1.png

2.png

3.png

代码实现:

/**  二进制/八进制转换器   **/

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

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10

typedef char ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

// 函数功能:初始化栈
// 参数*s:栈的地址
void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

// 函数功能:入栈操作
// 参数*s:栈的地址
// 参数e:待压入栈的元素
void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

// 函数功能:弹栈操作
// 参数*s:栈的地址
// 参数e:存放从栈里弹出的数据
void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
    {
        return;
    }
    *e = *--(s->top);
}

// 函数功能:计算栈s的当前长度
// 参数s:栈
int StackLen(sqStack s)
{
    return (s.top - s.base);
}

int main()
{
    ElemType c;
    sqStack s1;
    sqStack s2;
    int len, i, j, sum = 0;

    InitStack(&s1); // 初始化栈s1,用来存放二进制输入

    printf("请输入二进制数,输入‘#’号表示结束!\n\n");
    scanf("%c", &c);
    while( c != '#' )
    {
        if( c=='0' || c=='1' )  // 检查输入是否二进制
            Push(&s1, c);
        scanf("%c", &c);
    }
    getchar();      // 把'\n'从缓冲区去掉
    len = StackLen(s1);

    InitStack(&s2); // 初始化栈s2,用来存放转换的八进制

    for( i=0; i < len; i+=3 )
    {
        for( j=0; j < 3; j++ )
        {
            Pop( &s1, &c ); // 取出栈顶元素
            sum = sum + (c-48) * pow(2, j);

            if( s1.base == s1.top )
            {
                break;
            }
        }

        Push( &s2, sum+48 );
        sum = 0;
    }

    printf("\n转化为八进制数是: ");
    while( s2.base != s2.top )
    {
        Pop( &s2, &c );
        printf("%c", c);
    }
    printf("(O)\n");

    return 0;
}

三、二进制转十六进制

代码实现:

/** 二进制/十六进制转换器  **/

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

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10

typedef char ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

// 函数功能:初始化栈
// 参数*s:栈的地址
void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

// 函数功能:入栈操作
// 参数*s:栈的地址
// 参数e:待压入栈的元素
void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

// 函数功能:弹栈操作
// 参数*s:栈的地址
// 参数e:存放从栈里弹出的数据
void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
    {
        return;
    }
    *e = *--(s->top);
}

// 函数功能:计算栈s的当前长度
// 参数s:栈
int StackLen(sqStack s)
{
    return (s.top - s.base);
}

int main()
{
    ElemType c;
    sqStack s1;
    sqStack s2;
    int len, i, j, sum = 0;

    InitStack(&s1); // 初始化栈s1,用来存放二进制输入

    printf("请输入二进制数,输入‘#’号表示结束!\n\n");
    scanf("%c", &c);
    while( c != '#' )
    {
        if( c=='0' || c=='1' )  // 检查输入是否二进制
            Push(&s1, c);
        scanf("%c", &c);
    }
    getchar();      // 把'\n'从缓冲区去掉
    len = StackLen(s1);

    InitStack(&s2); // 初始化栈s2,用来存放转换的八进制

    for( i=0; i < len; i+=4 )
    {
        for( j=0; j < 4; j++ )
        {
            Pop( &s1, &c ); // 取出栈顶元素
            sum = sum + (c-48) * pow(2, j);

            if( s1.base == s1.top )
            {
                break;
            }
        }

        switch( sum )
        {
            case 10: sum = 'A'; break;
            case 11: sum = 'B'; break;
            case 12: sum = 'C'; break;
            case 13: sum = 'D'; break;
            case 14: sum = 'E'; break;
            case 15: sum = 'F'; break;
            default: sum += 48;
        }

        Push( &s2, sum );
        sum = 0;
    }

    printf("\n转化为十六进制数是: ");
    while( s2.base != s2.top )
    {
        Pop( &s2, &c );
        printf("%c", c);
    }
    printf("(H)\n");

    return 0;
}
2018-02-15 11:21:39 magic_faker 阅读数 52
  • Hadoop大数据从入门到精通

    Hadoop分布式文件系统(HDFS)和MapReduce的工作原理 如何优化Hadoop机群所需要的硬件配置 搭建Hadoop机群所需要考虑的网络因素 如何利用Hadoop配置选项进行系统性能调优 如何利用FairScheduler为多用户提供服务级别保障 Hadoop机群维护和监控 如何使用Flume从动态生成的文件加载数据到Hadoop

    54829 人正在学习 去看看 任亮

利用栈的数据结构,将二进制转换为十进制

  1. 首先初始化创建一个栈
  2. 然后通过循环语句输入二进制0/1,用’#”作为结束标志。在输入的过程,用push()将二进制字符串从高位到低位顺序压栈
  3. 输入完毕,用StackLen()函数得到二进制的长度,然后通过循环逐一从栈顶取数,用pop()函数实现,取出的字符存放在变量c中,c-48是为了得到字符对应的0/1值,0的asii码为48,函数pow(x,y)是计算x的y次方,通过sum=sum+(c-48)*pow(2,i);
  4. 最终sum就是输入的二进制数对应的十进制数,将其输出到屏幕
/*利用栈的数据结构,将二进制转换为十进制数*/

include "stdio.h"
#define Stack_INIT_size 100;
#define Stackincrement 10;
typedef char ElemType;

typedef struct{
   ElemType * base;  //base指向栈底的指针变量
   ElemType * top;    //top指向栈顶的指针变量
   int stacksize;   //指示栈的当前可使用的最大容量
}
sqStack;


 void initStack(sqStack *s)
{
    /*内存中开辟一段连续的空间作为栈空间,首地址赋值给s->base*/
    s-> base=(ElemType *) malloc (Stack_INIT_size *sizeof(ElemType));
    if(!s->base) exit(0);
    s->top=s->base; //最开始的时候,栈顶就是栈底此时为空栈
    s->stacksize=Stack_INIT_size;//最大的容量为Stack_INIT_size
}



 void Push(sqStack* s,ElemType e){
     if(s->top-s->base >=s->stacksize)
     //栈满,追加空间
     {
         s->base=(ElemType *)realloc(s->base,(s->stacksize+Stackincrement)*sizeof(ElemType));
         if(!s->base) exit(0);
         s->top=s->base+s->stacksize;
         s->stacksize=s->stacksize+Stackincrement;
     }
     *(s->top)=e;
     s->top++;
 }


 void Pop(sqStack*s ,ElemType*e){
     if(s->top==s->base) return;
     *e=*--(s->top);
     //先--再赋值
 }

 int StackLen(sqStack s){
     return (s.top-s.base);
 }

 DestroyStack (sqStack *s){
     free(s->base); //释放内存空间
     s->base=s->top=NULL; //栈底栈顶的指针置NULL
     s->stacksize=0;
 }

 int main(){

    ElemType c ;
    sqStack s;
    int len,i,sum=0;
    printf("please input a Binary digit\n");
    initStack(&S);
    scan("%c",&c);
    while(c!='#'){
          Push(&s,c);
          scanf("%c",&c);
    }
     getchar();
     len=StackLen(s);
//得到栈中的元素个数
for(i=0;i<len;i++){
Pop(&s,&c);
sum=sum+(c-48)*pow(2,i);
}
printf("Decimal is %d \n",sum);
DestroyStack(&s);
getche();
 }







数字反转

阅读数 3506

利用栈的数据结构实现数字反转

博文 来自: Vipin_Pei
没有更多推荐了,返回首页