Java基础篇

最新推荐文章于 2017-12-18 22:01:00 发布

原创最新推荐文章于 2017-12-18 22:01:00 发布 · 603 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

8 篇文章

订阅专栏

博客包含测试素数的简单程序，还介绍了实现整数堆栈的Stack类，同时给出调用代码示例，如先递归调用再写处理代码，以层次遍历二叉树为例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Number one : 测试素数的一个简单程序

boolean IsPrime(int num){
	boolean isPrime = true; 
	num = 14;
	for(int i=2; i <= num/2; i++) { 
		if((num % i) == 0) { 
		    isPrime = false; 
		    break; 
		} 
	} 
	    return isPrime;
}

Number two : Stack的类，实现整数的堆栈

class Stack { 
	private int stck[]; 
	private int tos; 
// Initialize top-of-stack 
	Stack(int num ) { 
		stck = new int[num];
		tos = -1; 
	} 
	
	Stack() { 
		stck = new int[10];
		tos = -1; 
	}
// Push an item onto the stack 
	void push(int item) { 
		if(tos==stck.length - 1) 
			System.out.println("Stack is full,please attention stackflow"); 
		else 
			stck[++tos] = item; 
	} 
// Pop an item from the stack 
int pop() { 
	if(tos < 0) { 
		System.out.println("Stack underflow."); 
		return 0; 
	} 
	else 
		return stck[tos--]; 
	}

调用代码为：

public static void main(String args[]) { 
		Stack mystack1 = new Stack(); 
		Stack mystack2 = new Stack(); 
		// push some numbers onto the stack 
		for(int i=0; i<10; i++) mystack1.push(i); 
		for(int i=10; i<23; i++) mystack2.push(i); 
		// pop those numbers off the stack 
		System.out.println("Stack in mystack1:"); 
		for(int i=0; i<10; i++) 
		System.out.println(mystack1.pop()); 
		System.out.println("Stack in mystack2:"); 
		for(int i=0; i<10; i++) 
		System.out.println(mystack2.pop()); 
		}

Number three : 递归习惯问题：之前习惯用的递归代码顺序是先写处理代码，后递归调用。不过要适应用先递归调用，而后再是写处理代码

情况一：先递归调用，而后再是写处理代码:

class RecTest { 
int values[]; 
RecTest(int i) { 
values = new int[i]; 
} 
// display array – recursively 
void printArray(int i) { 
if(i==0) return; 
else printArray(i-1);   //先递归调用，而后再是写处理代码
System.out.println("[" + (i-1) + "] " + values[i-1]); 
} 
} 
class Recursion2 { 
public static void main(String args[]) { 
RecTest ob = new RecTest(10); 
int i; 
for(i=0; i<10; i++) ob.values[i] = i; 
ob.printArray(10); 
} 
}

情况二：先写处理代码，后递归调用

例子是之前写过的层次遍历二叉树：

template <class Elem>
 2 void level(BinNode<Elem>* subroot) 
 3 {
 4      AQueue<BinNode<Elem>*> Q;
 5      Q.enqueue(subroot);
 6      while(!Q.isEmpty())
 7       {
 8      BinNode<Elem>* temp;
 9           Q.dequeue(temp);  //返回temp指针是Q队列的表头的二叉树中的结点，而temp指针的结点已经被dequeue（出列）
10           if(temp != NULL) 
11             {
12               Print(temp);
13               if(temp->left!=NULL)    Q.enqueue(temp->left());
14               if(temp->right!=NULL)   Q.enqueue(temp->right());
15              }
16        }
17 }