Java 用堆栈实现斐波那契数列//散列映射//死锁的基本概念

堆栈

堆栈是一种"后进先出"的数据结构,只能只能在一端进行输出或输出数据的操作
向堆栈中输入数据称为"压栈",从堆栈中输出数据称为"弹栈"

可以使用Stack泛型类创建一个堆栈对象

Stack<E>stack = new Stack<E>();

堆栈对象的方法

• public E push(E item) //实现压栈操作
• public E pop() //实现弹栈操作
• public boolean empty() //判断堆栈是否还有数据
• public E peek() //获取堆栈顶端的数据,但不删除
• public int search(Object data) //获取数据在堆栈中的位置,最顶端的位置是1,依次往下增加,没有就返回-1

使用堆栈可以节省内存的开销,例如递归是一种很消耗内存的算法,可以借助堆栈消除大部分递归,达到和递归算法同样的目的

使用堆栈实现斐波那契数列 //好好理解

import java.util.Stack;

public class Example13_6 {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(1);  //压栈
        stack.push(1);
        int k = 1;
        while(k < 11){
            for (int i = 0; i <= 2 ; i++) {
                int f1 = stack.pop();   //弹栈
                int f2 = stack.pop();   //弹栈
                int next = f1+f2;
                System.out.print(" " + next);
                stack.push(next);
                stack.push(f2); //后进先出
                k++;
            }
        }
    }
}

运行结果

D:\HelloWorld\out\production\HelloJava Chapter_13.Part_3.Example13_6
 2 3 5 8 13 21 34 55 89 144 233 377
进程已结束，退出代码 0

散列映射

HashMap<K,V>泛型类

HashMap<K,V>对象采用散列表这种数据结构存储数据,习惯上称HashMap<K,V>对象为散列映射
散列映射用于存储"键/值对",允许把任何数量的键值对存储在一起
对于数组表和链表两种数据结构,如果要查找他们存储的某个特定元素却不知道位置,则需要从头开始访问元素直到找到匹配位置,这时可以使用散列映射来存储要查找的数据,可以减少检索的开销

创建散列映射

HashMap<String,Student> hashMap = new HashMap<String,Student>()

HashMa<K,V>泛型类常用方法

• public void clear() //清空散列映射
• public Object clone() //返回当前散列映射的一个克隆
• public boolean containsKey(Obeject Key) //是否含有所指的键
• public boolean containsValue(Object Value) //是否含有所指的值
• public V get(Object key) //返回散列映射使用Key作为键的值
• public boolean isEmpty() //散射列表是否含有键值对
• public V remove(Object key) //删除散列映射中指定的键值对,并返回键对应的值
• public int size() //返回散射列表的大小
• public V put(K key,V value) //添加键值对

遍历散列映射

利用 public Collectionvalues()方法返回一个实现Collection接口类创建的对象,可以使用接口回调技术,

Collection<BOOK>  collection = hashMap.values();
Iterator<BOOK> iterator = collection.iterator();

基于散列映射查询的例子

import javax.swing.*;
import java.awt.*;

public class myWindow extends JFrame {
    JTextField input,show;
    myListener myListener;
    myWindow(){
        setTitle("英-汉小词典");
        setLayout(new FlowLayout());
        setBounds(300,300,400,400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container con = this.getContentPane();
        con.setBackground(new Color(0xBE879B)); //设置背景颜色
        setVisible(true);
        input = new JTextField(10);
        myListener = new myListener();
        myListener.setMyWindow(this);
        input.addActionListener(myListener);
        add(input);
        show = new JTextField(10);
        show.setEditable(false);
        add(show);
        validate();
    }
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.HashMap;
import java.util.Scanner;

public class myListener implements ActionListener {
    File file = new File("C:\\Users\\Administrator\\Desktop", "小词典数据.txt");
    Scanner scanner;
    myWindow myWindow;
    HashMap<String, String> myHash;

    public void setMyWindow(Chapter_13.Part_3.myWindow myWindow) {
        this.myWindow = myWindow;
    }

    myListener() {
        try {
            myHash = new HashMap<String, String>();
            scanner = new Scanner(file);
            while (scanner.hasNext()) {
                String English = scanner.next();
                String Chinese = scanner.next();
                myHash.put(English, Chinese);
            }
        } catch (Exception E) {

        }

    }

    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        if (myHash.containsKey(myWindow.input.getText())) { //查看是否拥有该键
            myWindow.show.setText(myHash.get(myWindow.input.getText()));
        } else {
            myWindow.show.setText("没有此单词");
        }

    }
}

public class Example13_7 {
    public static void main(String[] args) {
        myWindow myWindow = new myWindow();
    }
}

运行结果

死锁的基本概念

当若干个进程竞争使用资源时,可能每个进程要求的资源都已被另一进程占用,于是也就没有一进程继续运行,这种情况称为死锁

产生死锁的四个必要条件

• 互斥 //进程互斥使用资源
• 不可剥夺 //资源未使用完成时不能被其他进程强行剥夺
• 请求保持 //申请新的资源时继续保持占用已分配的资源
• 循环等待 //

解决死锁的方法

• 死锁的预防 //根据4个必要条件,使其中之一不能成立
• 死锁的避免 //银行家算法
• 死锁的检测
• 死锁的解除 //采用资源剥夺法和撤销进程法解除死锁

CET4P183

• calculate
• confess
• virtually
• virtual
• draught
• meantime
• appointment
• perspective
• laundry
• violin
• violet
• appearance
• murder