20172314 2018-2019-1 實驗一《線性結構》實驗報告

時間 2019-12-04

標籤實驗線性結構報告欄目應用數學简体版

原文原文鏈接

課程：《程序設計與數據結構》html

班級： 1723java

姓名：方藝雯node

學號：20172314git

實驗教師：王志強數組

實驗日期：2018年9月27日服務器

必修/選修：必修數據結構

一、實驗內容及要求

實驗一-1ide

鏈表練習，要求實現下列功能：函數

（1）經過鍵盤輸入一些整數，創建一個鏈表（1分）；
這些數是你學號中依次取出的兩位數。再加上今天的時間。
例如你的學號是 20172301
今天時間是 2018/10/1， 16：23：49秒
數字就是
20， 17，23，1， 20， 18，10，1，16，23，49
打印全部鏈表元素，並輸出元素的總數。
在你的程序中，請用一個特殊變量名來紀錄元素的總數，變量名就是你的名字。例如你叫張三，那麼這個變量名就是
int nZhangSan = 0; //初始化爲 0.this

作完這一步，把你的程序簽入源代碼控制（git push）。
實驗一-2

（2）實現節點插入、刪除、輸出操做（2分，3個知識點根據實際狀況酌情扣分）；

繼續你上一個程序，擴展它的功能，每作完一個新功能，或者寫了超過10行新代碼，就簽入代碼，提交到源代碼服務器；

從磁盤讀取一個文件，這個文件有兩個數字。
從文件中讀入數字1，插入到鏈表第 5 位，並打印全部數字，和元素的總數。保留這個鏈表，繼續下面的操做。
從文件中讀入數字2，插入到鏈表第 0 位，並打印全部數字，和元素的總數。保留這個鏈表，並繼續下面的操做。
從鏈表中刪除剛纔的數字1. 並打印全部數字和元素的總數。
簽入全部代碼。
實驗一-3

（3）使用冒泡排序法或者選擇排序法根據數值大小對鏈表進行排序（2分）；
若是你學號是單數，選擇冒泡排序，不然選擇選擇排序。
在排序的每個輪次中，打印元素的總數，和目前鏈表的全部元素。

在（2）獲得的程序中繼續擴展，用同一個程序文件，寫不一樣的函數來實現這個功能。仍然用 nZhangSan （你的名字）來表示元素的總數。
實驗一-4

（1）經過鍵盤輸入一些整數，創建一個鏈表（1分）；
這些數是你學號中依次取出的兩位數。再加上今天的時間。
例如你的學號是 20172301
今天時間是 2018/10/1， 16：23：49秒
數字就是
20， 17，23，1， 20， 18，10，1，16，23，49
打印全部數組元素，並輸出元素的總數。
在你的程序中，請用一個特殊變量名來紀錄元素的總數，變量名就是你的名字。例如你叫張三，那麼這個變量名就是
int nZhangSan = 0; //初始化爲 0.

作完這一步，把你的程序簽入源代碼控制（git push）。

（2）實現節點插入、刪除、輸出操做（2分，3個知識點根據實際狀況酌情扣分）；

繼續你上一個程序，擴展它的功能，每作完一個新功能，或者寫了超過10行新代碼，就簽入代碼，提交到源代碼服務器；

從磁盤讀取一個文件，這個文件有兩個數字。
從文件中讀入數字1，插入到數組第 5 位，並打印全部數字，和元素的總數。保留這個數組，繼續下面的操做。
從文件中讀入數字2，插入到數組第 0 位，並打印全部數字，和元素的總數。保留這個數組，並繼續下面的操做。
從數組中刪除剛纔的數字1. 並打印全部數字和元素的總數。
簽入全部代碼。
實驗一-5

（3）使用冒泡排序法或者選擇排序法根據數值大小對數組進行排序（2分）；
若是你學號是單數，選擇選擇排序，不然選擇冒泡排序。
在排序的每個輪次中，打印元素的總數，和目前數組的全部元素。

在（2）獲得的程序中繼續擴展，用同一個程序文件，寫不一樣的函數來實現這個功能。仍然用 nZhangSan （你的名字）來表示元素的總數。

實驗過程及結果

實驗1-1

主要代碼：

@Override
    //打印鏈表
    public String Print() {

        String result = "";
        LinearNode <T>temp = head;
        while(temp != null){
            result += temp.getElement()+ " ";
            temp = temp.next;
        }
        return result;

    }

    @Override
    //鏈表長度
    public int size() {
        return nFangYiWen;
    }
    @Override
    //尾插法
    public void add(T t){
        LinearNode<T> node = new LinearNode(t);
        LinearNode<T> temp;

        if (head == null) {
            head = node;
        }
        else {
            temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = node;
        }
        nFangYiWen++;
    }

實驗1-2

主要代碼：

@Override
    //刪除指定位置元素
    public void Delete(int where, T num) {
        LinearNode node = new LinearNode(num);
        LinearNode temp1, temp2;
        //頭刪除
        if ((where == 1) && (head.element.equals(num))) {
            head = head.next;
        } else {
            if (where <= nFangYiWen + 1) {
                temp1 = head;
                temp2 = head.next;
                for (int a = 1; a < where - 1; a++) {
                    temp1 = temp1.next;
                    temp2 = temp2.next;
                }
                //中間刪
                if (temp2.element.equals(node.element)) {
                    if (temp2.next != null) {
                        temp1.next = temp2.next;
                    }
                    //尾刪
                    else {
                        temp1.next = null;
                    }
                } else {
                    System.out.println("刪除錯誤");
                }
            } else {
                System.out.println("刪除錯誤");
            }
        }
        nFangYiWen--;
    }

實驗1-3

主要代碼：

public String SelectSort() {
        String result = "";
        String[] strings = this.Print().split(" ");
        int[] a = new int[nFangYiWen];

        for (int i = 0; i < a.length - 1; i++) {
            int y = Integer.parseInt(strings[i]);
            a[i] = y;
        }

        for (int i = 0; i < a.length - 1; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] < a[j]) {
                    int min = a[i];
                    a[i] = a[j];
                    a[j] = min;
                }
            }
            String all = "";
            for (int s = 0; s < a.length; s++) {
                all += a[s] + " ";
            }
            result += "元素總數爲：" + a.length + "\n"+ "鏈表元素爲：" + all + "\n";
        }
        return result;
    }

實驗1-4

主要代碼：

public String Print(){
        String result="";
        for (int i=0;i<Array.length;i++){
            result += Array[i]+ " ";
        }
        return result;
    }

    public int size(){
        return nFangYiWen;
    }

    public void Insert(int n,String num){
        int y =Array.length+1;
        String []result = new String[y];

        if (n==0){
            result[0]=num;
            for (int a=0;a<Array.length;a++)
            {
                result[a+1]=Array[a];
            }
        }
        else
        {
            if (n==Array.length){
                for (int a=0;a<Array.length;a++){
                    result[a]=Array[a];
                }
                result[Array.length+1]=num;
            }

            else {
                result[n]=num;
                for (int a=0;a<Array.length;a++){
                    if (a<n)
                        result[a]=Array[a];
                    else
                        result[a+1]=Array[a];
                }
            }
        }
        Array=result;
        nFangYiWen=Array.length;
    }

    public void  Delete(int n){
        String []result=new String[Array.length-1];

        if (n==0){
            for (int a=0;a<Array.length-1;a++)
            {
                result[a]=Array[a+1];
            }
        }
        else
        {
            if (n==Array.length-1){
                for (int a=0;a<Array.length-1;a++){
                    result[a]=Array[a];
                }
            }

            else {
                for (int a=0;a<Array.length-1;a++){
                    if (a<n)
                        result[a]=Array[a];
                    else
                        result[a]=Array[a+1];
                }
            }
        }
        Array=result;
        nFangYiWen=Array.length;
    }

實驗1-5

主要代碼：

//冒泡排序
    public String Sort(){
        String result2="";
        int[]array=new int[nFangYiWen];

        for (int a=0;a<nFangYiWen;a++ ){
            array[a]=Integer.parseInt(Array[a]);
        }

        for (int i = 0; i < array.length - 1; i++) {
            //遍歷次數
            for (int j = 0; j < array.length - 1 - i; j++) {
                //每次遍歷的排序
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
                }
            String every = "";
            for (int a = 0; a < array.length; a++) {
                every += array[a] + " ";
            }
            result2 += "鏈表元素爲：" + every + "\n"+ "元素的總數爲:" + array.length + "\n" ;
        }
        return result2;
    }

遇到的問題及解決

問題一：在排序時，要求每輪排序輸出元素總數，而我顯示的元素總數一直是1

問題一解決：我以前的排序代碼爲：

public Number selectionSort(Number Head) {
    //選擇排序法,大的在左
    int temp;
    Number xxx = Head;
    //while (xxx != null) {
        Number s = xxx.next;
        while (s != null) {
            if (s.number > xxx.number) {
                temp = s.number;
                s.number = xxx.number;
                xxx.number = temp;
            }
            s = s.next;
            LinkedList3 linkedlist3 = new LinkedList3();
            System.out.println("鏈表元素是：");
            linkedlist3.Print(Head); ;
            System.out.println();
            System.out.println("元素總數爲："+ linkedlist3.size());
        }
   //     xxx = xxx.next;
 //   }
    return Head;
}

其中的linkedlist3新聲明的，並非指正在排序的那條鏈表，linkedlist3.size()執行以下操做

public int size() {
    return nFangYiWen+1;
}

至關於0+1，因此元素總數一直是1.正確的應該是

public  Number selectionSort(Number Head) {
    //選擇排序法,大的在左
    int temp;
    Number xxx = Head;
    while (xxx != null) {
        Number s = xxx.next;
        while (s != null) {
            while (s.number > xxx.number) {
                temp = s.number;
                s.number = xxx.number;
                xxx.number = temp;
            }
            s = s.next;
        }
        xxx=xxx.next;
        System.out.println();
        System.out.print("鏈表元素是：");
        Print(Head);
        System.out.println();
        System.out.println("元素總數爲：" + size());
    }
        return Head;
}

問題二：元素重複出現問題
問題二解決：以前的錯誤代碼爲
```
while(num.hasMoreTokens()) {
        int i = Integer.parseInt(num.nextToken());
        Number number = new Number(i);
        Number Head = new Number(i);
        xxx.add(Head,number);
        xxx.Print(Head);
    }
```
這樣的話每次while循環中，i有一個新的值，Head也爲新的值，完整的鏈表還未造成，因此每次打印出一個Head,一個number，將xxx.Print(Head)移到while循環外便可。
問題三：運行程序拋出錯誤java.lang.NumberFormatException:For input String
問題三解決：在網上查找解決辦法得知是由於

當應用程序試圖將字符串轉換成一種數值類型，但該字符串不能轉換爲適當格式時，拋出該異常
也就是說你的字符串有問題

仔細檢查代碼後發現

應爲

由於.toString獲得的字符串沒有「」，在選擇排序法中須要的形式有格式限制的。