约瑟夫环与二叉树问题java

1. 约瑟夫环数组实现

importjava.util.Scanner;

 

/**

 *使用数组实现约瑟夫环问题 由m个人围成一个首尾相连的圈报数。 从第一个人开始，从1开始报数，报到n的人出圈，

 *剩下的人继续从1开始报数，直到所有的人都出圈为止。 对于给定的m和n，求出所有人的出圈顺序.

 */

publicclass RingTest {

publicstatic void main(String[] args) {

System.out.println("程序说明如下：");

System.out.println("由m个人围成一个首尾相连的圈报数。从第一个人开始，从1开始报数，报到n的人出圈，剩下的人继续从1开始报数，直到所有的人都出圈为止。对于给定的m和n，求出所有人的出圈顺序.");

 

// 提示输入总人数

System.out.println("请输入做这个游戏的总人数：");

Scannersca = new Scanner(System.in);

intm = sca.nextInt();

// 提示输入要出圈的数值

System.out.println("请输入要出圈的数值：");

intn = sca.nextInt();

System.out.println("按出圈的次序输出序号：");

// 创建有m个值的数组

int[]a = new int[m];

// 初始长度，以后出圈一个，长度就减一

intlen = m;

// 给数组赋值

for(int i = 0; i < a.length; i++)

a[i]= i + 1;

// i为元素下标，j代表当前要报的数

inti = 0;

intj = 1;

while(len > 0) {

if(a[i % m] > 0) {

if (j % n == 0) {// 找到要出圈的人，并把圈中人数减一

System.out.print(a[i% m] + "  ");

a[i% m] = -1;

j= 1;

i++;

len--;

}else {

i++;

j++;

}

} else {// 遇到空位了，就跳到下一位，但j不加一，也就是这个位置没有报数

i++;

}

}

}

}

 

2. 二叉树遍历递归与非递归

publicclass BinaryTree {

 

int data; // 根节点数据

BinaryTree left; // 左子树

BinaryTree right; // 右子树

 

public BinaryTree(int data) // 实例化二叉树类

{

this.data= data;

left= null;

right= null;

}

 

public void insert(BinaryTree root, int data) { // 向二叉树中插入子节点

if (data > root.data) // 二叉树的左节点都比根节点小

{

if(root.right == null) {

root.right= new BinaryTree(data);

}else {

this.insert(root.right,data);

}

} else { // 二叉树的右节点都比根节点大

if(root.left == null) {

root.left= new BinaryTree(data);

}else {

this.insert(root.left,data);

}

}

}

 

}

 

importjava.util.Stack;

 

publicclass BinaryTreePreorder {

 

public static void preOrder(BinaryTree root) { // 先根遍历

if(root != null) {

System.out.print(root.data+ "-");

preOrder(root.left);

preOrder(root.right);

}

}

 

public static void inOrder(BinaryTree root) { // 中根遍历

 

if(root != null) {

inOrder(root.left);

System.out.print(root.data+ "--");

inOrder(root.right);

}

}

 

public static void postOrder(BinaryTree root) { // 后根遍历

 

if(root != null) {

postOrder(root.left);

postOrder(root.right);

System.out.print(root.data+ "---");

}

}

 

// 先序遍历非递归     

    public static void preOrder2(BinaryTreeroot) {   

        Stack<BinaryTree> s = newStack<BinaryTree>();   

        while (root != null || !s.empty()){   

            while (root != null) {   

                System.out.print(root.data +"-");   

                s.push(root);   

                root = root.left;   

            }   

            if (!s.empty()) {   

                   root = s.pop();   

                   root = root.right;   

            }   

        }   

    }

   

 // 中序遍历非递归     

    public static void inOrder2(BinaryTree t){   

        Stack<BinaryTree> s = newStack<BinaryTree>();   

        while (t != null || !s.empty()) {   

            while (t != null) {   

                s.push(t);   

                t = t.left;   

            }   

            if (!s.empty()) {   

                t = s.pop();   

                System.out.print(t.data +"-");   

                t = t.right;   

            }   

        }   

    }   

   

   // 后序遍历非递归     

    public static void postOrder2(BinaryTree t){   

        Stack<BinaryTree> s = newStack<BinaryTree>();   

        Stack<Integer> s2 = newStack<Integer>();   

        Integer i = new Integer(1);   

        while (t != null || !s.empty()) {   

            while (t != null) {   

                s.push(t);   

                s2.push(new Integer(0));   

                t = t.left;   

            }   

            while (!s.empty() &&s2.peek().equals(i)) {   

                s2.pop();   

                System.out.print(s.pop().data +"-");   

            }   

   

            if (!s.empty()) {   

                s2.pop();   

                s2.push(new Integer(1));   

                t = s.peek();   

                t = t.right;   

            }   

        }   

    }  

 

publicstatic void main(String[] str) {

int[]array = { 12, 76, 35, 22, 16, 48, 90, 46, 9, 40 };

BinaryTree root = new BinaryTree(array[0]); // 创建二叉树

for(int i = 1; i < array.length; i++) {

root.insert(root, array[i]); // 向二叉树中插入数据

}

System.out.println("先根遍历：");

preOrder(root);

System.out.println();

System.out.println("中根遍历：");

inOrder(root);

System.out.println();

System.out.println("后根遍历：");

postOrder(root);

System.out.println();

System.out.println("先根遍历(非递归)：");

preOrder2(root);

System.out.println();

System.out.println("中根遍历(非递归)：");

inOrder2(root);

System.out.println();

System.out.println("后根遍历(非递归)：");

postOrder2(root);

}

 

}