数据结构课程实践——学生成绩档案管理系统——实验预习

数据结构实践——学生成绩档案管理系统——实验预习

实验流程：

（1）系统设计

       主函数设计
       主要功能模块

（2）排序方法

       双向冒泡
       希尔排序
       快速排序
       堆排序

（3）文件保存

需求分析

新增学生信息（包括学号、姓名、专业、4门课成绩……）
浏览学生信息（对学生排序后信息进行浏览）
删除学生信息（删除指定学生的信息，可给用户选择检索指定项）
查找学生信息（查找符合条件的某条记录）
保存学生信息（保存学生成绩档案信息到文本文件）
加载学生信息（登录系统后将磁盘文件中保存的学生成绩信息读取到内存中）

系统设计

（1）main函数 用来调用各种函数的主区域

（2）student类 主要存放学生的各种属性，例如学号，姓名，专业等等

（3）studentd类 主要存放student类的ArrayList数组，存放增删改查的函数

（4）screen类，主要存放与用户交互的函数

screen用户界面交互函数

class screen
{
    void maindan()
    {
        student1 pg1=new student1();
        pg1.add();
        int qp=1;
        while(qp!=0) {
        Scanner sc=new Scanner(System.in);
        System.out.println("输入一个数字进行操作");
        System.out.println("1.用学号查找学生");
        System.out.println("2.修改学生成绩");
        System.out.println("3.查看所有学生成绩");
        System.out.println("4.用学号删除学生");
        System.out.println("5.排序查看学生");
        int s=sc.nextInt();
            switch (s) {
                case 1:
                    pg1.cha();
                    break;
                case 2:
                    pg1.gai();
                    break;
                case 3:
                    pg1.look();
                    break;
                case 4:
                    pg1.delete();
                    break;
                case 5:
                    pg1.paixu();
                    break;
                default:
                    System.out.println("输入错误");
                    break;
            }
            System.out.println("请输入一个数字,如果为0,则退出系统");
            int ppgr=sc.nextInt();
            qp=ppgr;
        }
    }
}

冒泡排序

public void twoSort(ArrayList<student> li){
        int left=0,right = li.size()-1;
        while(left<right){

            //左侧扫描
            for(int j = left+1; j <= right; j++) {
                if(li.get(left).score1<li.get(j).score1) {
                    student temp=li.get(left);
                    li.set(left,li.get(j));
                    li.set(j,temp);
                }
            }
            left++;

            if(left>=right){
                break;
            }

            //右侧扫描
            for(int j = right-1; j >= left; j--) {
                if(li.get(right).score1>li.get(j).score1) {
                    student temp=li.get(right);
                    li.set(right,li.get(j));
                    li.set(j,temp);
                }
            }
            right--;
        }
    }

        System.out.println("根据成绩1排序后的结果");
        for (int jjj = 0; jjj <= aa.size() - 1; jjj++) {
            System.out.println("姓名" + aa.get(jjj).xingming + " 学号" + aa.get(jjj).xuehao + " 专业" + aa.get(jjj).zhuangye + "  成绩1 " + aa.get(jjj).score1 + "  成绩2 " + aa.get(jjj).score2 + "  成绩3 " + aa.get(jjj).score3 + "  成绩4 " + aa.get(jjj).score4);
        }

    }

希尔排序

void xierpaixu1()
    {
        student temp=new student(1,2,3,4,1,"ui","er");
        int d,i,j;
        int n=aa.size()-1;
        for(d=n/2;d>=1;d=d/2)
        {
            for(i=d;i<=n;i++)
            {
                temp=aa.get(i);
            }
            for(j=i-d;j>=0&&temp.score1>aa.get(j).score1;j-=d)
            {
                aa.set(j+d,aa.get(j));
            }
            aa.set(j+d,temp);
        }
    }

快速排序

 void quicksort(ArrayList<student> pp ,int left,int right){
        if (left > right) {
            return;
        }
        int i = left;
        int j = right;
        student t = aa.get(left);

        while (i != j){
            while (aa.get(j).score1 <= t.score1&& (j > i)) {
                j--;
            }
            while (aa.get(i).score1 >= t.score1&& (j > i)) {
                i++;
            }
            //交换位置
            if (i < j) {
                student temp=aa.get(i);
                aa.set(i,aa.get(j));
                aa.set(j,temp);
            }
        }
        aa.set(left,aa.get(i));
        aa.set(i,t);

        //递归左子序列
        quicksort(aa,left, --i);
        //递归右子序列
        quicksort(aa,++j, right);
        return;
    }

堆排序

public void heapSort(ArrayList<student> list){
        int i = 0;
        int n=list.size()-1;
        //初始建堆，从最后一个分支结点至根结点
        for (i = n/2; i >= 1; i--) {
            Sift(list, i, n);
        }
        //重复执行移走堆顶及重建堆的操作
        for (i=0; i<n; i++) {
            //交换0和末尾（n-i）的位置
            student temp=list.get(0);
            list.set(0,list.get(n-i));
            list.set(n-i,temp);
            Sift(list, 0, n-i-1);
        }
    }


    void Sift(ArrayList<student> list, int k, int m)
    {
        //i指向被筛选结点，j指向结点i的左孩子
        int i = k, j = 2 * i;
        if(i==0){
            j=1;
        }
        while (j <= m) {
            //比较i的左右孩子，j指向两者中的较小者
            if (j < m &&list.get(j).score1< list.get(j+1).score1) {
                j++;
            }
            //若根结点已经小于左右孩子中的较小者
            if (list.get(i).score1 < list.get(j).score1) {
                break;
            } else {
                student temp=list.get(i);
                list.set(i,list.get(j));
                list.set(j,temp);
                //被筛结点位于原来结点j的位置
                i = j; j = 2 * i;
            }
        }
    }

文件保存

（1）使用BufferWriter写文件，使用 FileOutputStream(fileName, false)来构造，保证每次将文件根据list重写