java实现顺序表，链表，栈，队列_数据结构与算法

书目是科大本科数据结构教材。涉及代码部分准备使用JAVA实现。

绪论

1.数据元素，数据元素之间的逻辑关系，逻辑关系在计算机中的存储表示，适用的操作->数据结构

2.逻辑结构：集合，线性，树状，图

存储结构：顺序存储，链式存储，散列存储

3.o(1)<o(log2(n)）<o(n)<o(nlog2(n))<o(n(2))<o(n(3))<o(2(n))

线性表

1.线性表： n个具有相同类型的数据元素的有限序列

2.顺序表：一组地址连续的存储单元存储线性表 ->数组

查找：按位置->随机存取特性 o(1) ，按值 ->o(n)

插入删除： o(n)

package java_practice;


import java.util.Arrays;

/**Java中，可以使用
 * 数组:单种类对象或基本类型，指定大小（更符合书上顺序表定义）
 * ArrayList集合:多种类对象类型，动态大小
 * 来作为顺序表
 * 在此暂不考虑ArrayList等Java是如何实现的，只给出用法
*/
public class HelloWorld{
    public static void main(String[] args){
        /*数组*/
        MyArray my = new MyArray(6);
        my.insert(1,2);
        my.insert(0,3);
        my.delete(1);
        System.out.println(my.search_k(1));
        System.out.println(my.search_v(3));

    }
}

class MyArray{
    private int[] i;
    private int len = 5;
    MyArray(int len){
        this.len = len;
        //创建及初始化
        this.i =new int[this.len];
    }

    //查找
    public int search_v(int value){
        for (int x = 0;x<this.i.length;x++) {
            if (this.i[x] == value) {
                return x;
            }
        }
        return -1;
    }
    public int search_k(int key){
        return this.i[key];
    }

    //删除
    public void delete(int key){
        for(int x=key+1;x<this.i.length;x++){
            this.i[x-1] = this.i[x];
        }
        this.i[this.i.length-1] = 0;
        print();
    }

    //插入
    public void insert(int key,int value){
        for (int x=key;x<this.i.length;x++){
            int temp = this.i[x];
            this.i[x] = value;
            value = temp;
        }
        print();
    }

    //销毁
    public void destroy(){
        this.i = null;
        print();
    }

    //清空
    public void  clear(){
        this.i = new int[this.len];
        print();
    }

    //判空操作由于现在使用的是int数组只能判定是否为0，如果是对象类型数组则判断是否所有位置均为null
    //前驱后续均为基础数组操作，获调用search_k即可
    //打印
    public void print(){
        System.out.println(Arrays.toString(this.i));
    }
}

public class HelloWorld{
    public static void main(String[] args){
        /*ArrayList*/

        MyArrayList<Integer> mai = new MyArrayList<>();
        mai.create(6,6,8,9);
        mai.print();
        mai.insert(1,3);
        mai.get_k(1);
        mai.get_v(19);
        mai.delete(2);
    }
}

class MyArrayList<E>{
    private ArrayList<E> ai = null;

    //初始化后才可使用insert及set ArrayList是变容量的
    public void create(int capacity,E el1,E el2,E el3){
        this.ai = new ArrayList<E>(capacity);
        this.ai.add(el1);
        this.ai.add(el2);
        this.ai.add(el3);
    }

    //ArrayList 自带插入方法
    public void insert(int key,E value){
        this.ai.add(key,value);
        print();
    }
    //自带方法
    public void get_v(E element){
        System.out.println(this.ai.contains(element));
    }
    public void get_k(int k){
        E el = this.ai.get(k);
        System.out.println(el.toString());
    }
    //自带方法
    public void delete(int k){
        E el = this.ai.remove(k);
        print();
    }

    //清空，判空均为自带方法

    public void print(){
        System.out.println(this.ai.toString());
    }
}

3.链表：一组任意的存储单元存储线性表

查找：顺序存取按位置，按值->o(n)

插入，删除：o(n) 减少了数据移动

循环单链表：环，可以从表中任意节点开始遍历整个链表

双向链表：每个节点有两个指针域，指向前一个及后一个节点

静态链表：采用数组模拟链表的指针

import java.util.LinkedList;

/**Java中，可以使用
 * 自定义节点类型及操作
 * LinkedList
 * 来作为链表
 * 在此暂不考虑Java是如何实现的，只给出用法
*/
public class HelloWorld{
    public static void main(String[] args){
        LinkedList<Integer> exp1 = new LinkedList<>();
        //插入
        exp1.add(0,1);
        exp1.add(0,10);
        System.out.println(exp1.toString());
        //查找
        System.out.println(exp1.get(1));
        System.out.println(exp1.indexOf(10));
        //删除
        exp1.remove(1);
        System.out.println(exp1.toString());
        //长度
        System.out.println(exp1.size());
    }
}

import java.util.LinkedList;
//大部分条件判断都没做，为了容错，应该加上对角标的判断
public class HelloWorld{
    public static void main(String[] args){
//       
        MyLinkList my = new MyLinkList();
        my.add(10);
        my.add(1);
        my.add(20);
//        my.print();
//        System.out.println(my.length());
//        my.getbyindex(1);
//        my.getbyindex(0);
//        my.insert(0,20);
        my.delete(1);
    }
}

class MyLinkList{
    //头结点
    private Node head;
    //指针
    private Node where;

    class Node{
        //数据域
        int data;
        //指针域
        Node next;

        public Node(int init){
            this.data = init;
            next = null;
        }
    }

    //初始化
    MyLinkList(){
        this.head = new Node(-1);
        this.where = this.head;
    }

    //添加
    public void add(int e){
        Node ne = new Node(e);
        this.where.next = ne;
        this.where = ne;
    }

    //查询
    public Node getbyindex(int index){
        int i = -1;
        Node in = this.head;
        while (i<index){
            in = in.next;
            i++;
        }

        return in;
    }

    //插入
    public void insert(int index, int data){
        Node now = new Node(data);
        Node pre = getbyindex(index-1);
        Node net = getbyindex(index);
//        System.out.print(net.data);
        pre.next = now;
        now.next = net;
        print();
    }

    public void delete(int index){
        Node pre = getbyindex(index-1);
        Node net = getbyindex(index+1);
        pre.next = net;
        print();
    }

    //长度
    public int length(){
//        System.out.print("sad");
        Node temp = this.head;
        int lenth = 0;
        while (temp.next != null){
//            System.out.print(lenth);
            lenth = lenth+1;
            temp = temp.next;
        }
//        System.out.print(lenth);
        return lenth;
    }

    public void print(){
        Node temp = this.head;
        while (temp.next != null){
            System.out.println(temp.next.data);
            temp = temp.next;
        }
    }


}

4.栈：运算受限的线性表 First In Last Out 。也可以使用顺序表或链表进行实现

/**
 * for the test
 *
 * @auther:dan
 * @version:1.0
 * @date:2017.11.16
 */
package java_practice;

import java.util.LinkedList;

/**Java中，可以使用
 * 链表
 * 顺序表

 * stack类
 * 进行限定操作来模拟栈的操作
 */

public class HelloWorld{
    public static void main(String[] args){
        MyLinkList_stack my = new MyLinkList_stack();
        my.push(10);
        my.push(1);
        my.push(20);
        my.print();
        my.pop();
        my.print();

        my.pop();
        my.print();

        my.pop();
        my.print();

        my.pop();
        my.print();
    }
}

class MyLinkList_stack{

    //指针
    private Node top ;

    class Node{
        //数据域
        int data;
        //指针域
        Node next;

        public Node(int init){
            this.data = init;
            next = null;
        }
    }

    //初始化
    MyLinkList_stack(){
        this.top = null;
    }

    //入栈
    public void push(int e){
        Node ne = new Node(e);
        ne.next = this.top;
        this.top = ne;
    }

    //出栈
    public void pop(){
        if (this.top != null){
//            System.out.print(this.top.data);
            this.top = this.top.next;
        }else {
            System.out.print("null stack");
        }
    }


    public void print(){
        Node temp = this.top;
        while (temp != null){
            System.out.println(temp.data);
            temp = temp.next;
        }
    }
}

public class HelloWorld{
    public static void main(String[] args){
          MyArray_stack my = new MyArray_stack(5);
          my.push(10);
          my.push(1);
          my.push(20);
          my.print();

          my.pop();
          my.print();

          my.pop();
          my.print();

    }
}

class MyArray_stack{
    private int[] i;
    private int len = 5;
    private int top;
    MyArray_stack(int len){
        this.len = len;
        //创建及初始化
        this.i =new int[this.len];
        this.top = -1;
    }

    //入栈
    public void push(int e){
        if (this.top>this.len-1){
            System.out.print("full stack");
        }else {
            this.top = this.top + 1;
            this.i[this.top] = e;
        }
    }

    public void pop(){
        if (this.top<0){
            System.out.print("null stack");
        }else {
            this.i[this.top] = 0;
            this.top = this.top -1;
        }
    }
    public void print(){
        System.out.println(Arrays.toString(this.i));
    }
}

5.计算器的实现思路：后缀表达式，操作数入栈，读到操作符则取出两个操作数，结果入栈

6.队列：First In First Out。也可以使用顺序表或链表进行实现

优先队列：利用堆实现，每次返回的是优先级最高的任务（后续补充实现，Java中的实现是PriorityQueue）

import java.util.Arrays;
import java.util.LinkedList;

/**Java中，可以使用
 * 链表
 * 顺序表(为了防止假溢出，使用循环队列实现）
 * Queue类,Queue是一个接口，可以使用ArrayDeque->数组队列，LinkedList->链表队列
 * 进行限定操作来模拟队列的操作
 */

public class HelloWorld{
    public static void main(String[] args){
          MyArray_queue my = new MyArray_queue(5);
          my.push(10);
          my.push(1);
          my.push(20);
          my.print();

          my.pop();
          my.print();

          my.pop();
          my.print();
    }
}

class MyArray_queue{
    private int[] i;
    private int len = 5;
    private int front;
    private int rear;
    //循环队列判空或满的方法：1.设置count变量记录个数；2.另设一个标志用于区分；3.少用一个数据空间，(rear+1)%len == front
    private int count;

    MyArray_queue(int len){
        this.len = len;
        //创建及初始化
        this.i =new int[this.len];
        this.front = -1;
        this.rear = -1;
        this.count = 0;
    }

    //入队
    public void push(int e){
        if (this.count>=this.len){
            System.out.print("full queue");
        }else {
            this.rear = (this.rear+1)%this.len;
            this.i[rear] = e;
            this.count = this.count+1;
        }
    }

    public void pop(){
        if (this.count<=0){
            System.out.print("null queue");
        }else {
            this.i[this.front+1] = 0;
            this.front = (this.front+1)%this.len;
            this.count = this.count-1;
        }
    }

    public void print(){
        System.out.println(Arrays.toString(this.i));
    }
}

import java.util.Arrays;
import java.util.LinkedList;

/**Java中，可以使用
 * 链表
 * 顺序表(为了防止假溢出，使用循环队列实现）
 * Queue类
 * 进行限定操作来模拟队列的操作
 */

public class HelloWorld{
    public static void main(String[] args){
        MyLinkList_queue my = new MyLinkList_queue();
        my.push(10);
        my.push(1);
        my.push(20);
        my.print();
        my.pop();
        my.print();

    }
}

class MyLinkList_queue{

    //指针
    private Node front ;
    private Node rear;

    class Node{
        //数据域
        int data;
        //指针域
        Node next;

        public Node(int init){
            this.data = init;
            next = null;
        }
    }

    //初始化
    MyLinkList_queue(){
        this.front = null;
        this.rear = null;
    }

    //入队,只能在队尾入队（单链表决定的）
    public void push(int e){
        Node ne = new Node(e);
        ne.next = null;
        if (this.front == null){
            this.front = ne;
            this.rear = ne;
        }else {
            this.rear.next = ne;
            this.rear = ne;
        }

    }

    //出栈
    public void pop(){
        if (this.front != null){
//            System.out.print(this.front.data);
            this.front = this.front.next;
//            System.out.print(this.front.data);
        }else {
            System.out.print("null stack");
        }
    }


    public void print(){
        Node temp = this.front;
        while (temp != null){
            System.out.println(temp.data);
            temp = temp.next;
        }
    }


}

java实现顺序表，链表，栈，队列_数据结构与算法

猜你喜欢