学生成绩档案管理系统——实验准备

学生成绩档案管理系统——实验准备

实验任务

学生信息录入，信息包括学号、姓名、专业、四门课成绩、总分、名次
系统可对学生信息浏览、增加、删除和修改
按学生成绩名次及信息输入，双向冒泡排序、希尔排序、快速排序、堆排序
要求可对学生信息查询，根据学号或者姓名进行查找
信息删改仅可修改四门课成绩
文件存取学生信息

编程语言及开发环境

编程语言：JAVA
开发环境：JDK1.8

算法

1.双向冒泡排序

public static void bubbleSort_Two(int[] list){
	//j在最外层定义
	boolean needNextPass = true;
	for(int i=0,j;i<list.length/2&&needNextPass;i++){
		needNextPass = false;
		//list.length-1-i 代替list.length-i(i初始化1)  保证反向冒泡
		for(j=i;j<list.length-1-i;j++){
			if(list[j]>list[j+1]){
				int temp = list[j];
				list[j] = list[j+1];
				list[j+1] = temp;
				needNextPass = true;
			}
		}
		System.out.println("-------------->第"+(i+1)+"次正向冒泡");
		//--j 遍历开始，j>i  外层循环i++保证了j的遍历结束也是不包含遍历过的
		for(--j;j>i;j--){
			if(list[j]<list[j-1]){
				int temp = list[j];
				list[j] = list[j-1];
				list[j-1] = temp;
				needNextPass = true;
			}
		}
		System.out.println("-------------->第"+(i+1)+"次反向冒泡");
	}
}
public static void main(String[] args) {
	int [] list = {2,3,2,5,6,1,-2,3,14,12};
	bubbleSort_Two(list);
	for(int i=0;i<list.length;i++){
		System.out.print(list[i]+" ");
	}

}

2.希尔排序

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {5, 1, 7, 3, 1, 6, 9, 4};
        shellSort(arr);

        for (int i : arr) {
            System.out.print(i + "\t");
        }
    }

    private static void shellSort(int[] arr) {
        //step:步长
        for (int step = arr.length / 2; step > 0; step /= 2) {
            //对一个步长区间进行比较 [step,arr.length)
            for (int i = step; i < arr.length; i++) {
                int value = arr[i];
                int j;

                //对步长区间中具体的元素进行比较
                for (j = i - step; j >= 0 && arr[j] > value; j -= step) {
                    //j为左区间的取值，j+step为右区间与左区间的对应值。
                    arr[j + step] = arr[j]; 
                }
                //此时step为一个负数，[j + step]为左区间上的初始交换值
                arr[j + step] = value;  
            }
        }
    }
}

3.快速排序

public static void quickSort(int[] array) {
 6     int len;
 7     if(array == null
 8             || (len = array.length) == 0
 9             || len == 1) {
10         return ;
11     }
12     sort(array, 0, len - 1);
13 }
14 
15 /**
16  * 快排核心算法，递归实现
17  * @param array
18  * @param left
19  * @param right
20  */
21 public static void sort(int[] array, int left, int right) {
22     if(left > right) {
23         return;
24     }
25     // base中存放基准数
26     int base = array[left];
27     int i = left, j = right;
28     while(i != j) {
29         // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
30         while(array[j] >= base && i < j) {
31             j--;
32         }
33 
34         // 再从左往右边找，直到找到比base值大的数
35         while(array[i] <= base && i < j) {
36             i++;
37         }
38 
39         // 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
40         if(i < j) {
41             int tmp = array[i];
42             array[i] = array[j];
43             array[j] = tmp;
44         }
45     }
46 
47     // 将基准数放到中间的位置（基准数归位）
48     array[left] = array[i];
49     array[i] = base;
50 
51     // 递归，继续向基准的左右两边执行和上面同样的操作
52     // i的索引处为上面已确定好的基准值的位置，无需再处理
53     sort(array, left, i - 1);
54     sort(array, i + 1, right);
55 }

4.堆排序

public class HeapSort {
    public static void main(String[] args) {
//        int[] arr = {5, 1, 7, 3, 1, 6, 9, 4};
        int[] arr = {16, 7, 3, 20, 17, 8};

        heapSort(arr);

        for (int i : arr) {
            System.out.print(i + " ");
        }
    }


    /**
     * 创建堆，
     * @param arr 待排序列
     */
    private static void heapSort(int[] arr) {
        //创建堆
        for (int i = (arr.length - 1) / 2; i >= 0; i--) {
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr, i, arr.length);
        }

        //调整堆结构+交换堆顶元素与末尾元素
        for (int i = arr.length - 1; i > 0; i--) {
            //将堆顶元素与末尾元素进行交换
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;

            //重新对堆进行调整
            adjustHeap(arr, 0, i);
        }
    }

    /**
     * 调整堆
     * @param arr 待排序列
     * @param parent 父节点
     * @param length 待排序列尾元素索引
     */
    private static void adjustHeap(int[] arr, int parent, int length) {
        //将temp作为父节点
        int temp = arr[parent];
        //左孩子
        int lChild = 2 * parent + 1;

        while (lChild < length) {
            //右孩子
            int rChild = lChild + 1;
            // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
            if (rChild < length && arr[lChild] < arr[rChild]) {
                lChild++;
            }

            // 如果父结点的值已经大于孩子结点的值，则直接结束
            if (temp >= arr[lChild]) {
                break;
            }

            // 把孩子结点的值赋给父结点
            arr[parent] = arr[lChild];

            //选取孩子结点的左孩子结点,继续向下筛选
            parent = lChild;
            lChild = 2 * lChild + 1;
        }
        arr[parent] = temp;
    }
}