2018-2019-20172329 《Java軟件結構與數據結構》第二週學習總結

時間  2019-12-07
標籤 Java軟件結構與數據結構 第二 學習 總結 欄目 Java 简体版
原文   原文鏈接

2018-2019-20172329 《Java軟件結構與數據結構》第二週學習總結

教材學習內容總結

《Java軟件結構與數據結構》第三章 集合概述——棧

1、集合
一、咱們印象中的集合應該最大致如今數學學習中，在高一剛剛入學的時候就已經學習了集合是什麼，映射是什麼，綜合學習數學以及Java的的經驗，顧名思義，其實集合就是一些元素的總和，而這些元素能夠是一些數字，或者一些類，反正是咱們自身在編程的時候所須要的東西。
二、集合能夠分爲兩大類：包括線性集合和非線性集合。從字面上就能夠理解這兩種集合的區別，線性與非線性的區別，可是所謂的線性所表現出的是什麼呢，這就是咱們要深刻了解的地方。php

  • （1）線性集合舉個例子，就像是小朋友排成一列，咱們能夠直接的選擇咱們須要誰，其優點就是內容簡單，咱們在提取數據或者元素的時候快速方便；
  • （2）而非線性集合呢，則是像是一個拓展圖，它比較詳細的展現了其每個裏面全部的元素，其優點在於它比較能夠快速的尋找到咱們所須要的元素，展現的時候比較詳細，清晰，可是在提取的時候，我認爲它可能並無線性集合那樣快。

三、抽象：如何去理解這個抽象，在我看來，它無非就是構成一個事物必不可少的東西，可是咱們能夠經過一些步驟或者工具去簡化（或忽略）一些細節，使得咱們本身能夠去控制這個事物達到這個事物的最大效能，或者是完成這個事物應當作的任務。綜合來說，就是能夠經過一些方法將一個複雜的事物簡單化之後變得更加容易控制的東西。
四、強調的一點是：集合也是一種抽象。
五、抽象數據類型（Abstract Date Type，ADT）：是一種在程序設計語言中還沒有定義其值和操做的數據類型。ADT的抽象性體如今，ADT必須對其實現細節進行定義，且這些對用戶是不可見的。
六、數據結構：是一種用於實現集合的編程結構集。
七、集合是一種隱藏了實現細節的抽象。
八、Java集合API是一個類集，表示了一些特定類型的集合，這些類的實現方式各不相同。html

2、棧集合
一、棧的元素是按後進先出（LIFO）的方法進行處理的，最後進入棧中的元素最早被移除。
二、編程人員選擇的數據結構，應與須要進行數據管理的類型相適應。
三、棧的一些操做方法：java

操做 描述
push 添加一個元素到棧的頂部
pop 從棧的頂部移出一個元素
peek 查看棧頂部的元素
isempty 肯定棧是否爲空
size 肯定棧的元素數目

3、主要的面向對象概念
一、繼承性與多態：node

  • （1）多態引用是一個引用變量，它能夠在不一樣地點引用不一樣類型的對象。
  • （2）繼承能夠用於建立一個類層次，其中，一個引用變量可用於指向與之相關的任意對象。
    二、泛型
  • （1）什麼叫作泛型呢？
  • 解答：就是咱們能夠定義一個類，以便他能儲存、操做和管理在實例化以前沒有指定是何種類型的對象。
  • （2）爲何要用泛型呢？
  • 解答：使用泛型能夠來建立可用於安全且高效地儲存任意類型的對象的集合。

4、異常
一、錯誤和異常表示不正常或不合法的處理。android

5、棧ADT
一、Java接口定義了一個抽象方法集，有助於把抽象數據類型的概念與其實現分隔開來。
二、經過使用接口名做爲返回類型，方法就不會侷限於實現棧的任何特定類。git

6、用數組實現棧web

代碼：編程

import java.util.Arrays;
import java.util.EmptyStackException;

public class ArrayStack<T> implements StackADT<T> {
    private final int DEFAULT_CAPACITY = 100;
    private int top;
    private T[] stack;
    public ArrayStack(){
        top = 0;
        stack = (T[]) (new Object[DEFAULT_CAPACITY]);
    }

//    public ArrayStack(int initialCapacity){
//        top = 0;
//        stack = (T[]) (new Object[initialCapacity]);
//    }
    @Override
    public void  push(T element){
        if(size()==stack.length)
            expandCapacity();
        stack[top] = element;
        top++;
    }
    private void expandCapacity(){
        stack= Arrays.copyOf(stack,stack.length*2);
    }
    @Override
    public int size(){
        int b=0;
        for(int a = 0; stack[a] != null;a++)
        {
           b++;
        }

        return b;
    }
    @Override
    public T pop() throws EmptyCollectionException
    {
        if (isEmpty())
            throw new EmptyCollectionException("Stack");
        top--;
        T result = stack[top];
        stack[top] = null;

        return result;
    }
    @Override
    public T peek() throws EmptyStackException
    {
        if (isEmpty())
            throw new  EmptyCollectionException("Stack");

        return stack[top-1];
    }
@Override
public boolean isEmpty(){
        boolean p ;
        if (stack[0]!=null){
            p=false;
        }
        else
        {
            p=true;
        }
    return p;
}

@Override
public String toString(){
        String result = "";
        for(int a = 0; a<size();a++){
            result += String.valueOf(stack[a] +" ");
        }
    return result;
}

}

《Java軟件結構與數據結構》第四章 鏈式結構——棧

1、連接做爲引用
一、對象引用變量能夠用來建立鏈式結構。
二、鏈表由一些對象構成，其中每一個對象指向了鏈表中的下一對象。
三、在鏈表中儲存的對象一般泛稱爲鏈表的結點。
四、鏈表會按需動態增加，所以在本質上，它沒有容量限制。
2、管理鏈表
一、插入結點：改變引用順序是維護鏈表的關鍵。
數組

二、刪除結點：處理鏈表的首結點須要進行一些特殊處理。
安全

3、無連接的元素
一、儲存在集合中的對象不該該含有基本數據結構的任何實現細節。
二、雙向鏈表：在雙向鏈表中，須要維護兩個引用：一個引用指向鏈表的首結點；另外一個引用指向鏈表的末端點。鏈表的每一個結點都存在兩個引用：一個指向下一個元素，另外一個指向上一個元素。

4、用鏈表實現棧
一、只要有效地實現了恰當的操做，集合的實現均可用來求解問題。

package chapter4.pp4_2;

public class LindedStack<T> implements StackADT<T> {
    private int count;
    private LinnearNode<T> top;
    public LindedStack(){
    count=0;
    top=null;
    }

    @Override
    public void push(T element) {
        LinnearNode<T> temp=new LinnearNode<T>(element);

        temp.setNext(top);
        top = temp;
        count++;
    }

    @Override
    public T pop() throws EmptyCollectionException {

        if (isEmpty())
            throw new EmptyCollectionException("Stack");

        T result = top.getElement();
        top=top.getNext();
        count--;

        return result;
    }

    @Override
    public T peek() {

        if (isEmpty())
            throw new EmptyCollectionException("Stack");
        T result = top.getElement();
        top=top.getNext();

        return result;
    }

    @Override
    public boolean isEmpty() {

        boolean p ;
        if (size()==0){
            p=true;
        }
        else
        {
            p=false;
        }
        return p;
    }

    @Override
    public int size() {

        return count;
    }
    @Override
    public String toString(){
        LinnearNode node = new LinnearNode();
  ![](https://img2018.cnblogs.com/blog/1333084/201809/1333084-20180918154501879-1136225221.png)

      while (node != null) {
            System.out.print(node.getElement()+" ");
            node = node.getNext();
        }

        return node.getElement().toString();
    }
}

教材學習中的問題和解決過程

  • 問題1：看到了教材中對於雙向鏈條的提起，就很好奇它是如何進行建立和運轉的：
  • 問題1解決方法：
    首先了解一個方法不如和學習單鏈表同樣的方法，從圖解來入手：

這就是具體的過程，也讓我本身瞭解到雙鏈表的神奇。

代碼調試中的問題和解決過程

  • 問題1：用數組實現棧和用鏈表實現棧的區別以及效率
  • 問題1解決方法：使用代碼對比咱們本身實現的棧的性能差別：
private static double testStack(Stack<Integer> s, int opCnt) {
        long startTime = System.nanoTime();
 
        for (int i = 0; i < opCnt; i++) {
            s.push(i);
        }
 
        for (int i = 0; i < opCnt; i++) {
            s.pop();
        }
 
        long endTime = System.nanoTime();
 
        return (endTime - startTime) / 1000000000.0;
    }

上面的代碼實現：對棧進行opCnt次入棧和出棧操做，記錄所消耗的時間。(注：nonoTime的單位是ns，將結果轉換爲s，除以10的9次方)

首先將opCnt設置爲10 0000 來看看性能差別：

public static void main(String[] args) {
        ArrayStack<Integer> arrayStack = new ArrayStack<Integer>();
        LinkedStack<Integer> linkedStack = new LinkedStack<Integer>();
        int opCnt = 100000;
        double time1 = testStack(arrayStack, opCnt);
        double time2 = testStack(linkedStack, opCnt);
        System.out.println("arrayStack:" + time1 + "s");
        System.out.println("linkedStack:" + time2 + "s");
 
    }

將opCnt設置爲100 0000：
結果：

arrayStack:0.020232116s
linkedStack:0.016551687s

將opCnt設置爲1000 0000：

arrayStack:3.780388172s
linkedStack:9.333468302s

總結：

基於數組的棧是在數組尾部進行入棧和出棧操做，所以實現複雜度爲O（1）；

基於鏈表的棧是在鏈表頭部進行入棧和出棧操做，所以實現複雜度也爲O（1）；

所以二者的性能不會差不少，在opCnt=1000 0000時，arrayStack的性能比linkedStack性能要好。緣由是linkedStack要進行大量的new操做，在opCnt較小的狀況下，體現不出性能差別；而在操做次數大時，arrayStack性能優點就體現出來了。

碼雲連接

由於個人as傳不到碼雲上面因此在這裏給出個人Java代碼和運行結果：

package com.example.pp3_9;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import java.util.Stack;

public class MainActivity extends AppCompatActivity {
    LinkedlistStack stack=new LinkedlistStack();
    private  String result="";
    int time=0;
    String re="";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button1=(Button)findViewById(R.id.button);
        button1.setOnClickListener(new mybuttoninsert1());
        Button button2=(Button)findViewById(R.id.button2);
        button2.setOnClickListener(new mybuttoninsert2());
    }

    public class mybuttoninsert1 implements View.OnClickListener {
        @Override
        public void onClick(View view) {

            EditText a =(EditText) findViewById(R.id.editText3);
            String[] aa = a.getText().toString().split("");
            EditText b =(EditText)findViewById(R.id.editText);
            stack.push(aa[time]);
            time++;
                String result="";
               for (int i =0;i<a.getText().length()-time;i++){
                   result+=aa[i+1];
                   //result+=aa[a.getText().length()-time];
               }
               b.setText(result);

        }
    }
    public class mybuttoninsert2 implements View.OnClickListener {
        @Override
        public void onClick(View view) {
            EditText c =(EditText)findViewById(R.id.editText2);
           // c.setText(stack.pop().toString());

           re+=stack.pop();

          c.setText(re);
        }
    }
}


上週考試錯題總結

  • 錯題1.An efficient system handles problems gracefully
    A .True
    B .False

    正確答案： B  個人答案： A

  • 錯題解析：由於在書裏有這樣一句話：「一個健壯的系統能夠完美地處理各類問題。」被這句話給誤導了。

  • 錯題2.Which of the following has the smallest time complexity?
    A .3n+5+2n
    B .logn+2
    C .3n+4
    D .nlogn

    正確答案： B  個人答案： D

  • 錯題解析：由於對於題目位置的不肯定性，沒有看出本來題目的意思。

    結對及互評

  • 本週結對學習狀況
  • 博客中值得學習的或問題：
    • 內容詳略得當；
    • 代碼調試環節比較詳細；
  • 基於評分標準，我給本博客打分：5分。得分狀況以下：
  1. 正確使用Markdown語法（加1分）：
  2. 模板中的要素齊全（加1分）
  3. 教材學習中的問題和解決過程, 一個問題加1分

  4. 代碼調試中的問題和解決過程, 一個問題加1分

  • 博客中值得學習的或問題：
    • 內容詳略得當；
    • 代碼調試環節比較詳細；
  • 基於評分標準，我給本博客打分：9分。得分狀況以下：
  1. 正確使用Markdown語法（加1分）：
  2. 模板中的要素齊全（加1分）
  3. 教材學習中的問題和解決過程, 一個問題加1分
  4. 代碼調試中的問題和解決過程, 一個問題加1分

感悟

這一週Java課程學習了新知識，也溫習了舊的一些功課，由於對於知識的掌握程度一開始的瞭解程度不是很好，因此就花了很長的時間去理解知識點，知識點的理解對於書本內容的吃透仍是很重要，這一學期的任務相比於上學期的任務只能講熟練程度，由於不少也都是以前寫過的代碼，所以但願本身新的一學期能夠本身加油，努力！唉，又是一波雞湯！！

學習進度條

代碼行數（新增/累積） 博客量（新增/累積） 學習時間（新增/累積）
目標 5000行 30篇 400小時
第一週 0/0 1/1 6/6
第二週 1313/1313 1/2 20/26

參考資料

藍墨雲班課
Java程序設計
java:鏈表排序
[數據結構]java實現的簡單鏈表的 頭/尾插法
玩轉數據結構（五）數組棧和鏈表棧性能對比

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程