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;
rear = (rear+1)%items.length;
}
public T dequeue() throws Exception {
if (front == rear) throw new Exception(“队列已空”);
T t = items[front];
front = (front+1)%items.length;
return t;
}
public void show(){
for (int i = front; i != rear ; i = (i+1)%items.length) {
System.out.print(items[i] + " ");
}
}
public static void main(String[] args) throws Exception {
CycleQueue queue = new CycleQueue(5);
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
queue.enqueue(4);
queue.dequeue();
queue.enqueue(10);
queue.show();
}
}
（15）、一元多项式计算。(2)
要求：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输出；（难度系数为2）
package com.课程实践.Fifth;
import java.util.Scanner;
public class Polynomial15 {
public Node head;
private class Node{
// 系数
public double coefficient;
// 指数
public int index;
Node next;
public Node(double coefficient, int index, Node next) {
this.coefficient = coefficient;
this.index = index;
this.next = next;
}
@Override
public String toString() {
return
"系数是 " + coefficient +
“, 指数是” + index ;
}
}
public Polynomial15() {
this.head = null;
}
/**
-
可以按指数大小插入节点
-
@param coefficient
-
@param index
*/
public void insert(double coefficient, int index){
Node newNode = new Node(coefficient,index,null);
if (head == null){
head = newNode;
return;
}
Node currentNode = head.next;
Node preNode = head;
// 比头节点的指数小
if (index < preNode.index){
newNode.next = head;
head = newNode;
return;
}
// 一般性
while(currentNode != null){
// 当前节点的指数比新节点的指数大
if (index <= currentNode.index){
newNode.next = currentNode;
preNode.next = newNode;
return;
}else{
preNode = preNode.next;
currentNode = currentNode.next;
}
}
preNode.next = newNode;
}
public static Polynomial15 addPolynomial(Polynomial15 l1,Polynomial15 l2){
Node node1 = l1.head;
Node node2 = l2.head;
Polynomial15 l3 = new Polynomial15();
while(node1 != null && node2 != null){
if(node1.index < node2.index) {
l3.insert(node1.coefficient,node1.index);
node1 = node1.next;
}else if(node1.index > node2.index){
l3.insert(node2.coefficient,node2.index);
node2 = node2.next;
}else{
l3.insert(node1.coefficient+node2.coefficient,node1.index);
node1 = node1.next;
node2 = node2.next;
}
}
while(node1 != null) {
l3.insert(node1.coefficient,node1.index);
node1 = node1.next;
}
while(node2 != null){
l3.insert(node2.coefficient,node2.index);
node2 = node2.next;
}
return l3;
}
public static Polynomial15 subPolynomial(Polynomial15 l1,Polynomial15 l2){
Node node1 = l1.head;
Node node2 = l2.head;
Polynomial15 l3 = new Polynomial15();
while(node1 != null && node2 != null){
if(node1.index < node2.index) {
l3.insert(node1.coefficient,node1.index);
node1 = node1.next;
}else if(node1.index > node2.index){
l3.insert(node2.coefficient,node2.index);
node2 = node2.next;
}else{
l3.insert(node1.coefficient-node2.coefficient,node1.index);
node1 = node1.next;
node2 = node2.next;
}
}
while(node1 != null) {
l3.insert(node1.coefficient,node1.index);
node1 = node1.next;
}
while(node2 != null){
l3.insert(node2.coefficient,node2.index);
node2 = node2.next;
}
return l3;
}
public static void main(String[] args) {
Polynomial15 l1 = new Polynomial15();
Polynomial15 l2 = new Polynomial15();
Scanner scanner = new Scanner(System.in);
int N;
double coefficient;
int index;
System.out.println(“请输入第一个多项式的项数”);
N = scanner.nextInt();
System.out.println(“请分别输入多项式的系数和指数”);
for(int i = 0;i < N;i++){
coefficient = scanner.nextDouble();
index = scanner.nextInt();
l1.insert(coefficient,index);
}
System.out.println(“请输入第二个多项式的项数”);
N = scanner.nextInt();
System.out.println(“请分别输入多项式的系数和指数”);
for(int i = 0;i < N;i++){
coefficient = scanner.nextDouble();
index = scanner.nextInt();
l2.insert(coefficient,index);
}
System.out.println(“请选择您要进行的运算”);
System.out.println(“1.进行加法”);
System.out.println(“2.进行减法”);
N = scanner.nextInt();
Polynomial15 l3;
if (N == 1){
l3 = addPolynomial(l1,l2);
}else{
l3 = subPolynomial(l1,l2);
}
Node node = l3.head;
System.out.println(“运算后的多项式是:”);
while(node != null){
if(node.coefficient != 0) System.out.println(node);
node = node.next;
}
}
}
（17）、猴子选大王。(2)
任务：一堆猴子都有编号，编号是1，2，3 …m ,这群猴子（m个）按照1-m的顺序围坐一圈，从第1开始数，每数到第N个，该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王。要求：输入m, n，其中 m, n 为整数，n<m，按照m个猴子，数n 个数的方法，输出为大王的猴子的编号。（难度系数为2）
package com.课程实践.Fifth;
import java.util.Scanner;
public class MonkeyKing {
private class Node{
Node next;
int num;
public Node( int num,Node next) {
this.next = next;
this.num = num;
}
}
Node head;
public MonkeyKing() {
this.head = null;
}
public void insert(int i){
Node current = head;
if (current == null) {
head = new Node(i,null);
return;
}
while(current.next != null) current = current.next;
current.next = new Node(i,null);
}
public void delete(Node current){
Node preNode = head;
while (preNode.next != null){
if (preNode.next.equals(current)){
preNode.next = current.next;
current = current.next;
return;
}else {
preNode = preNode.next;
}
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println(“请输入猴子的数量”);
int M = scanner.nextInt();
System.out.println(“请输入报数的N”);
int N = scanner.nextInt();
MonkeyKing monkeys = new MonkeyKing();
for (int i = 1; i <= M; i++) {
monkeys.insert(i);
}
Node currentNode = monkeys.head;
Node lastNode = monkeys.head;
// 构建循环链表
while(lastNode.next != null){
lastNode = lastNode.next;
}
// 尾结点指向头节点
lastNode.next = monkeys.head;
int count = 1;
while (currentNode.next != null && !currentNode.equals(currentNode.next)){
if (count != N) {
currentNode = currentNode.next;
count++;
}else{
monkeys.delete(currentNode);
count = 0;
}
}
System.out.println(“国王的编号是”);
System.out.println(currentNode.num);
}
}
（18）、已知有序表中的元素以值递增有序排列，并以带头结点的单链表作存储结构。试编写算法删除表中所有值大于mink且小于maxk的元素，同时释放被删结点空间，并分析算法的时间复杂度。（难度系数为2）
package com.课程实践.Fifth;
public class DeleteNode18 {
private class Node{
T data;
Node next;
public Node(T data, Node next) {
this.data = data;
this.next = next;
}
}
Node head;
public DeleteNode18() {
this.head = null;
}
public void insert(T t){
if (head == null){
head = new Node(t,null);
return;
}
Node currentNode = head;
while(currentNode.next != null) currentNode = currentNode.next;
currentNode.next = new Node(t,null);
}
public void delete(T minK,T maxK){
Node currentNode = head;
Node minNode = head,maxNode = head;
boolean flag1 = true,flag2 = true;
while(currentNode != null){
// 找到第一个大于minK的节点
if (currentNode.data.compareTo(minK) > 0 && flag1){
flag1 = false;
minNode = currentNode;
currentNode = currentNode.next;
// 找到第一个大于maxK的元素
}else if (currentNode.data.compareTo(maxK) > 0 && flag2){
flag2 = false;
maxNode = currentNode;
break;
}else{
currentNode = currentNode.next;
}
}
Node preMinNode = head;
Node preMaxNode = head;
while (!preMaxNode.next.equals(maxNode)) preMaxNode = preMaxNode.next;
while (!preMinNode.next.equals(minNode)) preMinNode = preMinNode.next;
preMinNode.next = preMaxNode;
}
public static void main(String[] args) {
DeleteNode18 nodes = new DeleteNode18();
nodes.insert(1);
nodes.insert(1);
nodes.insert(2);
nodes.insert(3);
nodes.insert(3);
nodes.insert(4);
nodes.insert(5);
nodes.insert(6);
nodes.insert(7);
DeleteNode18.Node node = nodes.head;
System.out.println(“原链表为:”);
while(node != null){
System.out.print(node.data + " ");
node = node.next;
}
nodes.delete(3,5);
node = nodes.head;
System.out.println();
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
最后
ActiveMQ消息中间件面试专题
- 什么是ActiveMQ?
- ActiveMQ服务器宕机怎么办？
- 丢消息怎么办？
- 持久化消息非常慢怎么办？
- 消息的不均匀消费怎么办？
- 死信队列怎么办？
- ActiveMQ中的消息重发时间间隔和重发次数吗？
ActiveMQ消息中间件面试专题解析拓展：
redis面试专题及答案
- 支持一致性哈希的客户端有哪些？
- Redis与其他key-value存储有什么不同？
- Redis的内存占用情况怎么样？
- 都有哪些办法可以降低Redis的内存使用情况呢？
- 查看Redis使用情况及状态信息用什么命令？
- Redis的内存用完了会发生什么？
- Redis是单线程的，如何提高多核CPU的利用率？
Spring面试专题及答案
- 谈谈你对 Spring 的理解
- Spring 有哪些优点？
- Spring 中的设计模式
- 怎样开启注解装配以及常用注解
- 简单介绍下 Spring bean 的生命周期
Spring面试答案解析拓展
高并发多线程面试专题
- 现在有线程 T1、T2 和 T3。你如何确保 T2 线程在 T1 之后执行，并且 T3 线程在 T2 之后执行？
- Java 中新的 Lock 接口相对于同步代码块（synchronized block）有什么优势？如果让你实现一个高性能缓存，支持并发读取和单一写入，你如何保证数据完整性。
- Java 中 wait 和 sleep 方法有什么区别？
- 如何在 Java 中实现一个阻塞队列？
- 如何在 Java 中编写代码解决生产者消费者问题？
- 写一段死锁代码。你在 Java 中如何解决死锁？
高并发多线程面试解析与拓展
jvm面试专题与解析
- JVM 由哪些部分组成？
- JVM 内存划分？
- Java 的内存模型?
- 引用的分类？
- GC什么时候开始？
JVM面试专题解析与拓展！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
e (!preMinNode.next.equals(minNode)) preMinNode = preMinNode.next;
preMinNode.next = preMaxNode;
}
public static void main(String[] args) {
DeleteNode18 nodes = new DeleteNode18();
nodes.insert(1);
nodes.insert(1);
nodes.insert(2);
nodes.insert(3);
nodes.insert(3);
nodes.insert(4);
nodes.insert(5);
nodes.insert(6);
nodes.insert(7);
DeleteNode18.Node node = nodes.head;
System.out.println(“原链表为:”);
while(node != null){
System.out.print(node.data + " ");
node = node.next;
}
nodes.delete(3,5);
node = nodes.head;
System.out.println();
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-KziLOjqu-1713714687171)]
[外链图片转存中…(img-pdfdT80R-1713714687172)]
[外链图片转存中…(img-M7WkcXIA-1713714687172)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
最后
ActiveMQ消息中间件面试专题
- 什么是ActiveMQ?
- ActiveMQ服务器宕机怎么办？
- 丢消息怎么办？
- 持久化消息非常慢怎么办？
- 消息的不均匀消费怎么办？
- 死信队列怎么办？
- ActiveMQ中的消息重发时间间隔和重发次数吗？
ActiveMQ消息中间件面试专题解析拓展：
[外链图片转存中…(img-BuhRyi2r-1713714687172)]
redis面试专题及答案
- 支持一致性哈希的客户端有哪些？
- Redis与其他key-value存储有什么不同？
- Redis的内存占用情况怎么样？
- 都有哪些办法可以降低Redis的内存使用情况呢？
- 查看Redis使用情况及状态信息用什么命令？
- Redis的内存用完了会发生什么？
- Redis是单线程的，如何提高多核CPU的利用率？
[外链图片转存中…(img-8H9CkYW3-1713714687172)]
Spring面试专题及答案
- 谈谈你对 Spring 的理解
- Spring 有哪些优点？
- Spring 中的设计模式
- 怎样开启注解装配以及常用注解
- 简单介绍下 Spring bean 的生命周期
Spring面试答案解析拓展
[外链图片转存中…(img-DpYfvkFR-1713714687173)]
高并发多线程面试专题
- 现在有线程 T1、T2 和 T3。你如何确保 T2 线程在 T1 之后执行，并且 T3 线程在 T2 之后执行？
- Java 中新的 Lock 接口相对于同步代码块（synchronized block）有什么优势？如果让你实现一个高性能缓存，支持并发读取和单一写入，你如何保证数据完整性。
- Java 中 wait 和 sleep 方法有什么区别？
- 如何在 Java 中实现一个阻塞队列？
- 如何在 Java 中编写代码解决生产者消费者问题？
- 写一段死锁代码。你在 Java 中如何解决死锁？
高并发多线程面试解析与拓展
[外链图片转存中…(img-68ZNQGam-1713714687173)]
jvm面试专题与解析
- JVM 由哪些部分组成？
- JVM 内存划分？
- Java 的内存模型?
- 引用的分类？
- GC什么时候开始？
JVM面试专题解析与拓展！
[外链图片转存中…(img-DeuoxsWr-1713714687173)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
