数据结构(JAVA)

01-数据结构—判断题

02-数据结构—选择题

03 数据结构—多选+填空+程序填空

01-顺序表的建立及遍历

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Scanner;public class Main {public static void main(String[] args) {// TODO Auto-generated method stub
//		输出n个整数，以空格分隔（最后一个数的后面没有空格）Scanner sc = new Scanner(System.in);int num = sc.nextInt();int[] arr = new int[num];// 创建一个空的链表LinkedList<Integer> numbers = new LinkedList<>();for (int i = 0; i < num; i++) {numbers.add(sc.nextInt());}ListIterator<Integer> iterator = numbers.listIterator();boolean isFirst = true;while (iterator.hasNext()) {//不是第一个元素就打印空格if (!isFirst) {System.out.print(" ");} else {isFirst = false;}System.out.print(iterator.next());}}
}

02-递增有序顺序表的插入

import java.util.Scanner;public class Main {public static void main(String[] args) {// TODO Auto-generated method stub
//		第1行输入顺序表长度，第2行输入递增有序的顺序表，第3行输入要插入的数据元素X。
//		对每一组输入，在一行中输出插入X后的递增的顺序表。Scanner sc = new Scanner(System.in);int length = sc.nextInt();int arr[] = new int[length+1];for (int i = 0; i < length; i++) {arr[i] = sc.nextInt();}int num = sc.nextInt();arr[length] = num;int j = 0;for (int i = length; i > 0; i--) {if (arr[i]<arr[i-1]) {j=arr[i];arr[i] = arr[i-1];arr[i-1]=j;}}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+",");}}}

03-顺序表的插入

import java.util.Scanner;public class Main {// MAXSIZE为最大数据元素数目private static final int MAXSIZE = 10;// 定义顺序表结构static class SqList {ElemType[] elem;int length;// 构造函数初始化@SuppressWarnings("unchecked")public SqList(int size) {elem = new ElemType[size];length = 0;}}// 定义元素类型static class ElemType {int value;public ElemType(int value) {this.value = value;}}// 创建顺序表public static SqList createList(int n, int[] values) {SqList list = new SqList(MAXSIZE);for (int i = 0; i < n; i++) {list.elem[i] = new ElemType(values[i]);}list.length = n;return list;}// 插入元素public static String insertElem(SqList list, int position, int value) {if (list.length == MAXSIZE) {return "OVERFLOW!";}if (position < 1 || position > list.length + 1) {return "Insert position error!";}for (int i = list.length; i >= position; i--) {list.elem[i] = list.elem[i - 1];}list.elem[position - 1] = new ElemType(value);list.length++;return null;}// 打印顺序表public static String printList(SqList list) {StringBuilder sb = new StringBuilder();sb.append("(");for (int i = 0; i < list.length; i++) {sb.append(list.elem[i].value);if (i < list.length - 1) {sb.append(",");}}sb.append(")");return sb.toString();}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 读取输入int n = scanner.nextInt();int[] values = new int[n];for (int i = 0; i < n; i++) {values[i] = scanner.nextInt();}int position = scanner.nextInt();int value = scanner.nextInt();// 创建顺序表SqList list = createList(n, values);// 打印插入前的顺序表System.out.println("Before:" + printList(list));// 插入元素并打印插入后的顺序表或错误信息String result = insertElem(list, position, value);if (result == null) {System.out.println("After:" + printList(list));} else {System.out.println(result);}}
}

04-数据结构实验一顺序表的删除

import java.util.Scanner;public class Main {// MAXSIZE为最大数据元素数目private static final int MAXSIZE = 10;// 定义顺序表结构static class SqList {ElemType[] elem;int length;// 构造函数初始化@SuppressWarnings("unchecked")public SqList(int size) {elem = new ElemType[size];length = 0;}}// 定义元素类型static class ElemType {int value;public ElemType(int value) {this.value = value;}}// 创建顺序表public static SqList createList(int n, int[] values) {SqList list = new SqList(MAXSIZE);for (int i = 0; i < n; i++) {list.elem[i] = new ElemType(values[i]);}list.length = n;return list;}// 删除元素public static String deleteElem(SqList list, int position) {if (position < 1 || position > list.length) {return "Delete position error!";}for (int i = position - 1; i < list.length - 1; i++) {list.elem[i] = list.elem[i + 1];}list.elem[list.length - 1] = null;  // 清除最后一个元素list.length--;return null;}// 打印顺序表public static String printList(SqList list) {StringBuilder sb = new StringBuilder();sb.append("(");for (int i = 0; i < list.length; i++) {sb.append(list.elem[i].value);if (i < list.length - 1) {sb.append(",");}}sb.append(")");return sb.toString();}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 读取输入int n = scanner.nextInt();int[] values = new int[n];for (int i = 0; i < n; i++) {values[i] = scanner.nextInt();}int position = scanner.nextInt();// 创建顺序表SqList list = createList(n, values);// 打印删除前的顺序表System.out.println("Before:" + printList(list));// 删除元素并打印删除后的顺序表或错误信息String result = deleteElem(list, position);if (result == null) {System.out.println("After:" + printList(list));} else {System.out.println(result);}}
}

05-哈夫曼树

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;public class Main {public static void main(String[] args) {// TODO Auto-generated method stubScanner sc = new Scanner(System.in);//		读取叶子结点的个数int n = sc.nextInt();//		读取每个叶子结点的权值int[] weights = new int[n];for (int i = 0; i < n; i++) {weights[i] = sc.nextInt();}sc.close();//构造哈夫曼树HuffmanTree tree = buildHuffmanTree(weights);//获取哈夫曼树的带权路径长度int wpl = tree.getWPL();//输出带权路径长度System.out.println(wpl);}//构建哈夫曼树private static HuffmanTree buildHuffmanTree(int[] weights) { //使用优先队列存储节点，按照权值从小到大排序PriorityQueue<HuffmanTree.Node> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(node -> node.weight));//将每个叶子结点添加到优先队列中for (int weight : weights) {priorityQueue.offer(new HuffmanTree.Node(weight));}//不断地从优先队列中取出权值最小的两个结点，合并成一个新的父节点，直到只剩一个节点为止while (priorityQueue.size() > 1) {HuffmanTree.Node left = priorityQueue.poll();HuffmanTree.Node right = priorityQueue.poll();HuffmanTree.Node parent = new HuffmanTree.Node(left.weight + right.weight);parent.left = left;parent.right = right;priorityQueue.offer(parent);}return new HuffmanTree(priorityQueue.poll());}static class HuffmanTree{private Node root;//构造函数，根据根节点创建哈夫曼树public HuffmanTree(Node root) {this.root = root;}//获取哈夫曼树的带权路径长度public int getWPL() {return calculateWPL(root,0);}//递归计算哈夫曼树的带权路径长度private int calculateWPL(Node node, int depth) {if (node == null) {return 0;}//如果是叶子节点，返回权值乘以深度if (node.left == null && node.right == null) {return node.weight * depth;}//非叶子结点，继续递归计算左右子树的带权路径长度return calculateWPL(node.left, depth+1)+calculateWPL(node.right, depth+1);}//结点类static class Node{int weight; //权值Node left; // 左孩子Node right; //右孩子//构造函数，创建具有指定权值的叶子结点public Node(int weight) {this.weight = weight;}}}
}

06-还原二叉树

import java.util.Scanner;public class Main {// 定义二叉树节点static class TreeNode {char val;TreeNode left;TreeNode right;TreeNode(char x) {val = x;}}// 根据前序和中序遍历序列构建二叉树public static TreeNode buildTree(char[] preorder, char[] inorder) {return buildTreeHelper(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);}private static TreeNode buildTreeHelper(char[] preorder, int preStart, int preEnd, char[] inorder, int inStart, int inEnd) {if (preStart > preEnd || inStart > inEnd) {return null;}char rootVal = preorder[preStart];TreeNode root = new TreeNode(rootVal);int rootIndex = 0;for (int i = inStart; i <= inEnd; i++) {if (inorder[i] == rootVal) {rootIndex = i;break;}}int leftTreeSize = rootIndex - inStart;root.left = buildTreeHelper(preorder, preStart + 1, preStart + leftTreeSize, inorder, inStart, rootIndex - 1);root.right = buildTreeHelper(preorder, preStart + leftTreeSize + 1, preEnd, inorder, rootIndex + 1, inEnd);return root;}// 计算二叉树的高度public static int treeHeight(TreeNode root) {if (root == null) {return 0;}int leftHeight = treeHeight(root.left);int rightHeight = treeHeight(root.right);return Math.max(leftHeight, rightHeight) + 1;}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);// 读取输入int n = scanner.nextInt();String preorderStr = scanner.next();String inorderStr = scanner.next();char[] preorder = preorderStr.toCharArray();char[] inorder = inorderStr.toCharArray();// 构建二叉树TreeNode root = buildTree(preorder, inorder);// 计算二叉树的高度int height = treeHeight(root);// 输出结果System.out.println(height);}
}

07-玩转二叉树

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;public class Main {static int n;static int[]id;static int[]pr;static Queue<node>q=new LinkedList<node>();public static node build(int prl,int prr,int il,int ir) {if(il>ir) return null;node root=new node();int v=pr[prl];root.v=v;int i;for(i=il;i<=ir;i++)if(id[i]==v)break;int num=i-il;//镜面反转，是指将所有非叶结点的左右孩子对换//把比根节点大的建在根节点的左边，比根节点小的建在根节点的右边root.le=build(prl+num+1,prr,i+1,ir);root.ri=build(prl+1,prl+num,il,i-1);return root;}public static void print() {int t=1;while(!q.isEmpty()) {node r=q.poll();if(t==n)System.out.println(r.v);else {System.out.print(r.v+" ");t++;}if(r.le!=null)q.add(r.le);if(r.ri!=null)q.add(r.ri);}}public static void main(String[] args) {Scanner in=new Scanner(System.in);n=in.nextInt();id=new int[n+1];pr=new int[n+1];for(int i=1;i<=n;i++)id[i]=in.nextInt();for(int i=1;i<=n;i++)pr[i]=in.nextInt();node root=build(1,n,1,n);q.add(root);print();}}
class node{int v;node le;node ri;}

08-完全二叉搜索树

import java.io.*;
import java.util.Arrays;public class Main {static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));public static int ini() throws IOException {st.nextToken();return (int)st.nval;}static int n, idx;static int []tree;static int []arr;public static void main(String[] args) throws NumberFormatException, IOException {n = ini();arr = new int[n];tree = new int[n + 1];for(int i = 0; i < n; i++) arr[i] = ini();Arrays.sort(arr);build(1);System.out.print(tree[1]);for(int i = 2; i <= n; i++) System.out.print(" " + tree[i]);}public static void build(int root) {if(root * 2 <= n) build(root * 2);tree[root] = arr[idx++];if(root *2 + 1 <= n) build(root * 2 + 1);}
}

09-是否完全二叉搜索树

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;public class Main {public static void main(String[] args) throws IOException {Reader.init(System.in);N = Reader.nextInt();int[] tree = new int[4194303];/** fa = (child - 1) / 2 left_child = (fa + 1) * 2 - 1 right_child = (fa + 1) * 2*/for (int i = 0; i < N; i++) {int node = Reader.nextInt();insert(tree, node);}show(tree);if(isOK) {System.out.println("YES");}else {System.out.println("NO");}}static int N;static boolean isOK = true;static void insert(int[] tree, int node) {int current = 0;while (tree[current] != 0) {if (node < tree[current]) {current = (current + 1) * 2;} else {current = (current + 1) * 2 - 1;}}if (current >= N) {isOK = false;}tree[current] = node;}static void show(int[] tree) {int count = 0;for (int i = 0; i < tree.length; i++) {if(tree[i] != 0) {count++;if(count == N) {System.out.println(tree[i]);break;}System.out.print(tree[i] + " ");}}}}// Class for buffered reading int and double values *//*
class Reader {static BufferedReader reader;static StringTokenizer tokenizer;// ** call this method to initialize reader for InputStream *//*static void init(InputStream input) {reader = new BufferedReader(new InputStreamReader(input));tokenizer = new StringTokenizer("");}// ** get next word *//*static String next() throws IOException {while (!tokenizer.hasMoreTokens()) {// TODO add check for eof if necessarytokenizer = new StringTokenizer(reader.readLine());}return tokenizer.nextToken();}static String nextLine() throws IOException {return reader.readLine();}static int nextInt() throws IOException {return Integer.parseInt(next());}static char nextChar() throws IOException {return next().toCharArray()[0];}static float nextFloat() throws IOException {return Float.parseFloat(next());}
}

10-树的遍历

import java.util.*;public class Main {static int[] post = new int[35];static int[] in = new int[35];static int[] level = new int[10000];// 后序中的最后一个结点是根结点 root，在中序中从 start 到 end 移动 i 找到这个根结点的位置，// i 以左是左子树，以右是右子树static void pre(int start, int end, int root, int index) {if (start > end)return; // 当一个结点就是一个树时，start==end；将这个最底层的叶子结点存入 level 后就应该结束递归了。int i = start;while (i < end && in[i] != post[root])i++;level[index] = post[root];pre(start, i - 1, root - (end - i) - 1, index * 2 + 1);pre(i + 1, end, root - 1, index * 2 + 2);}public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();for (int i = 0; i < n; i++) {post[i] = scanner.nextInt();}for (int i = 0; i < n; i++) {in[i] = scanner.nextInt();}pre(0, n - 1, n - 1, 0);int cnt = 0;for (int i = 0; i < 10000; i++) {if (level[i] != 0 && cnt < n - 1) {System.out.print(level[i] + " ");cnt++;} else if (level[i] != 0) {System.out.print(level[i]);break;}}scanner.close();}
}

11-根据后序和中序遍历输出前序遍历

import java.util.*;class TreeNode{int val;TreeNode left;TreeNode right;TreeNode(int x){val = x;}
}
public class Main {//根据后序和中序遍历结果构造二叉树public static TreeNode builTree(int[] inorder,int[] postorder,int inStart,int inEnd,int postStart,int postEnd,Map<Integer, Integer> inorderMap) {
//		边界条件：如果子区间的下标越界，说明已经到达叶子节点或者不存在合法的子树，返回nullif (inStart>inEnd || postStart>postEnd) {return null;}
//		后序遍历最后一个元素是当前子树的根节点int rootval = postorder[postEnd];TreeNode root = new TreeNode(rootval);//		在中序遍历数组中找到当前子树根节点的位置int rootIndex = inorderMap.get(rootval);//		递归构建左右子树root.left = builTree(inorder, postorder, inStart, rootIndex-1, postStart, postStart+rootIndex-inStart-1, inorderMap);root.right = builTree(inorder, postorder, rootIndex+1, inEnd, postStart+rootIndex-inStart, postEnd-1, inorderMap);return root;}//前序遍历二叉树public static void preorder(TreeNode root,StringBuilder sbu) {if (root == null) {return;}sbu.append(root.val).append(" ");preorder(root.left, sbu);preorder(root.right, sbu);}public static void main(String[] args) {// TODO Auto-generated method stubScanner sc = new Scanner(System.in);int num = sc.nextInt();int[] postorder = new int[num];int[] inorder = new int[num];//		后序遍历for (int i = 0; i < num; ++i) {postorder[i] = sc.nextInt();}
//		中序遍历for (int i = 0; i < num; ++i) {inorder[i] = sc.nextInt();}Map<Integer, Integer> inorderMap = new HashMap<>();for (int i = 0; i < num; i++) {inorderMap.put(inorder[i],i);}TreeNode root = builTree(inorder, postorder, 0, num-1, 0, num-1, inorderMap);StringBuilder sbu = new StringBuilder();preorder(root, sbu);System.out.println("Preorder: "+sbu.toString().trim());}}

12-栈操作的合法性

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int m = scanner.nextInt();scanner.nextLine(); // 读取换行符for (int i = 0; i < n; i++) {String sequence = scanner.nextLine();if (isValidSequence(sequence, m)) {System.out.println("YES");} else {System.out.println("NO");}}}private static boolean isValidSequence(String sequence, int maxCapacity) {int stackSize = 0;for (char operation : sequence.toCharArray()) {if (operation == 'S') {stackSize++;if (stackSize > maxCapacity) {return false;}} else if (operation == 'X') {stackSize--;if (stackSize < 0) {return false;}}}return stackSize == 0;}
}

13-出栈序列的合法性

import java.util.Scanner;
import java.util.Stack;public class Main {private static boolean isValidSequence(int[] sequence, int m, int n) {Stack<Integer> stack = new Stack<>();int nextToPush = 1;for (int i = 0; i < sequence.length; i++) {int num = sequence[i];// 确保所有小于等于当前num的自然数都已经入栈while (nextToPush <= num) {if (stack.size() == m) return false; // 检查是否栈溢出stack.push(nextToPush++);}if (stack.peek() != num) return false; // 检查是否提前出栈stack.pop();}return true;}public static void main(String[] args) {Scanner sc = new Scanner(System.in);int m = sc.nextInt();  // 栈容量int n = sc.nextInt();  // 元素个数int k = sc.nextInt();  // 测试序列数String[] results = new String[k]; // 存储每个出栈序列的有效性结果for (int i = 0; i < k; i++) {int[] sequence = new int[n];for (int j = 0; j < n; j++) {sequence[j] = sc.nextInt(); // 读取每一个出栈序列}//            判断当前出栈序列是否有效，并将结果存入results数组if (isValidSequence(sequence, m, n)) {results[i] = "YES";} else {results[i] = "NO";}}for (int i = 0; i < results.length; i++) {String result = results[i];System.out.println(result);}}}

14-完全二叉树的层序遍历

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;/*给定一棵完全二叉树的后序遍历，给出这棵树的层序遍历结果。
输入在第一行中给出正整数 N（≤30），即树中结点个数。
第二行给出后序遍历序列，为 N 个不超过 100 的正整数。同一行中所有数字都以空格分隔。*/public class Main {
//	定义全局变量static int num; //树的节点数量
//	定义一个静态数组 tree 存储完全二叉树的节点值，数组大小为 31 以适应最多 30 个节点的需求static int[] BinaryTree = new int[31];
//	定义一个静态数组 arr，用于存放输入的节点值static int[] data = new int[31];
//	定义一个静态队列 queue，存储树节点对应的下标，初始时添加所有可能的节点下标static Queue<Integer> queue = new LinkedList<Integer>();//	创建完全二叉树的递归private static void createComplete(int i) {
//		节点下标大于总节点数时，结束递归if (i > num) {return;}createComplete(2*i); // 如果有左孩子，则编号为2i，createComplete(2*i+1); // 如果有右孩子，编号为2i+1，//然后按照后序遍历的方式（左右根），进行输入，最后顺序输出即可。BinaryTree[i] = data[queue.remove()];}		public static void main(String[] args) {// TODO Auto-generated method stubScanner sc = new Scanner(System.in);num = sc.nextInt();//		初始化 queue，向其中添加从 1 到 30 的整数作为节点下标for (int i = 1; i < 31; i++) {queue.add(i);}for (int i = 0; i < num; i++) {data[i+1] = sc.nextInt();}//		照层序遍历的方式生成完全二叉树createComplete(1);//		输出完全二叉树层序遍历的结果for (int i = 1; i <= num; i++) {
//			输出第一个节点时不加空格，其余节点前面加上空格if (i == 1) {System.out.print(BinaryTree[i]);} else {System.out.print(" "+BinaryTree[i]);}}}
}