栈和线性表的简单应用-数制转换

　　栈结构具有后进先出的特点，是程序设计中的有用工具

我们先来看看进制转换的过程 如图：

可以看出 整数部分符合后进先出的特点，可以应用栈结构

小数部分先进先出，可以应用线性表

　　 栈的头文件 sqstack.h 

#pragma once
#include <stdio.h>
#include <stdlib.h>
#define STACK_INIT_SIZE 100//储存空间初始分配量
#define STACKINCREMENT  10//存储空间分配增量
#define OK 1
#define ERROR 0
typedef int StackType; //栈元素类型

typedef struct {
    StackType *base;   //在构造之前和销毁之后，base的值为NULL
    StackType *top;    //栈顶指针
    int stacksize;     //当前已分配的存储空间，以元素为单位
}SqStack; //顺序栈

//栈的初始化
int InitStack(SqStack *p) {


    p->base = (StackType*)malloc(STACK_INIT_SIZE * sizeof(StackType));
    if (p->base == NULL)  return ERROR;  //内存分配失败
    p->top = p->base;     //栈顶与栈底相同表示一个空栈
    p->stacksize = STACK_INIT_SIZE;
    return OK;

}
//判断栈是否为空
int EmptyStack(SqStack *p) {
    //若为空栈 则返回OK，否则返回ERROR
    if (p->top == p->base) return OK;
    else return ERROR;
}
//顺序栈的压入
int Push(SqStack *p, StackType e) {
    //插入元素e为新的栈顶元素
    if ((p->top - p->base) >= p->stacksize)   //栈满，追加储存空间
    {
        p->base = (StackType*)realloc(p->base, (p->stacksize + STACKINCREMENT) * sizeof(StackType));
        if (p->base == NULL)   return ERROR;// 储存空间分配失败
        p->top = p->base + p->stacksize;   
        p->stacksize += STACKINCREMENT;
    }
    *(p->top) = e;
    (p->top)++;
    return OK;
}
// 顺序栈的弹出     
int Pop(SqStack *p, StackType *e) {
    //若栈不空，则删除p的栈顶元素，用e返回其值
    if (p->top == p->base) return ERROR;
    --(p->top);
    *e = *(p->top);
    return OK;


}
//顺序栈的销毁
int DestroyStack(SqStack *p) {
    //释放栈底空间并置空
    free(p->base);
    p->base = NULL;
    p->top = NULL;
    p->stacksize = 0;

    return OK;
}

　　线性表的头文件 sqlist.h

#pragma once
//顺序线性表
#include <stdio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100 //线性表储存空间的初始分配量
#define LISTINCREMENT 10  //线性表储存空间的分配增量
#define OK 1
#define ERROR 0
typedef double ElemType;
typedef struct {
    ElemType *elem;  //储存空间基地址
    int length;        //当前长度
    int listsize;   //当前分配的储存容量(以sizeof(ElemType))为单位
}SqList;
//顺序表的初始化
void InitList(SqList *L) {
    L->elem = (ElemType*)malloc(LIST_INIT_SIZE);
    if (!L->elem)  //储存分配失败
        exit(-1);
    L->length = 0;    //空表长度为0
    L->listsize = LIST_INIT_SIZE; //初始储存容量
}
//判断表是否为空
int EmptyList(SqList *L)
{
    if (L->length == 0)
    {
        return OK;
    }
    return ERROR;
}
//尾插
int BackInsert(SqList *L,ElemType e) {
    ElemType *newbase, *p;
    if (L->length >= L->listsize)  //当前储存空间已满，增加分配
    {
        newbase = (ElemType*)realloc(L->elem, (L->listsize +
            LISTINCREMENT) * sizeof(ElemType));
        if (!newbase)  exit(-1);
        L->elem = newbase;  //新基地址
        L->listsize += LISTINCREMENT;  //增加储存容量
    }
    p = L->elem + L->length;  //p指向最后一个元素的后一个地址
    *p = e;       //插入e
    L->length++;  //表长加1
    return OK;

}
//打印表中元素
void PrintList(SqList *L)
{
    int i;
    if (EmptyList(L)==OK)
    {
        printf("表为空！
");
        exit(-1);
    }
    for (i = 0; i< L->length; i++)
    {
        printf("%d ",*( L->elem+i));
    }
    printf("
");
}
//销毁表
int DestoryList(SqList *L) {
    
    free(L->elem);
    return OK;
}

　　源代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "sqstack.h" //引入顺序栈储存结构及其基本操作
#include "sqlist.h"  //引入顺序表储存结构及其基本操作
#define OK 1
#define ERROR 0

//对于输入任意一个非负的十进制数，打印与其等值的N进制数
void Conversion(int N) {
    double x, decimal;
    int integer;
    scanf("%lf", &x);
    integer =(int)floor(x);  //整数部分
    decimal = x - integer; //小数部分
    //处理整数部分
    
    StackType *e;
    SqStack *ps, s;
        ps = &s;
        e = (StackType*)malloc(sizeof(StackType));    //为指针e分配内存地址
        InitStack(ps);                               //初始化栈
        while (integer)  //当integer不等于0
        {
            Push(ps, integer % N);  //压入integer 除以N的余数
            integer = integer / N;
        }
        while (EmptyStack(ps) != OK) //当栈不为空
        {
            Pop(ps, e);  //弹出的栈顶元素，并让e指向其地址
            printf("%d ", *e); // 输出e 每一个数码间用空格隔开
        }
        //处理小数部分
        if (decimal) { //小数部分不为0 才处理
            SqList *L;
            ElemType m;
            L = (SqList*)malloc(sizeof(SqList)); //为指针L分配内存地址
            InitList(L);                        //初始化顺序表
            while (decimal)   //当decimal不为0
            {
                m = (ElemType)floor(decimal*N);
                BackInsert(L, m); //插入decimal*N的整数
                decimal = decimal * N - m;
            }
            printf(". ");
            PrintList(L);  //每一个数码之间用空格隔开
        }
}
int main() {
    int N;
    printf("请输入目标进制:");
    scanf("%d", &N);
    printf("将十进制数n转换为%d进制数，请输入:n(>=0)=", N);
    Conversion(N);
    return 0;

}

 　　合理的使用数据结构可以使代码跟易读，易懂。栈的引入

简化了程序设计的问题，划分了不同的关注层次，逻辑思路清晰。