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

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

项目需求

• 项目需求

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

算法与数据结构

1.双向冒泡排序

原理：
代码实现：

 public static int[] doubleBuddleSort(int[] num) {
        int left = 0, right = num.length - 1;
        while (left < right) {
            //较大气泡从左边向右边移动
            for (int i = left + 1; i <= right; i++) {
                if (num[left] > num[i]) {
                    int temp = num[left];
                    num[left] = num[i];
                    num[i] = temp;
                }
            }
            left++;

            //较小气泡从右边向左边移动
            for (int i = right - 1; i >= left; i--) {
                if (num[i] > num[right]) {
                    int temp = num[right];
                    num[right] = num[i];
                    num[i] = temp;
                }
            }
            right--;
        }

        return num;
    }

2.希尔排序

算法描述：希尔排序是插入排序的一种改进，主要是为了解决当较小的 数据大都出现在数组后面时导致的移动次数明显增多的问题，思想是使 用一个不断缩小的增量gap将数组元素分组，在每个分组内部先进行插 入排序，当gap减少到1时整个数组元素分在一组，最后进行一次插入排序，整个排序过程结束。

代码实现：

    public class ShellSort {
        public static void shellSort(int[] arr) {
            if (arr == null || arr.length < 2) {
                return;
            }
            for (int gap = arr.length / 2; gap > 0; gap /= 2) {
                for (int i = gap; i < arr.length; i++) {
                    int j = i;
                    int tmp = arr[j];
                    if (arr[j] < arr[j - gap]) {
                        while (j - gap >= 0 && tmp < arr[j - gap]) {
                            arr[j] = arr[j - gap];
                            j -= gap;
                        }
                    }
                    arr[j] = tmp;
                }
            }
        }
    }

3.快速排序

算法描述：快速排序算法利用的是一趟快速排序,基本内容是选择一个数作为准基数,然后利用这个准基数将遗传数据分为两个部分,第一部分比这个准基数小,都放在准基数的左边,第二部分都比这个准基数大,放在准基数的右边.

代码实现：
public void sort(int left,int right,int[] array) {
if (left >= right) return;
int start = left;
int end = right;
int flag = left;
while (left < right) {
while ((left < right) && (array[right] >= array[flag])) {
right–;
}
if (array[right] < array[flag]) {
int tmp = array[right];
array[right] = array[flag];
array[flag] = tmp;
flag = right;
}
while ((left < right) && (array[left] <= array[flag])) {
left++;
}
if (array[left] > array[flag]) {
int tmp = array[left];
array[left] = array[flag];
array[flag] = tmp;
flag = left;
}
}
sort(start, left - 1, array);
sort(left + 1, end, array);
}

4.堆排序

算法描述：堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

代码实现：public static void main(String []args){
int []arr = {7,6,7,11,5,12,3,0,1};
System.out.println(“排序前：”+Arrays.toString(arr));
sort(arr);
System.out.println(“排序前：”+Arrays.toString(arr));
}

public static void sort(int []arr){
    //1.构建大顶堆
    for(int i=arr.length/2-1;i>=0;i--){
        //从第一个非叶子结点从下至上，从右至左调整结构
        adjustHeap(arr,i,arr.length);
    }
    //2.调整堆结构+交换堆顶元素与末尾元素
    for(int j=arr.length-1;j>0;j--){
        swap(arr,0,j);//将堆顶元素与末尾元素进行交换
        adjustHeap(arr,0,j);//重新对堆进行调整
    }

}

/**
 * 调整大根堆（仅是调整过程，建立在大顶堆已构建的基础上）
 * @param arr
 * @param i
 * @param length
 */
public static void adjustHeap(int []arr,int i,int length){
    int temp = arr[i];//先取出当前元素i
    for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
        if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
            k++;
        }
        if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
            arr[i] = arr[k];
            i = k;
        }else{
            break;
        }
    }
    arr[i] = temp;//将temp值放到最终的位置
}

/**
 * 交换元素
 * @param 
 * @param 
 * @param 
 */
public static void swap(int []arr,int a ,int b){
    int temp=arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

使用语言及环境

• 使用语言：Java
• 环境：JDK1.8
• 工具：IntelliJ IDEA

程序设计