数据结构-java-用栈实现二进制转换

二进制转换问题

• 输入一个数转换为对应的二进制表示

---

解题思路

1. 用栈实现
2. 基于线性表实现栈的ADT
3. 转换关键: 一个数(int)转换为对应的二进制①java自带的toBinaryString方法②辗转相除
4. 此处实现使用辗转相除,有兴趣可以去了解下java自带方法的实现

1. 基于线性表实现ADT

• Seqlist.java 线性表类

package indi.yyh.datastru.project2.SeqList;

//顺序表

public class SeqList<T> extends Object {
     

//私有变量
    protected Object[] element;
    protected int n;

//构造方法
    public SeqList(int length) {
     
        this.element = new Object[length];
        this.n = 0;
    }
    public SeqList() {
     
        this(64);
    }
    public SeqList(T[] values){
     
        this(values.length);
        for(int i=0;i<values.length;i++){
     
            this.element[i] = values[i];
        }
        this.n =element.length;
    }

//成员方法
    public boolean isEmpty(){
     
        return this.n==0;
    }

    public int size(){
     
        return this.n;
    }

    public T get(int i) {
     
        if (i>=0&&i<this.n){
     
            return (T)this.element[i];
        }
        return null;
    }

    public String toString(){
     
        String str = "("; //返回类名
        if (this.n>0){
     
            str += this.element[0].toString();
        }
        for(int i=1; i<this.n;i++){
     
            str += ","+this.element[i].toString();
        }
        return str+")";
    }

    public int insert(int i,T x){
     
        if(x==null){
     
            throw new NullPointerException("x==null");
        }
        if(i<0) i=0;
        if(i>this.n) i =this.n;
        Object[] source =this.element;
        if(this.n==element.length){
              //数组已满
            this.element = new Object[source.length*2];
            for (int j = 0; j<i ; j++){
     
                this.element[j] = source[j];
            }
        }
        for (int j=this.n-1;j>=i;j--) this.element[j+1] = source[j];
        this.element[i] = x;
        this.n++;
        return i;   //返回序列号
    }

    public int insert(T x){
     
        return this.insert(this.n,x);   //尾插入
    }

    public T remove(int i){
     
        if (this.n>0 && i>=0 && i<this.n){
     
            T old = (T)this.element[i];
            for (int j=i; j<this.n-1; j++)
                this.element[j] = this.element[j+1];
            this.element[this.n-1] = null;
            this.n--;
            return old;
    }
        return null;
    }

• Stack.java ADT

package indi.yyh.datastru.project3;

//抽象类型栈类
public interface Stack<T> {
     

    public abstract boolean isEmpty();
    public abstract void push(T x);
    public abstract T peek();
    public abstract T pop();
    
}

• SeqStack.java 实现ADT

package indi.yyh.datastru.project3.Binary;

import indi.yyh.datastru.project2.SeqList.SeqList;
import indi.yyh.datastru.project3.Stack;

public final class SeqStack<T> implements Stack<T> {
     

    private SeqList<T> list;

    // 构造方法
    public SeqStack(int length) {
     
        this.list = new SeqList<T>(length);
    }

    // 默认
    public SeqStack() {
     
        this(64);
    }

    //成员方法
    public boolean isEmpty() {
     
        return this.list.isEmpty();
    }
    public void push(T x) {
     
        this.list.insert(x);
    }
    public T peek() {
     
        return this.list.get(this.list.size()-1);
    }
    public T pop() {
     
        return this.list.remove(this.list.size()-1);
    }

    //转换二进制方法	(有误未实现)
    // public String toBinary(){
     
    //     String str = "";
    //     for(int i = 0; i < list.size() ;i++){
     
    //         str += Integer.toBinaryString((int) this.list.get(i));
    //     }
    //     return str;
    // }
}

• main.java 执行函数中实现算法

        Scanner dec = new Scanner(System.in);
        int Dec =dec.nextInt();
        while(Dec != 0){
     
            int x = Dec%2;
            Dec /= 2;
            stack.push(x);
        }
        while(!stack.isEmpty()){
     
            System.out.print(stack.pop());
        }
        System.out.println("");

---

效果

学习参考使用