20172329《程序設計與數據結構》實驗一：線性結構實驗報告

20172329 2018-2019-2 《程序設計與數據結構》實驗一報告

課程：《程序設計與數據結構》
班級： 1723
姓名： 王文彬
學號：20172329
實驗教師：王志強
實驗日期：2018年9月30日
必修/選修： 必修

一.實驗內容

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）實現節點插入、刪除、輸出操做
• 繼續你上一個程序， 擴展它的功能，每作完一個新功能，或者寫了超過10行新代碼，就簽入代碼，提交到源代碼服務器；
• 從磁盤讀取一個文件， 這個文件有兩個數字。
• 從文件中讀入數字1， 插入到鏈表第 5 位，並打印全部數字，和元素的總數。 保留這個鏈表，繼續下面的操做。
• 從文件中讀入數字2， 插入到鏈表第 0 位，並打印全部數字，和元素的總數。 保留這個鏈表，並繼續下面的操做。
• 從鏈表中刪除剛纔的數字1. 並打印全部數字和元素的總數。
• 簽入全部代碼。

3、第三個實驗要求

• 鏈表練習，要求實現下列功能：
  （3）使用冒泡排序法或者選擇排序法根據數值大小對鏈表進行排序；
• 若是你學號是單數， 選擇冒泡排序， 不然選擇選擇排序。
• 在排序的每個輪次中， 打印元素的總數，和目前鏈表的全部元素。
• 在（2）獲得的程序中繼續擴展， 用同一個程序文件，寫不一樣的函數來實現這個功能。 仍然用 nZhangSan （你的名字）來表示元素的總數。

4、第四個實驗要求

• 數組練習，要求實現下列功能：
  （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）實現節點插入、刪除、輸出操做；
• 繼續你上一個程序， 擴展它的功能，每作完一個新功能，或者寫了超過10行新代碼，就簽入代碼，提交到源代碼服務器；
• 從磁盤讀取一個文件， 這個文件有兩個數字。
• 從文件中讀入數字1， 插入到數組第 5 位，並打印全部數字，和元素的總數。 保留這個數組，繼續下面的操做。
• 從文件中讀入數字2， 插入到數組第 0 位，並打印全部數字，和元素的總數。 保留這個數組，並繼續下面的操做。
• 從數組中刪除剛纔的數字1. 並打印全部數字和元素的總數。
• 簽入全部代碼。

5、第五個實驗要求

• 數組練習，要求實現下列功能：
  （3）使用冒泡排序法或者選擇排序法根據數值大小對數組進行排序；
• 若是你學號是單數， 選擇選擇排序， 不然選擇冒泡排序。
• 在排序的每個輪次中， 打印元素的總數，和目前數組的全部元素。
• 在（2）獲得的程序中繼續擴展， 用同一個程序文件，寫不一樣的函數來實現這個功能。 仍然用 nZhangSan （你的名字）來表示元素的總數。

2、實驗過程及結果

第一個實驗

• 過程：首先這個實驗在以前的第四章的時候能夠用隊列實現，由於自己咱們本身隊列就是由鏈表實現的，因此就直接調用了當時本身寫的那個類，在裏面本身寫了各類各樣的插入方法。其中爲了解決想要把一段須要鍵入的數字給寫進隊列，就不得不使用尾插法用一個for循環將其寫進循環，同時也要使得題目裏所要求的nwangwenbin那個變量能夠發揮出它應該有的做用，因此就使用了這樣一個循環。

for (int i =0;i<c.length;i++)
        {
            a.enqueue(c[i]);
        }

而後用size()方法把隊列的元素個數給輸出。

• 代碼結果截圖：
  

第二個實驗

• 過程：由於須要用鏈表實現插入，刪除，輸出等方法，因此在實現這個實驗期間，須要解決頭插法的實現，由於當時老師講的頭插法我可能用了錯誤的方式進行了實現,雖然能夠進行頭插法的實現，可是並無實際的插入到隊列中，因此這是一個待解決的問題，其次，在進行這個實驗中，我參考了我一樣參考了以前我本身寫過的一個類，由於以前本身寫的方法都將其定義爲了靜態，因此每個方法都是相互獨立的，因此爲了將nwangwenbin成功發揮出它的做用，我將這些靜態方法都作出了適當改變，以即可以成功計數，從而使得size方法寫的比較完整。

• 具體代碼實現：
  （1）插入方法的實現：

public void Firstinsert(Number Head, Number node) {//頭插
        node.next = Head;
        Head = node;
        nWangwenbin++;
        System.out.print(Head.number+" ");
    }
    public void insert(Number Head, Number node1, Number node2, Number node) {//中間插
        Number point = Head;
        while ((point.number != node1.number) && point != null)

        {
            point = point.next;
        }

        if (point.number == node1.number) {
            node.next = node2;
            point.next = node;
        }
        nWangwenbin++;

    }
public  void add(Number Head, Number node) {//尾插

        Number temp = Head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
        nWangwenbin++;
    }

（2）刪除方法的實現：

public void delet(Number Head, Number node) {
        Number p = Head, Curr = Head;
        while (Curr != null) {
            if (Curr.number != node.number) {
                p = Curr;
                Curr = Curr.next;
            } else {
                break;
            }
        }
        p.next = Curr.next;
        nWangwenbin--;
    }

（3）輸出方法實現：

public void print(Number Head) {
        Number node = Head;
        while (node != null) {
            System.out.print(node.number+",");
            node = node.next;
        }
    }

（4）計數方法實現：

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

• 實現結果截圖：
  

第三個實驗

• 過程：本實驗主要考察咱們對於排序法的編寫以及理解，可以本身變出一個算法的前提就是要搞清楚這個算法究竟是如何進行的，而不是憑空想象或者更隨便的從網上抄一段代碼來，相信你們都不想讓本身作那個吃別人剩下的，由於假如未來咱們要從事的是計算機行業，而進入一個企業的一些考驗每每就是這些最基礎的算法。
• 首先，先來帶你們瞭解一下什麼是冒泡排序。
• （1）原理：比較兩個相鄰的元素，將值大的元素交換至右端。

• （2）思路：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。而後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。重複第一趟步驟，直至所有排序完成。
  第一趟比較完成後，最後一個數必定是數組中最大的一個數，因此第二趟比較的時候最後一個數不參與比較；
  第二趟比較完成後，倒數第二個數也必定是數組中第二大的數，因此第三趟比較的時候最後兩個數不參與比較；
  依次類推，每一趟比較次數-1；

• 形象展現
  
  

• 具體代碼實現

public  Number bubbleSort(Number head){
        if(head == null || head.next == null)
            return head;

        Number cur = null, tail = null;

        cur = head;

        while(cur.next != tail){
            while(cur.next != tail){
                if(cur.number > cur.next.number){
                    int tmp = cur.number;
                    cur.number = cur.next.number;
                    cur.next.number = tmp;
                }
                cur = cur.next;

                }
                Number node = head;
            while (node != null) {
                System.out.print(node.number+" ");
                node = node.next;
            }
            System.out.println("該一輪的元素數量爲："+(nWangwenbin-1));

            tail = cur;
            cur = head;

        }
     return null;
}

• 實驗結果截圖
  

第四個實驗

• 過程：第四個實現，旨在讓咱們用數組實現第1、二個實驗所須要的功能，其中咱們須要實現的是不只僅只有插入，刪除的方法，還要就這個題目結合本身的代碼進行其餘方法的處理與編寫，以使得本身的代碼能夠完成其應當有的功能。

• 關鍵代碼顯示

public void add(int array[],int a){
        if (array[0]==0){
            array[0]=a;
        }
        else {
            int i =0;
            while (array[i]!=0){
                i++;
            }
            array[i]=a;
        }
        nwangwenbin++;
}
    public int size(){
        return nwangwenbin;
    }

    public void delete(int array[] ) {
        System.out.println("請輸入想要刪除的數字的位置：");
        Scanner scan = new Scanner(System.in);
        int mes = scan.nextInt();
        int pos=mes;
       // int pos1=mes;
        for (int i = 0; i < size(); i++) {
            temp[i] = array[mes];
            mes++;
        }
        for (int i =0;i<size();i++){
            array[pos-1]=temp[i];
            pos++;
        }
        nwangwenbin--;
    }
    public boolean iEmpty(){
        if (array[0]==0){
            return true;
        }
        else {
            return false;
        }
    }

    public String print(int array[]){
        String result="";
        for (int i =0;i<size();i++){
            result+=array[i]+" ";
        }
        return result;
    }

• 代碼結果截圖
  

第五個實驗

• 過程：第五個實驗旨在用數組實現選擇排序，由於以前就已經瞭解過選擇排序，在這裏不作詳細的講解。

• 具體代碼實現

public void selectsorting(int[] array){
        for(int i = 0; i < size() - 1; i++) {
            int k = i;
            for(int j = k + 1; j < size(); j++){
                if(array[j] < array[k]){
                    k = j;
                }
            }

            if(i != k){
                int temp = array[i];
                array[i] = array[k];
                array[k] = temp;
            }
            System.out.print("第" + (i + 1) + "輪排序後：");
            for (int ii = 0; ii < size(); ii++) {
                System.out.print(array[ii] + " ");
            }
            System.out.println("當前數字串的總數爲："+nwangwenbin);

            System.out.print("\n");


        }

• 具體實現截圖
  

3. 實驗過程當中遇到的問題和解決過程

• 問題1：在Java文件讀出的時候，爲何與掃出來的數字不一樣？

• 問題1解決方法：
  （1）由於從文件讀出的屬於字節流，讀出來的是字節型的，因此咱們須要用Stringvalueof語句將其進行轉義爲字符串格式，再根據其咱們所須要的格式進行改寫。

• 問題2：在實現排序過程當中每一次要輸出該輪的隊列或者數組的所有，在實現這一階段的時候，我發現我知道在哪裏輸出，可是在第一次進行輸出的時候要麼只會輸出一輪，要麼在輸出的時候就直接成爲了一次死循環。
• 問題2解決方案：在進行選擇輸出每一輪事後的那個隊列或者數組的所有內容的時候，在外循環的內部進行相似於輸出方法（print方法)的一個過程，以下關鍵代碼：

while (node != null) {
                System.out.print(node.number+" ");
                node = node.next;
            }
            System.out.println("該一輪的元素數量爲："+(nWangwenbin-1));

經過這樣一段輸出，就能夠將其在每一輪進行輸出。

• 問題3：在進行實驗三的代碼編寫的過程當中，由於自己就要涉及到用數組進行排序，因此我一開始的想法就是直接將鍵入的一段字符串用空格進行分割再將其分爲一個字符串數組，可是在這個過程當中，我發現一個問題，由於假如僅僅經過這樣的方式將字符串就保存在這一個數組中，其實咱們要求中需必須的nwangwenbin的那個變量的做用也就沒有了，簡單來說，就是其實每個數字並非真正的進入數組，因此，我就不得不另外想一種方法使得它進入數組，使得nwangwenbin進行累加，（ps：這個nwangwenbin變量的大小還涉及着不少方面的因素，由於在輸出之類的一些方法中，就是靠size方法進行的，因此這個變量很是重要）
• 問題3解決方法：言歸正傳，因此，我就仿照鏈表的作法，繼續寫了一個尾插的方法，用一個循環將一開始用split語句分開的數組進行真正意義上的進入。以下代碼：

public void add(int array[],int a){
        if (array[0]==0){
            array[0]=a;
        }
        else {
            int i =0;
            while (array[i]!=0){
                i++;
            }
            array[i]=a;
        }
        nwangwenbin++;
}

經過這樣一段，就能夠再用下面的這段掃進實現nwangwenbin的累加：

for (int i =0;i<c.length;i++){
            a.add(b,Integer.parseInt(c[i]));
        }

經過這樣的一段就能夠解決咱們的問題。

4.感想

作這個實驗的時候，由於本身在以前就已經有編寫相關代碼的過程，因此在編寫這五個代碼的過程當中，本身的自主性獲得了提高，再也不想上學期同樣，一旦不會就去看別人的代碼，我以爲本身與上學期相比，有所進步。

5.參考文獻

Java中的經典算法之冒泡排序(Bubble Sort)
各類排序的動圖.gif