2018-2019-20172329 《Java软件结构与数据结构》第二周学习总结

时间 2019-12-07

原文原文链接

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
```
错题解析：由于对于题目位置的不肯定性，没有看出本来题目的意思。

结对及互评
本周结对学习状况
- 20172316赵乾宸
博客中值得学习的或问题：
- 内容详略得当；
- 代码调试环节比较详细；
基于评分标准，我给本博客打分：5分。得分状况以下：

正确使用Markdown语法（加1分）：
模板中的要素齐全（加1分）
教材学习中的问题和解决过程, 一个问题加1分
代码调试中的问题和解决过程, 一个问题加1分
- 20172316唐才铭

博客中值得学习的或问题：
- 内容详略得当；
- 代码调试环节比较详细；
基于评分标准，我给本博客打分：9分。得分状况以下：

正确使用Markdown语法（加1分）：
模板中的要素齐全（加1分）
教材学习中的问题和解决过程, 一个问题加1分
代码调试中的问题和解决过程, 一个问题加1分

感悟

这一周Java课程学习了新知识，也温习了旧的一些功课，由于对于知识的掌握程度一开始的了解程度不是很好，因此就花了很长的时间去理解知识点，知识点的理解对于书本内容的吃透仍是很重要，这一学期的任务相比于上学期的任务只能讲熟练程度，由于不少也都是以前写过的代码，所以但愿本身新的一学期能够本身加油，努力！唉，又是一波鸡汤！！

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	0/0	1/1	6/6
第二周	1313/1313	1/2	20/26

参考资料

蓝墨云班课
 Java程序设计
 java:链表排序
 [数据结构]java实现的简单链表的头/尾插法
 玩转数据结构（五）数组栈和链表栈性能对比

2018-2019-20172329 《Java软件结构与数据结构》第二周学习总结

2018-2019-20172329 《Java软件结构与数据结构》第二周学习总结

教材学习内容总结

《Java软件结构与数据结构》第三章 集合概述——栈

《Java软件结构与数据结构》第四章 链式结构——栈

教材学习中的问题和解决过程

代码调试中的问题和解决过程

码云连接

上周考试错题总结

结对及互评

感悟

学习进度条

参考资料

《Java软件结构与数据结构》第三章集合概述——栈

《Java软件结构与数据结构》第四章链式结构——栈