java算法

于 2021-08-18 16:13:53 发布
阅读量194 收藏
点赞数
分类专栏： java 文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yfcjava/article/details/119782572
版权

目录

介绍java中jdk中的一些数据结构

Dijkstra 的双栈算术表达式求值算法

自定义栈

泛型栈：

泛型栈实现迭代器：

链表数据结构

泛型队列

排序

选择排序

插入排序（对元素部分有序的数组和小规模数组非常高效）

介绍java中jdk中的一些数据结构

Bag类(包)、Stack类(栈)、Queue类(队列)。

这些类中都含有一个无参数的构造函数、向集合中加入单个元素的方法、返回一个集合大小的方法、集合是否为空。

Bag不会记住元素加入的顺序并且没有删除元素的方法。stack和queue有删除元素的方法。

Dijkstra 的双栈算术表达式求值算法

        该算法使用的数据结构为栈，一个栈存储数字，另一个栈存储运算符。

算法思路：

  •  将操作数压入操作数栈；
  • 将运算符压入运算符栈；
  • 忽略左括号；
  • 在遇到右括号时，弹出一个运算符，弹出所需数量的操作数，并将运算符和操作数的运算结果压入操作数栈。
Stack<String> ops = new Stack<String>();
Stack<Double> vals = new Stack<Double>();
while (!StdIn.isEmpty())
{ // 读取字符，如果是运算符则压入栈
String s = StdIn.readString();
if (s.equals("(")) ;
else if (s.equals("+")) ops.push(s);
else if (s.equals("-")) ops.push(s);
else if (s.equals("*")) ops.push(s);
else if (s.equals("/")) ops.push(s);
else if (s.equals("sqrt")) ops.push(s);
else if (s.equals(")"))
{ // 如果字符为")"，弹出运算符和操作数，计算结果并压入栈
String op = ops.pop();
double v = vals.pop();
if (op.equals("+")) v = vals.pop() + v;
else if (op.equals("-")) v = vals.pop() - v;
else if (op.equals("*")) v = vals.pop() * v;
else if (op.equals("/")) v = vals.pop() / v;
else if (op.equals("sqrt")) v = Math.sqrt(v);
vals.push(v);
} // 如果字符既非运算符也不是括号，将它作为double 值压入栈
else vals.push(Double.parseDouble(s));
}
StdOut.println(vals.pop());

自定义栈

String栈：该栈只能装入String类型的字符串


class Custom_Stack{
    //字符串数组
    private String[] values;
    //该栈中元素数量
    private int size;
    //创建一个大小为max的空栈
    public Custom_Stack(int max){
        if(max<=0)max=1;
        values=new String[max];
    }
    //入栈
    public void push(String value){
        if (values.length==size) //栈的最大容量是与栈中元素数量相等
            System.out.println("Stack is full. Stack's max number is "+size);
        else values[size++]=value;
    }
    //出栈
    public String pop(){
        String value=null;
        if(size==0){
            value ="Stack is empty!";
        } else {
            value = values[--size];
            values[size]=null;//将出栈对象设置为null,让垃圾回收器回收
        }
        return value;
    }
    //返回该栈中元素数量
    public int getSize(){return size;}
}

泛型栈：

class Custom_Stack<type>{
    //字符串数组
    private type[] values;
    //该栈中元素数量
    private int size;
    //创建一个大小为max的空栈
    public Custom_Stack(int max){
        if(max<=0)max=1;
        values=(type[]) new Object[max];
    }
    //入栈
    public void push(type value){
        if (values.length==size) //栈的最大容量是与栈中元素数量相等
            resize(values.length*2);
        values[size++]=value;
    }
    //出栈
    public type pop(){
        type value=null;
        if(size==0){
            System.out.println("Stack is empty!");
            return value;
        } 
        value = values[--size];
        values[size]=null;//将出栈对象设置为null,让垃圾回收器回收

        if (size==values.length/4)
            resize(values.length/2);
        return value;
    }
    //返回该栈中元素数量
    public int getSize(){return size;}

    //重新调整栈的大小
    private void resize(int max){
        type[] tempValues=(type[])new Object[max];
        for(int i=0;i<max/2;i++)
            tempValues[i]=values[i];
        values=tempValues;
    }
}

泛型栈实现迭代器：


//Iterable接口是专门创建新的迭代器的
class Custom_Stack<type> implements Iterable<type> {
    //字符串数组
    private type[] values;
    //该栈中元素数量
    private int size;
    //创建一个大小为max的空栈
    public Custom_Stack(int max){
        if(max<=0)max=1;
        values=(type[]) new Object[max];
    }
    //入栈
    public void push(type value){
        if (values.length==size) //栈的最大容量是与栈中元素数量相等
            resize(values.length*2);
        values[size++]=value;
    }
    //出栈
    public type pop(){
        type value=null;
        if(size==0){
            System.out.println("Stack is empty!");
            return value;
        }
        value = values[--size];
        values[size]=null;//将出栈对象设置为null,让垃圾回收器回收

        if (size==values.length/4)
            resize(values.length/2);
        return value;
    }
    //返回该栈中元素数量
    public int getSize(){return size;}

    //重新调整栈的大小
    private void resize(int max){
        type[] tempValues=(type[])new Object[max];
        for(int i=0;i<max/2;i++)
            tempValues[i]=values[i];
        values=tempValues;
    }

    //Iterator接口是一个专门设计迭代器的
    private class ReverseStackIterator implements Iterator<type>{

        private int iteSize=size;

        @Override
        public boolean hasNext() {
            if(iteSize > 0)
                return true;
            else
                return false;
        }

        @Override
        public type next() {
            if(hasNext())
                return values[--iteSize];
            else
                return null;
        }
    }

    @Override
    public Iterator<type> iterator() {
        return new ReverseStackIterator();
    }
}


public class Main {
    public static void main(String[] args) {

        Custom_Stack<Integer> c=new Custom_Stack(1);
        c.push(1);
        c.push(2);
        c.push(3);
        c.push(4);
        c.push(5);
        c.push(6);
        c.push(7);
        c.push(8);

//    普通遍历->真出栈
//        for (int i = 0,j=c.getSize(); i < j; i++)
//            System.out.println(c.pop());

//    迭代器遍历->假出栈
        Iterator<Integer> iterator = c.iterator();
        while (iterator.hasNext())
            System.out.println(iterator.next());

    }
}

链表数据结构

泛型栈实现的基础为非java直接支持的链表数据结构

//Iterable接口是专门创建新的迭代器的
class Custom_Stack<type> implements Iterable {
    //栈顶引用
    private Node top;
    //该栈中元素数量
    private int size;

    private class Node{
        private type data;
        private Node next;
    }

    //入栈
    public void push(type value){
        Node newNode=new Node();
        if(!isEmpty())//非空栈
            newNode.next=top;
        size++;
        top=newNode;
        top.data=value;
    }
    //出栈
    public type pop(){
        Node deNode=top;
        type value=null;
        if(isEmpty()){
            System.out.println("Stack is empty!");
            return value;
        }
        size--;
        value=top.data;
        top=top.next;
        deNode.next=null;
        return value;
    }
    //返回该栈中元素数量
    public int getSize(){return size;}

    //是否为空栈
    public boolean isEmpty(){
        return top==null;
    }

    //Iterator接口是一个专门设计迭代器的
    private class ReverseStackIterator implements Iterator<type>{

        private Node iterNode=top;

        @Override
        public boolean hasNext() {
            if(iterNode != null)
                return true;
            else
                return false;
        }

        @Override
        public type next() {
            type value = null;
            if(hasNext()){
                value=iterNode.data;
                iterNode=iterNode.next;
            }
            return value;
        }
    }

    @Override
    public Iterator<type> iterator() {
        return new ReverseStackIterator();
    }
}

泛型队列

class Custom_Queue<type> implements Iterable<type>{

    //队首
    private Node first;
    //队尾
    private Node last;
    //队列中元素的数量
    private int size;

    private class ReserveIteratorQueue implements Iterator<type> {
        private Node itemFirst = first;
        @Override
        public boolean hasNext() {
            if(itemFirst!=null)
                return true;
            else
                return false;
        }

        @Override
        public type next() {
            type value=null;
            if(hasNext()){
                value=itemFirst.data;
                itemFirst=itemFirst.next;
            }
            return value;
        }
    }

    @Override
    public Iterator<type> iterator() {
        return new ReserveIteratorQueue();
    }


    private class Node{
        private Node next;
        private type data;
    }

    //队首删除元素
    public type dequeue(){
        Node deNode=first;
        if(isEmpty())
            return null;
        if(first.next==null)
            last=null;
        type value=first.data;
        first=first.next;
        deNode.next=null;
        size--;
        return value;
    }

    //队尾插入元素
    public void enqueue(type value){
        Node newNode=new Node();
        newNode.data=value;

        if(first==null&&last==null){
            first=newNode;
            last=first;
        }else if(last!=null){
            last.next=newNode;
            last=newNode;
        }
        size++;
    }

    //返回队列中元素的数量
    public int size(){
        return size;
    }

    //判断是否为一个空队列
    public boolean isEmpty(){
        if(first==null&&last==null)
            return true;
        else
            return false;
    }
}

排序

选择排序

缺：一个随机排列的数组和一个基本有序的数组排序时间一样

优：数据移动最少即每次交换只会改变两个数组元素的值

找：需要比较且每次都查找未排序的元素

换：不需要比较直接交换


class Selection{

    /**
     *
     * @param a 排序的元素
     * @param sequence true 升序 ; false 降序
     */
    public static void sort(Comparable[] a,boolean sequence){
        final int N=a.length;

        //交换次数为n-1次
        for(int i=0;i<N-1;i++){
            int MaxOrMin=i;

            for(int j=i+1;j<N;j++)
                if(sequence){
                    //ascend Min
                    if(less(a[MaxOrMin],a[j]))
                        MaxOrMin=j;//得到当前已知最小值

                }else {
                    //descend
                    if(!less(a[MaxOrMin],a[j]))
                        MaxOrMin=j;//得到当前已知最大值
                }
            exch(a,i,MaxOrMin);//交换
        }

    }

    //比较
    private static boolean less(Comparable v, Comparable w){
        if(v.compareTo(w)<0)
            return false;
        else if(v.compareTo(w)>=0)
            return true;
        return true;
    }

    //交换
    private static void exch(Comparable[] a,int i,int j){
        Comparable p=a[i];
        a[i]=a[j];
        a[j]=p;
    }

    public static void show(Comparable[] a){
        for (Comparable com:a)
            System.out.println(com);
    }

}

插入排序（对元素部分有序的数组和小规模数组非常高效）

class Insertion_sort{

    /**
     *
     * @param a 排序的元素
     * @param sequence true 升序 ; false 降序
     */
    public static void sort(Comparable[] a,boolean sequence){
        final int N=a.length;

        // N-1次
        for(int i=1;i<N;i++)
            //如果基本有序元素排序就花费更少的时间
            for(int j=i;j>0;j--)
                if(sequence){
                    if(less(a[j-1],a[j]))
                        exch(a,j,j-1);
                    else
                        break;
                }else {

                    if(!less(a[j-1],a[j]))
                        exch(a,j,j-1);
                    else
                        break;
                }

    }

    //比较
    private static boolean less(Comparable v, Comparable w){
        if(v.compareTo(w)<0)
            return false;
        else if(v.compareTo(w)>=0)
            return true;
        return true;
    }

    //交换
    private static void exch(Comparable[] a,int i,int j){
        Comparable p=a[i];
        a[i]=a[j];
        a[j]=p;
    }

    public static void show(Comparable[] a){
        for (Comparable com:a)
            System.out.println(com);
    }

}

希尔排序(使用待排序元素变成部分有序后)

class Shell_Sort{
    /**
     *
     * @param a 排序的元素
     * @param sequence true 升序 ; false 降序
     */
    public static void sort(Comparable[] a,boolean sequence){
        final int N=a.length;

       //缩小gap直到0为止，就让代排元素基本有序，跳出循环
       for(int gap=N/2;gap>0;gap/=2)
           //比较与交换的循环
           for(int right=gap;right<N;right++)
               if(sequence){
                   if(!less(a[right],a[right-gap]))
                       exch(a,right,right-gap);
               }else {
                   if(less(a[right],a[right-gap]))
                       exch(a,right,right-gap);
               }

    }

    //比较
    private static boolean less(Comparable v, Comparable w){
        if(v.compareTo(w)<0)
            return false;
        else if(v.compareTo(w)>=0)
            return true;
        return true;
    }

    //交换
    private static void exch(Comparable[] a,int i,int j){
        Comparable p=a[i];
        a[i]=a[j];
        a[j]=p;
    }

    public static void show(Comparable[] a){
        for (Comparable com:a)
            System.out.println(com);
    }

}

new@*
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值