第六章

1. 题目

    题目1：将非负十进制整数n转换成b进制。（其中b=2~16） 

    2.算法构造

    2.1算法设计思路:

    将非负十进制数n转换为b进制，就拿十进制转二进制来说，大多数我们都是使用短除法，先求a%2,得出余数h,然后再用a=a/2,  然后再求a%2,一直循环下去，直到a==0,然后将得到的余数h依次倒序输出即为这个十进制数的二进制数，因此该程序使用了栈，利用栈的先进后出的特点，可将得到的余数倒序输出。

  设输入的需要转化的数字为a,需要转化的进制为b，h为余数;递归出口是当a=0时，返回h,递归体是if(a!=0)  h=a%b,a=cal(a/b,b);

在执行完h=a%b后，执行lStack.push(h);将h入栈，因为十一进制到十六进制中10~15需要用A~F表示，所以这里使用switch选择语句，将与得出的H相对应的字母入栈。

   2.2递归公式如下：

2.3非递归流程图：

3.代码如下：

/**
 *递归算法
 *by qiuerduoer
 */
import java.util.Scanner;
 class LinkStack {
    
    private Element base;
    private Element top;
     
    class Element
    {
        public Object data;
        public Element next;
    }
     //初始化栈
     public void initStack()
    {
        top = new Element();
        base = new Element();
        top.data=null;
        top.next=base;
        base.data=null;
        base.next=null;
    }
     
    
     //入栈
    public void push(Object o)
    {
        Element e = new Element();
        e.data = o;
        if(top.next==base)//第一次入栈操作
        {
            e.next=base;
            top.next=e;
        }else
        {
            e.next=top.next;
            top.next=e;
        }
         
    }
    // 判断栈是否为空
    public Boolean isEmpty()
    {
        if(top.next==base)
        {
            return true;
        }
        return false;
    }
    //出栈
 
    public Object pop()
    {
        Object o = null;
        if(top.next==base)
        {
            System.out.println("栈中没有元素！");
            return o;
        }else
        {
            o = top.next.data;
            //System.out.println("出栈操作"+o);
            top.next=top.next.next;
        }
        return o;
    }
    
    // 打印栈
   
    public void print()
    {
        System.out.print("打印栈：");
        Element temp =top;
        while(temp.next!=base)
        {
            System.out.print(temp.next.data+"\t");
            temp =temp.next;
        }
        System.out.println();
    }
}
class Count5 {
	int h;//余数
	int cal(int a,int b) {
        
        LinkStack lStack = new LinkStack();
        lStack.initStack();
        //递归出口
	    if(a==0){
			return h;	
		}
		//递归体
		else if(a!=0){
			h=a%b;
			switch(h) {
			case 10:
				lStack.push('A');//若h==10,'A'入栈
				break;
			case 11:
				lStack.push('B');//若h==11,'B'入栈
				break;
			case 12:
				lStack.push('C');//若h==12,'C'入栈
				break;
			case 13:
				lStack.push('D');//若h==13,'D'入栈
				break;
			case 14:
				lStack.push('E');//若h==14,'E'入栈
				break;
			case 15:
				lStack.push('F');//若h==15,'F'入栈
				break;
			default:lStack.push(h);//若h<10,h入栈
			    break;
			}	
			a=cal(a/b,b);
		}
	 while(!lStack.isEmpty()){
	    	
	System.out.print(lStack.pop());
	
	 }
	 return 0;
	    }
	
}
public class Example17 {
  public static void main(String[] args) {
	  
      
	 System.out.println("请输入您需要转换的数字（非负整数）："); 
	 Scanner scanner =new Scanner(System.in);
	 int a=scanner.nextInt();
	 if(a>0) {
	 System.out.println("请输入您需转化的进制(2~16):"); 
	 int b=scanner.nextInt();
	 Count5 count=new Count5();
	 count.cal(a, b);
	 }
	 else {
		 System.out.println("输入错误，请重新输入！");
	 }
  }
}

/**
 *非递归算法
 *部分代码，其余部分与递归算法差不多一直
 *by qiuerduoer
 */



class Count6 {
	int h;//余数
	int cal(int a,int b) {
      
       LinkStack lStack = new LinkStack();
       lStack.initStack();
       while(a!=0) {
			h=a%b;
			switch(h) {
			case 10:
				lStack.push('A');//若h==10,'A'入栈
				break;
			case 11:
				lStack.push('B');//若h==11,'B'入栈
				break;
			case 12:
				lStack.push('C');//若h==12,'C'入栈
				break;
			case 13:
				lStack.push('D');//若h==13,'D'入栈
				break;
			case 14:
				lStack.push('E');//若h==14,'E'入栈
				break;
			case 15:
				lStack.push('F');//若h==15,'F'入栈
				break;
			default:lStack.push(h);//若h<10,h入栈
			    break;
			}	
			
			 
		}
	 while(!lStack.isEmpty()){
	    	
	System.out.print(lStack.pop());
	
	 }
	 return 0;
	    }
	
}

4.运行结果

5.总结

编写该程序的遇到的最棘手的问题就是将十进制转换成十一及十一进制以后的进制，想了好久才发现可以直接使用switch选择语句，将10到15相对应的字母入栈即可。

通过本章的学习，最大的收获就是学习并掌握了递归程序的设计方法，学会了如何分析并设计递归模型、如何将递归算法变换到非递归算法。