数据结构学习之路一

本狗再学习大数据之余同时还在学习数据结构，今天开始就记录一下数据结构的学习过程。

先从栈和队列入手，语言选择Java，以后有时间本狗会更新python版本的，毕竟python更简洁。

栈：就不从书上的定义开始扯了，毕竟学习计算机的都有一本或者多本数据结构书的，用大白话来说，栈就是先进来的后出去，后进来的先出去，想象一下手枪的子弹，是不是最先放入弹夹的最后才发射出去，这样来理解栈是不是相对来说好一点。

这里分享一下以前学习栈这里遇见的一道题，当时可是把我的狗脑子给难住了。

a,b,c三个元素有多少种出栈可能。

答案是五种，可惜当时脑子就是转不过来，现在看来，当时真是狗脑子啊。

a,b,c依次进入再出来 c,b,a（三种）

a,b进b出，c进c出 b,c,a（一种）

a进b进，b出a出，c进c出 b,a,c（一种）

显然，五种出栈可能。

接下来，是栈的抽象数据类型（ADT)

因为使用Java来实现，那就直接定义函数来实现，在构造函数里面进行初始化。

package dataStructs;

public class myStack {
    //定义栈顶
    private int top;
    //栈的底层是数组
    private long arr[];
    //定义无参的构造方法
    public myStack(){
        arr = new long[10];
        top = -1;
    }
    //定义有参的构造方法
    public myStack(int maxsize){
        arr = new long[maxsize];
        top = -1;
    }
    //添加数据
    public void insert(int value){
       arr[++top] = value;
    }
    //删除数据
    public long remove(){
        return arr[top--];
    }
    //查看数据
    public long peek(){
        return arr[top];
    }
    //判断是否为空
    public boolean isEmpty(){
        return top == -1;
    }
    //判断是否满
    public boolean isFull(){
        return top == arr.length;
    }
}

在测试类中进行测试

package dataStructs;

public class TestMyStack {
    public static void main(String[] args){
        myStack ms = new myStack(10);
        ms.insert(12);
        ms.insert(72);
        ms.insert(52);
        ms.insert(1);
        System.out.println(ms.isEmpty());
        System.out.println(ms.isFull());

        System.out.println(ms.peek());
        System.out.println(ms.peek());

        while (!ms.isEmpty()){
            System.out.println(ms.remove()+",");
        }
        System.out.println(ms.isFull());
        System.out.println(ms.isEmpty());
    }
}

最后，输出结果为

false
false
1
1
1,
52,
72,
12,
false
true

关于栈就到这里。

队列，和栈一样，底层是一个数组，不过队列是先进先出的，类似在火车站买票，开头最前面的一个人买到票就会出去，从对头走出队列，又来一个人，就只能从队尾进入队列，这就是队列的实质。

接下来看看队列的代码

package dataStructs;

public class myQuene {
    //队列的底层是数组
    private long arr[];
    //定义存放数据量
    private int elements;
    //定义队列头
    private int front;
    //定义队列尾
    private int tail;
    //定义无参的构造函数
    public myQuene(){
        //初始化
        arr = new long [10];
        elements = 0;
        front = 0;
        tail = -1;
    }
    //定义有参的构造函数
    public myQuene(int maxsize){
        arr = new long [maxsize];
        elements = 0;
        front = 0;
        tail = -1;
    }
    //添加数据
    public void insert(long value){
        //判断是否已经满了
        if (tail == arr.length-1){
            tail=-1;
        }
        arr[++tail] = value;
        elements++;
    }
    //删除数据
    public long remove(){
        long value = arr[front++];
        if ( front == arr.length){
            front = 0;
        }
        elements--;
        return value;
    }
    //查看数据，从队头查看

    public long peek() {
        return arr[front];
    }

     //判断是否为空

    public boolean isEmpty() {
        return elements == 0;
    }


     // 判断是否满了

    public boolean isFull() {
        return elements == arr.length;
    }

}

测试：

package dataStructs;

public class TestMyQuene {
    public static void main(String[] args){
        myQuene mq = new myQuene(4);
        mq.insert(23);
        mq.insert(45);
        mq.insert(13);
        mq.insert(1);

        System.out.println(mq.isFull());
        System.out.println(mq.isEmpty());

        System.out.println(mq.peek());
        System.out.println(mq.peek());

        while (!mq.isEmpty()) {
            System.out.print(mq.remove() + " ");
        }
        System.out.println();

        mq.insert(23);
        mq.insert(45);
        mq.insert(13);
        mq.insert(1);

        while (!mq.isEmpty()) {
            System.out.print(mq.remove() + " ");
        }
    }
}

结果为：

true
false
23
23
23 45 13 1
23 45 13 1

至此，本狗对于栈和队列的粗浅理解到此结束。

数据结构学习之路一

猜你喜欢