【算法设计与分析】实验一常见数据结构概念和操作（附源代码）

一、上机目的

1、熟悉Java开发环境；
2、掌握栈和队列的定义及操作
3、掌握二叉树定义、常用的操遍历方法

二、上机内容与要求

1、掌握练习栈的定义和操作，并进行应用
2、掌握练习队列的定义和操作，并进行应用
3、掌握树的结构定义和遍历方法。

三、上机步骤

1、理解算法思想和问题要求；
2、编程实现题目要求；
3、上机输入和调试自己所编的程序；
4、验证分析实验结果；
5、整理出实验报告；

四、上机内容

1、利用栈实现数制转换（将一个十进制数转换成d进制
数）

import java.util.Scanner;
import java.util.Stack;
public class DecimalToBaseD {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("需要转换的十进制数:");
        int decimalNumber = scanner.nextInt(); // 需要转换的十进制数
        System.out.println("转换成的数制:");
        int base = scanner.nextInt(); // 转换成的数制，例如二进制
        System.out.println("需要转换的十进制数: " + decimalNumber);
        System.out.println("转换成的数制: " + base);

        String convertedNumber = convertDecimalToBase(decimalNumber, base);
        System.out.println("转换以后的数据为: " + convertedNumber);
    }

    public static String convertDecimalToBase(int decimal, int base) {
        Stack<Integer> stack = new Stack<>();

        while (decimal > 0) {
            int remainder = decimal % base;
            stack.push(remainder);
            decimal /= base;
        }

        StringBuilder result = new StringBuilder();
        while (!stack.isEmpty()) {
            result.append(stack.pop());
        }

        return result.reverse().toString(); // 如果进制为非负整数，我们可以反转结果并转换为字符串返回
    }
}

2、模拟顾客餐厅前等候就餐排队。
（1）取号时，打印当前排队号码，且给出当前等待的人数。
（2）叫号时，打印当前办理业务的排队号码。
提示：使用队列实现该功能。取号即为入队操作，叫号即为出队操作。

//导入工具包

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;

/*
1.可以通过录入的方式添加顾客（添加以后显示当前排队人数)
2.顾客取餐 同时显示当前排队人数
3.顾客就餐 排队人数减少 同时就餐人数增加
4.打印就餐人数以及就餐的桌号
 */


public class RestaurantQueueSimulation {
    public static void main(String[] args) {
        Queue<Integer> waitingQueue = new LinkedList<>();
        // 新建一个列表接收出队的数据
        List<Integer> eatingList = new LinkedList<>();
        int customerNumber = 1;

        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("请选择操作：");
            System.out.println("1-取号 2-叫号 3-查看排队人数 4-查看就餐人数 5-结账 6-退出");

            int choice = scanner.nextInt();
            switch (choice) {
                case 1:
                    waitingQueue.offer(customerNumber);
                    System.out.println("您的号码为" + customerNumber + "\n" + "当前排队人数为：" + waitingQueue.size());
                    customerNumber++;
                    break;
                case 2:
                    if (!waitingQueue.isEmpty()) {
                        int customer = waitingQueue.poll();
                        System.out.println("请" + customer + "号顾客取餐");
                        System.out.println(customer + "号顾客取餐中");
                        System.out.println(customer + "号顾客取餐完毕");
                        System.out.println(customer + "号顾客就餐中...\n");
                        eatingList.add(customer);
                    } else {
                        System.out.println("当前没有顾客在排队");
                    }
                    break;
                case 3:
                    System.out.println("当前排队人数：" + waitingQueue.size());
                    break;
                case 4:
                    if (!eatingList.isEmpty()) {
                        System.out.println("当前就餐人数：" + eatingList.size());
                        if (eatingList.size() > 0) {
                            // 输出新集合中的所有数据
                            for (int data : eatingList) {
                                System.out.println(data + "号顾客正在就餐！");
                            }
                        }
                    } else {
                        System.out.println("当前没有顾客在就餐！");
                    }
                    break;
                case 5:
                    System.out.println("选择结账桌号:");
                    int removednum = scanner.nextInt();
                    // 使用remove()方法删除特定元素
                    boolean removed = eatingList.remove(Integer.valueOf(removednum));

                    if (removed) {
                        System.out.println(removednum + "号顾客已成功结账。");
                    } else {
                        System.out.println("未找到" + removednum + "顾客数据。");
                    }
                    break;
                case 6:
                    System.out.println("感谢使用！");
                    System.exit(1);
                default:
                    System.out.println("无效操作");
            }
        }
    }
}

3、构造如图的一个二叉树，并先序、中序、后序进行遍历并输出结果。

import java.util.LinkedList;
import java.util.Queue;


class TreeNode {
    char val;
    TreeNode left;
    TreeNode right;

    public TreeNode(char val) {
        this.val = val;
    }
}

public class BinaryTree {
    public static void main(String[] args) {
        TreeNode root = new TreeNode('a');
        root.left = new TreeNode('b');
        root.right = new TreeNode('c');
        root.left.left = new TreeNode('d');
        root.right.left = new TreeNode('e');
        root.right.right = new TreeNode('f');
        root.left.left.left = new TreeNode('x');
        root.left.left.right = new TreeNode('y');
        System.out.println("原始二叉树结构为：");
        printTreeByLevel(root);
        System.out.println("");
        System.out.println("前序遍历的结果为：");
        preorderTraversal(root);
        System.out.println("");//等价与换行
        System.out.println("中序遍历的结果为：");
        minorderTraversal(root);
        System.out.println("");//等价与换行
        System.out.println("后序遍历的结果为：");
        inorderTraversal(root);
    }

    //前序遍历
    public static void preorderTraversal(TreeNode root) {
        if (root != null) {
            System.out.print(root.val + " ");
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
    }

    //中序遍历
    public static void minorderTraversal(TreeNode root) {
        if (root != null) {
            minorderTraversal(root.left);
            System.out.print(root.val + " ");
            minorderTraversal(root.right);
        }
    }

    //后序遍历
    public static void inorderTraversal(TreeNode root) {
        if (root != null) {
            inorderTraversal(root.right);
            inorderTraversal(root.left);
            System.out.print(root.val + " ");
        }
    }

    //显示二叉树
    public static void printTreeByLevel(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll();
                System.out.print(node.val + "  ");

                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            System.out.println();
        }
    }
}