数据结构课程实践(1)

Objects.equals(next, that.next);

}

@Override

public int hashCode() {

return Objects.hash(name, score, StudentNo, age, sex, next);

}

@Override

public String toString() {

return “学生学号: " + this.getStudentNo() +” 学生姓名: " + this.getName()+ " 性别 "+ getSex()+ " 本次成绩: " + getScore();

}

}

package com.课程实践;

import javax.net.ssl.SNIHostName;

import java.util.InputMismatchException;

import java.util.Scanner;

public class StudentList {

StudentNode head;

int N;

public StudentList() {

this.head = null;

N = 0;

}

// 按着成绩插入

public void addStudent(String name,Integer score ,int studentNo,int age,char sex){

StudentNode student = new StudentNode(name,studentNo,age,sex,score,null);

if (head == null){

head = student;

this.N++;

System.out.println(“添加成功”);

return;

}

if (score.compareTo(head.getScore()) > 0) {

student.setNext(head);

head = student;

this.N++;

System.out.println(“添加成功”);

return;

}

StudentNode node = head.getNext();

StudentNode preNode = head;

if (node == null){

head.setNext(student);

this.N++;

System.out.println(“添加成功”);

return;

}

while(node != null){

if (score.compareTo(node.getScore()) > 0){

preNode.setNext(student);

student.setNext(node);

this.N++;

System.out.println(“添加成功”);

return;

}else{

node = node.getNext();

preNode = preNode.getNext();

}

}

preNode.setNext(student);

this.N++;

System.out.println(“添加成功”);

return;

}

public void addStudent(StudentNode student){

if (head == null){

head = student;

this.N++;

System.out.println(“添加成功”);

return;

}

if (student.getScore().compareTo(head.getScore()) > 0) {

student.setNext(head);

head = student;

this.N++;

System.out.println(“添加成功”);

return;

}

StudentNode node = head.getNext();

StudentNode preNode = head;

if (node == null){

head.setNext(student);

this.N++;

System.out.println(“添加成功”);

return;

}

while(node != null){

if (student.getScore().compareTo(node.getScore()) > 0){

preNode.setNext(student);

student.setNext(node);

this.N++;

System.out.println(“添加成功”);

return;

}else{

node = node.getNext();

preNode = preNode.getNext();

}

}

preNode.setNext(student);

this.N++;

System.out.println(“添加成功”);

return;

}

// 学生信息删除

public void deleteStudent(Integer studentNo){

StudentNode node = head.getNext();

StudentNode preNode = head;

if (studentNo.equals(preNode.getStudentNo())) {

head = head.getNext();

this.N --;

System.out.println(“删除成功”);

System.out.println("删除后学生个数 ");

return;

}

while(node != null){

if (studentNo.equals(node.getStudentNo())){

preNode.setNext(node.getNext());

System.out.println(“删除成功”);

this.N --;

System.out.println();

return;

}else{

node = node.getNext();

preNode = preNode.getNext();

}

}

System.out.println(“删除失败,无此学生”);

System.out.println("删除后学生个数 ");

}

public void modifyStudent(Integer studentNo,String newName){

StudentNode node = head;

while(node != null){

if (studentNo.equals(node.getStudentNo())){

node.setName(newName);

System.out.println(“修改姓名成功”);

System.out.println("删除后学生个数 ");

return;

}else{

node = node.getNext();

}

}

System.out.println(“修改失败,无此学生”);

System.out.println("删除后学生个数 ");

}

public void modifyStudent(Integer studentNo,int score) {

StudentNode node = head;

while (node != null) {

if (studentNo.equals(node.getStudentNo())) {

node.setScore(score);

deleteStudent(studentNo);

addStudent(node);

System.out.println(“修改成绩成功,并重新排名”);

System.out.println("删除后学生个数 ");

return;

} else {

node = node.getNext();

}

}

System.out.println(“修改失败,无此学生”);

System.out.println("删除后学生个数 ");

}

public void showAllStudents(){

StudentNode currentNode = head;

int count = 1;

while (currentNode != null){

System.out.print(currentNode);

System.out.println(" 本次排名 " + count);

count++;

currentNode = currentNode.getNext();

}

}

public void findStudent(Integer studentNo){

StudentNode currentNode = head;

int count = 1;

while(currentNode != null){

if (studentNo.equals(currentNode.getStudentNo())){

System.out.print(currentNode);

System.out.println(" 本次排名 " + count);

return;

}else{

currentNode = currentNode.getNext();

count++;

}

}

System.out.println(“查询失败,没有此学生”);

System.out.println("删除后学生个数 ");

}

public Integer getAns(){

Scanner scanner = new Scanner(System.in);

Integer ans;

try {

ans = scanner.nextInt();

}catch (InputMismatchException e){

System.out.println(“请正确输入您要选择的编号”);

ans = getAns();

}

return ans;

}

public Integer getTrueStudentNo(){

Scanner scanner = new Scanner(System.in);

Integer No;

try {

No = scanner.nextInt();

}catch (InputMismatchException e){

System.out.println(“请正确输入学号”);

No = getTrueStudentNo();

}

return No;

}

public Integer getTrueAge(){

Scanner scanner = new Scanner(System.in);

Integer age;

try {

age = scanner.nextInt();

}catch (InputMismatchException e){

System.out.println(“请正确输入年龄”);

age = getTrueAge();

}

return age;

}

public Integer getTrueScore(){

Scanner scanner = new Scanner(System.in);

Integer ans;

try {

ans = scanner.nextInt();

}catch (InputMismatchException e){

System.out.println(“请正确输入分数”);

ans = getTrueScore();

}

return ans;

}

public String getTrueName(){

Scanner scanner = new Scanner(System.in);

String name;

try {

name = scanner.next();

}catch (InputMismatchException e){

System.out.println(“请正确输入学号”);

name = getTrueName();

}

return name;

}

public char getTrueSex(){

Scanner scanner = new Scanner(System.in);

String sex;

try {

sex = scanner.next();

}catch (InputMismatchException e){

System.out.println(“请正确输入性别”);

sex = String.valueOf(getTrueSex());

}

return sex.charAt(0);

}

public char getWord(){

Scanner scanner = new Scanner(System.in);

String word;

try {

word = scanner.next();

}catch (InputMismatchException e){

System.out.println(“请输入Y/N”);

word = String.valueOf(getWord());

}

return word.charAt(0);

}

/**

• 一次性输入多个学生信息

*/

public void inputManyStudents(){

Integer studentNo,age,score;

char sex,continueWord;

String name;

while(true) {

System.out.println(“请输入 学生姓名”);

name = getTrueName();

System.out.println(“请输入 学生学号”);

studentNo = getTrueStudentNo();

System.out.println(“请输入 学生年龄”);

age = getTrueAge();

System.out.println(“请输入 学生性别”);

sex = getTrueSex();

System.out.println(“请输入 学生成绩”);

score = getTrueScore();

StudentNode student = new StudentNode(name, studentNo, age, sex, score, null);

addStudent(student);

System.out.println(“是否继续录入学生信息?(Y/N)”);

continueWord = getWord();

if (continueWord == ‘N’) {

System.out.println(“录入结束”);

break;

}

}

}

}

package com.课程实践;

import java.util.Scanner;

public class StudentManagementSystemMain {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String name;

Integer studentNo,age,score,ans = 0;

StudentList students = new StudentList();

StudentNode student;

char sex;

System.out.println(“=欢迎使用计算机1911学生信息管理系统=”);

while(true){

System.out.println(“请选择您要使用的功能:”);

System.out.println(“1.录入多个学生信息”);

System.out.println(“2.插入学生信息”);

System.out.println(“3.修改学生姓名”);

System.out.println(“4.修改学生成绩”);

System.out.println(“5.删除学生信息”);

System.out.println(“6.查看某个学生信息”);

System.out.println(“7.查看所有学生信息”);

System.out.println(“0.退出学生系统”);

System.out.println();

System.out.println();

ans = students.getAns();

switch(ans){

case 1:

students.inputManyStudents();

break;

case 2:

System.out.println(“请输入 学生姓名”);

name = students.getTrueName();

System.out.println(“请输入 学生学号”);

studentNo = students.getTrueStudentNo();

System.out.println(“请输入 学生年龄”);

age = students.getTrueAge();

System.out.println(“请输入 学生性别”);

sex = students.getTrueSex();

System.out.println(“请输入 学生成绩”);

score = students.getTrueScore();

student = new StudentNode(name,studentNo,age,sex,score,null);

students.addStudent(student);

break;

case 3:

System.out.println(“请输入要修改的学生的学号,以及修改后的姓名”);

System.out.println();

studentNo = students.getTrueStudentNo();

name = students.getTrueName();

students.modifyStudent(studentNo,name);

break;

case 4:

System.out.println(“请输入要修改的学生的学号,以及修改后的成绩”);

System.out.println();

studentNo = students.getTrueStudentNo();

score = students.getTrueScore();

students.modifyStudent(studentNo,score);

break;

case 5:

System.out.println(“请输入要删除的学生的学号”);

System.out.println();

studentNo = students.getTrueStudentNo();

students.deleteStudent(studentNo);

break;

case 6:

System.out.println(“请输入要查看信息的学生的学号”);

System.out.println();

studentNo = students.getTrueStudentNo();

students.findStudent(studentNo);

break;

case 7:

System.out.println(“接下来是所有学生的信息(以成绩降序排列)”);

System.out.println();

students.showAllStudents();

break;

case 0:

System.out.println(“欢迎下次使用本系统”);

System.out.println(“再见”);

return;

}

}

}

}

5

（1）、建立二叉树实现中序遍历

(含递归和非递归算法实现)。要求：二叉树中结点的值存放于一个一维数组T[n]中，T[0]开始顺序读出各结点的值，建立该二叉树的二叉链表表示。 或能够从键盘上输入树的各个结点值，建立二叉树的二叉链表存储表示，输出中序遍历结果。（难度系数为2）

public class Tree {

private class Node{

Integer data;

Integer left;

Integer right;

public Node(Integer data) {

this.data = data;

this.left = -1;

this.right = -1;

}

}

Node[] nodes;

int length;

int root;

public Tree() {

this.nodes = new Node[100];

this.length = 0;

this.root = -1;

}

public void insert(int t){

root = insert(root,t);

}

private int insert(int k,int t){

if (k == -1){

k = length;

nodes[k] = new Node(t);

length++;

return k;

}else{

if (t <= nodes[k].data){

nodes[k].left = insert(nodes[k].left,t);

}else{

nodes[k].right = insert(nodes[k].right,t);

}

}

return k;

}

/**

• 中序遍历(递归)

*/

public void midOrderRecursion(){

midOrderRecursion(root);

}

public void midOrderRecursion(int k){

if (k == -1) return;

midOrderRecursion(nodes[k].left);

System.out.println(nodes[k].data);

midOrderRecursion(nodes[k].right);

}

/**

• 中序遍历(非递归)

*/

public void midOrder(){

Stack stack = new Stack<>();

int p = root;

while(p != -1 || !stack.empty()){

while(p != -1){

stack.push§;

p = nodes[p].left;

}

if (!stack.empty()){

p = stack.pop();

System.out.println(nodes[p].data);

p = nodes[p].right;

}

}

}

public static void main(String[] args) {

Tree tree = new Tree();

System.out.println(“请输入节点个数”);

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

System.out.println(“请输入节点的值”);

for (int i = 0; i < n; i++) {

tree.insert(scanner.nextInt());

}

System.out.println(“中序遍历(递归):”);

tree.midOrderRecursion();

System.out.println(“中序遍历(非递归)”);

tree.midOrder();

}

}

（2）、快速排序。(3)

package com.课程实践.Fifth;

import java.util.Random;

public class QuickSort2 {

public static void main(String[] args) {

int[] array1 = randomArray(10);

int[] array2 = randomArray(10);

quickSort(array1);

System.out.println(“快速排序后:”);

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

System.out.print(array1[i] +" ");

}

BubbleSort(array2);

System.out.println();

System.out.println(“冒泡排序后”);

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

System.out.print(array2[i] +" ");

}

}

public static int[] randomArray(int maxn){

Random random = new Random();

int[] a = new int[maxn];

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

a[i] = random.nextInt(100);

}

return a;

}

public static void quickSort(int[] a){

int l = 0,r = a.length-1;

quickSort(l,r,a);

}

public static void quickSort(int l,int r,int[] a){

if (l >= r) return;

int mid = (l + r) / 2;

int i = l -1,j = r + 1;

while(i < j){

do{

i++;

}while(a[i] < a[mid]);

do{

j–;

}while(a[j] > a[mid]);

if (i < j) {

int temp = a[i];

a[i] = a[j];

a[j] = temp;

}

}

quickSort(l,j,a);

quickSort(j+1,r,a);

}

public static void BubbleSort(int[] a){

for(int i = a.length - 1;i > 0 ;i–){

for (int j = 0; j < i ; j++) {

if (a[j] > a[j+1]){

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

}

}

（3）、堆排序(3)

任务：编程实现线性表基础上的堆排序，并输出排序结果数据可通过随机函数随机生成。（难度系数为3）

package com.课程实践.Fifth;

public class Heap3 <T extends Comparable>{

private T[] items;

private int length;

public Heap3(int capacity) {

this.length = 0;

items = (T[])new Comparable[capacity + 1];

}

/**

• 比较两个节点的大小

• @param i

• @param j

• @return

*/

private boolean less(int i,int j){

return items[i].compareTo(items[j]) < 0;

}

private void swap(int i,int j){

T temp = items[i];

items[i] = items[j];

items[j] = temp;

}

public void insert(T t){

items[++length] = t;

swim(length);

}

// 上浮算法

private void swim(int k){

while( k > 1){

if (less(k/2,k)) swap(k,k/2);

k /= 2;

}

}

public T deleteMax(){

T max = items[1];

swap(1,length);

items[length] = null;

length–;

sink(1);

return max;

}

private void sink(int k){

while(k*2 <= length){

int max;

if(k*2+1 <= length){

if (less(k2,k2+1)) max = k*2+1;

else max = k*2;

}else{

max = k*2;

}

if (less(k,max)) swap(k,max);

else return;

}

}

}

package com.课程实践.Fifth;

import java.util.Arrays;

import java.util.Random;

public class HeapSort3 {

/**

• 对source数组中的数据从小到大排列

• @param source

*/

public static void sort(Comparable[] source) {

Comparable[] heap = new Comparable[source.length + 1];

createHeap(source, heap);

int N = heap.length - 1;

while (N != 1) {

wrap(heap, 1, N);

N–;

sink(heap, 1, N);

}

System.arraycopy(heap, 1, source, 0, source.length);

}

private static void createHeap(Comparable[] source, Comparable[] heap) {

System.arraycopy(source, 0, heap, 1, source.length);

// 对堆中元素做下沉处理

for (int i = (heap.length - 1) / 2; i > 0; i–) {

sink(heap, i, heap.length - 1);

}

}

/**

• 判断heap堆中索引i处的元素是否小于索引j处的元素

• @param heap

• @param i

• @param j

• @return

*/

private static boolean less(Comparable[] heap, int i, int j) {

return heap[i].compareTo(heap[j]) < 0;

}

/**

• 交换heap堆中i索引和j索引处的值

• @param heap

• @param i

• @param j

*/

private static void wrap(Comparable[] heap, int i, int j) {

Comparable temp = heap[i];

heap[i] = heap[j];

heap[j] = temp;

}

/**

• 在heap堆中,对target处元素做下沉,范围是0~range

• @param heap

• @param target

• @param range

*/

private static void sink(Comparable[] heap, int target, int range) {

while (2 * target <= range) {

int max;

if (2 * target + 1 <= range) {

if (less(heap, 2 * target, 2 * target + 1)) max = 2 * target + 1;

else max = 2 * target;

} else {

max = 2 * target;

}

if (less(heap, target, max)) wrap(heap, max, target);

target = max;

}

}

public static Integer[] randomArray(int N) {

Random random = new Random();

Integer[] array = new Integer[N];

for(int i = 0;i < N;i++){

array[i] = random.nextInt(100);

}

return array;

}

public static void main(String[] args) {

Integer[] array = randomArray(10);

sort(array);

System.out.println(Arrays.toString(array));

}

}

（4）、直接插入排序(2)

任务：编程序实现线性表基础上的排序，并输出排序结果。数据可通过随机函数随机生成，也可通过键盘直接输入。（难度系数为2）

package com.课程实践.Fifth;

import java.util.Arrays;

import java.util.Random;

import java.util.Scanner;

public class InsertionSort4 {

public static void sort(Comparable[] a){

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

for (int j = i; j > 0 ; j–) {

if (great(a,j-1,j)) wrap(a,j-1,j);

}

}

}

private static void wrap(Comparable[] a,int i,int j){

Comparable temp = a[i];

a[i] = a[j];

a[j] = temp;

}

private static boolean great(Comparable[] a,int i,int j){

return a[i].compareTo(a[j]) > 0;

}

public static void main(String[] args) {

System.out.println(“请选择排序数组”);

System.out.println(“1.自己输入”);

System.out.println(“2.随机数生成(十个数)”);

Scanner scanner = new Scanner(System.in);

int ans = scanner.nextInt();

Integer[] array = new Integer[10];

if (ans == 1){

System.out.println(“请输入十个数字”);

for (int i = 0; i < 10; i++) {

array[i] = scanner.nextInt();

}

}else{

Random random = new Random();

for (int i = 0; i < 10; i++) {

array[i] = random.nextInt(100);

}

}

sort(array);

System.out.println(Arrays.toString(array));

}

}

（5）、建立二叉树实现后序遍历(含递归和非递归算法实现)。

要求：二叉树中结点的值存放于一个一维数组T[n]中，T[0]开始顺序读出各结点的值，建立该二叉树的二叉链表表示。 或能够从键盘上输入树的各个结点值，建立二叉树的二叉链表存储表示，输出后序遍历结果。（难度系数为3）

package com.课程实践.Fifth;

import java.util.Scanner;

import java.util.Stack;

public class Tree {

private class Node{

Integer data;

Integer left;

Integer right;

public Node(Integer data) {

this.data = data;

this.left = -1;

this.right = -1;

}

}

Node[] nodes;

int length;

int root;

public Tree() {

this.nodes = new Node[100];

this.length = 0;

this.root = -1;

}

public void insert(int t){

root = insert(root,t);

}

private int insert(int k,int t){

if (k == -1){

k = length;

nodes[k] = new Node(t);

length++;

return k;

}else{

if (t <= nodes[k].data){

nodes[k].left = insert(nodes[k].left,t);

}else{

nodes[k].right = insert(nodes[k].right,t);

}

}

return k;

}

/**

• 后续遍历(递归)

*/

public void afterOrderRecursion(){

afterOrderRecursion(root);

}

public void afterOrderRecursion(int k){

if (k == -1) return;

afterOrderRecursion(nodes[k].left);

afterOrderRecursion(nodes[k].right);

System.out.println(nodes[k].data);

}

public static void main(String[] args) {

Tree tree = new Tree();

System.out.println(“请输入节点个数”);

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

System.out.println(“请输入节点的值”);

for (int i = 0; i < n; i++) {

tree.insert(scanner.nextInt());

}

System.out.println(“后续遍历(递归):”);

tree.afterOrderRecursion();

}

}

(6)建立二叉树实现先序遍历(含递归和非递归算法实现)。

要求：二叉树中结点的值存放于一个一维数组T[n]中，T[0]开始顺序读出各结点的值，建立该二叉树的二叉链表表示。 或能够从键盘上输入树的各个结点值，建立二叉树的二叉链表存储表示，输出先序遍历结果。（难度系数为3）

package com.课程实践.Fifth;

import java.util.Scanner;

import java.util.Stack;

public class Tree {

private class Node{

Integer data;

Integer left;

Integer right;

public Node(Integer data) {

this.data = data;

this.left = -1;

this.right = -1;

}

}

Node[] nodes;

int length;

int root;

public Tree() {

this.nodes = new Node[100];

this.length = 0;

this.root = -1;

}

public void insert(int t){

root = insert(root,t);

}

private int insert(int k,int t){

if (k == -1){

k = length;

nodes[k] = new Node(t);

length++;

return k;

}else{

if (t <= nodes[k].data){

nodes[k].left = insert(nodes[k].left,t);

}else{

nodes[k].right = insert(nodes[k].right,t);

}

}

return k;

}

/**

• 先序遍历(递归)

*/

public void preOrderRecursion(){

preOrderRecursion(root);

}

public void preOrderRecursion(int k){

if (k == -1) return;

System.out.println(nodes[k].data);

preOrderRecursion(nodes[k].left);

preOrderRecursion(nodes[k].right);

}

/**

• 先序遍历(非递归)

*/

public void preOrder(){

Stack stack = new Stack();

int p = this.root;

while(p != -1 || !stack.empty()){

while (p != -1){

System.out.println(nodes[p].data);

stack.push§;

p = nodes[p].left;

}

if (!stack.empty()){

p = stack.pop();

p = nodes[p].right;

}

}

}

public static void main(String[] args) {

Tree tree = new Tree();

System.out.println(“请输入节点个数”);

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

System.out.println(“请输入节点的值”);

for (int i = 0; i < n; i++) {

tree.insert(scanner.nextInt());

}

System.out.println(“前序遍历(递归):”);

tree.preOrderRecursion();

System.out.println(“前序遍历(非递归)”);

tree.preOrder();

}

}

连通网络的最小生成树

要求：通过输入图的顶点和边的信息，建立连通网络的邻接表或邻接矩阵存储结构，求出其最小生成树。 （难度系数为3）

package com.课程实践.Fifth;

import java.util.Scanner;

public class Prim {

final static int N = 510;

final static int INT = Integer.MAX_VALUE;

static int n,m;

static int g[][] = new int[N][N];

static int dist[] = new int[N];

static boolean st[] = new boolean[N];

public static int prim(){

for (int i = 0; i < dist.length; i++) dist[i] = INT;

int ans = 0;

for (int i = 0;i < n;i++){

int t = -1;

for(int j = 1;j <= n;j++){

if (!st[j] && (t == -1 || dist[t] > dist[j])) t = j;

}

if (i != 0 && dist[t] == INT) return INT;

if (i != 0) ans += dist[t];

for (int j = 1; j <= n; j++) {

dist[j] = Integer.min(dist[j],g[t][j]);

}

st[t] = true;

}

return ans;

}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

n = scanner.nextInt();

m = scanner.nextInt();

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

for(int j = 0;j < g[0].length;j++){

g[i][j] = INT;

}

}

while (m > 0){

int a,b,c;

a = scanner.nextInt();

b = scanner.nextInt();

c = scanner.nextInt();

g[a][b] = g[b][a] = Integer.min(c,g[a][b]);

m–;

}

int t = prim();

if (t == INT) System.out.println(“不能构成树”);

else System.out.printf(“最小生成树的值” + t);

}

}

（11）、单链表的逆置(2)

要求：逆置后的单链表是一个新的单链表，但表中的结点不是新生成的，而是从原链表中得到。（难度系数为2）

package com.课程实践.Fifth;

public class LinkedList{

// 内部节点类

private class Node{

T item;

Node next;

public Node(T item, Node next) {

this.item = item;

this.next = next;

}

}

Node head;

int N;

public LinkedList() {

this.head = null;

this.N = 0;

}

public LinkedList reverseLinkedList(){

Node oldNode = this.head;

LinkedList newList = new LinkedList();

while(oldNode != null){

Node node = oldNode;

oldNode = oldNode.next;

if (newList.head == null) {

newList.head = node;

newList.head.next = null;

}

else {

node.next = newList.head;

newList.head = node;

}

}

Node current = newList.head;

return newList;

}

public void insert(T t){

Node node = head;

Node newNode = new Node(t,null);

if (head == null) {

head = newNode;

this.N++;

return;

}

while(node.next != null){

node = node.next;

}

node.next = newNode;

this.N–;

}

public void display(){

Node node = this.head;

while(node != null){

System.out.println(node.item);

node = node.next;

}

}

public static void main(String[] args) {

LinkedList oddList = new LinkedList<>();

oddList.insert(1);

oddList.insert(2);

oddList.insert(3);

oddList.insert(4);

oddList.insert(5);

System.out.println(“逆转前:”);

oddList.display();

System.out.println(“就地逆转后:”);

LinkedList newList = oddList.reverseLinkedList();

newList.display();

}

}

（14）、建立二叉树，实现层次遍历。

package com.课程实践.Fifth;

import java.util.Scanner;

import java.util.Stack;

public class Tree {

private class Node{

Integer data;

Integer left;

Integer right;

public Node(Integer data) {

this.data = data;

this.left = -1;

this.right = -1;

}

}

Node[] nodes;

int length;

int root;

public Tree() {

this.nodes = new Node[100];

this.length = 0;

this.root = -1;

}

public void insert(int t){

root = insert(root,t);

}

private int insert(int k,int t){

if (k == -1){

k = length;

nodes[k] = new Node(t);

length++;

return k;

}else{

if (t <= nodes[k].data){

nodes[k].left = insert(nodes[k].left,t);

}else{

nodes[k].right = insert(nodes[k].right,t);

}

}

return k;

}

public void layerOrder(){

for (int i = 0; i < length; i++) {

System.out.println(nodes[i].data);

}

}

public static void main(String[] args) {

Tree tree = new Tree();

System.out.println(“请输入节点个数”);

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

System.out.println(“请输入节点的值”);

for (int i = 0; i < n; i++) {

tree.insert(scanner.nextInt());

}

System.out.println(“层序遍历”);

tree.layerOrder();

}

要求：二叉树中结点的值存放于一个一维数组T[n]中，T[0]开始顺序读出各结点的值，建立该二叉树的二叉链表表示。 或能够从键盘上输入树的各个结点值，建立二叉树的二叉链存储表示，输出层次遍历结果。（难度系数为2）

（13）、循环队列(2)

package com.课程实践.Fifth;

public class CycleQueue {

T[] items;

int front,rear;

public CycleQueue(int maxSize){

items = (T[])new Object[maxSize];

front = rear = 0;

}

public boolean isEmpty(){

return front == rear;

}

public void enqueue(T t) throws Exception {

if ((rear+1)%items.length == front) throw new Exception(“队列已满”);

else items[rear] = t;
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

线程、数据库、算法、JVM、分布式、微服务、框架、Spring相关知识

一线互联网P7面试集锦+各种大厂面试集锦

学习笔记以及面试真题解析

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
,t);

}

private int insert(int k,int t){

if (k == -1){

k = length;

nodes[k] = new Node(t);

length++;

return k;

}else{

if (t <= nodes[k].data){

nodes[k].left = insert(nodes[k].left,t);

}else{

nodes[k].right = insert(nodes[k].right,t);

}

}

return k;

}

public void layerOrder(){

for (int i = 0; i < length; i++) {

System.out.println(nodes[i].data);

}

}

public static void main(String[] args) {

Tree tree = new Tree();

System.out.println(“请输入节点个数”);

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt();

System.out.println(“请输入节点的值”);

for (int i = 0; i < n; i++) {

tree.insert(scanner.nextInt());

}

System.out.println(“层序遍历”);

tree.layerOrder();

}

要求：二叉树中结点的值存放于一个一维数组T[n]中，T[0]开始顺序读出各结点的值，建立该二叉树的二叉链表表示。 或能够从键盘上输入树的各个结点值，建立二叉树的二叉链存储表示，输出层次遍历结果。（难度系数为2）

（13）、循环队列(2)

package com.课程实践.Fifth;

public class CycleQueue {

T[] items;

int front,rear;

public CycleQueue(int maxSize){

items = (T[])new Object[maxSize];

front = rear = 0;

}

public boolean isEmpty(){

return front == rear;

}

public void enqueue(T t) throws Exception {

if ((rear+1)%items.length == front) throw new Exception(“队列已满”);

else items[rear] = t;
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-MqM5aeyk-1713714652266)]

[外链图片转存中…(img-7cS9argJ-1713714652266)]

[外链图片转存中…(img-FAKfw9Ch-1713714652267)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

线程、数据库、算法、JVM、分布式、微服务、框架、Spring相关知识

[外链图片转存中…(img-TvOqRgFq-1713714652267)]

一线互联网P7面试集锦+各种大厂面试集锦

[外链图片转存中…(img-fJt7WZf9-1713714652267)]

学习笔记以及面试真题解析

[外链图片转存中…(img-64q68gJ3-1713714652267)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！