算法总结（java）

最新推荐文章于 2024-07-14 12:25:25 发布
最新推荐文章于 2024-07-14 12:25:25 发布
阅读量311 收藏
点赞数
文章标签： 算法 java pivot class

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;
/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class InsertSort implements SortUtil.Sort...{

    /**//* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        int temp;
        for(int i=1;i<data.length;i++)...{
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--)...{
                SortUtil.swap(data,j,j-1);
            }
        }       
    }

}
//冒泡排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class BubbleSort implements SortUtil.Sort...{

    /**//* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        int temp;
        for(int i=0;i<data.length;i++)...{
            for(int j=data.length-1;j>i;j--)...{
                if(data[j]<data[j-1])...{
                    SortUtil.swap(data,j,j-1);
                }
            }
        }
    }

}

//选择排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SelectionSort implements SortUtil.Sort ...{

    /**//*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        int temp;
        for (int i = 0; i < data.length; i++) ...{
            int lowIndex = i;
            for (int j = data.length - 1; j > i; j--) ...{
                if (data[j] < data[lowIndex]) ...{
                    lowIndex = j;
                }
            }
            SortUtil.swap(data,i,lowIndex);
        }
    }

}

//Shell排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ShellSort implements SortUtil.Sort...{

    /**//* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        for(int i=data.length/2;i>2;i/=2)...{
            for(int j=0;j<i;j++)...{
                insertSort(data,j,i);
            }
        }
        insertSort(data,0,1);
    }

    /** *//**
     * @param data
     * @param j
     * @param i
     */
    private void insertSort(int[] data, int start, int inc) ...{
        int temp;
        for(int i=start+inc;i<data.length;i+=inc)...{
            for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc)...{
                SortUtil.swap(data,j,j-inc);
            }
        }
    }

}

//快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class QuickSort implements SortUtil.Sort...{

    /**//* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        quickSort(data,0,data.length-1);       
    }
    private void quickSort(int[] data,int i,int j)...{
        int pivotIndex=(i+j)/2;
        //swap
        SortUtil.swap(data,pivotIndex,j);
       
        int k=partition(data,i-1,j,data[j]);
        SortUtil.swap(data,k,j);
        if((k-i)>1) quickSort(data,i,k-1);
        if((j-k)>1) quickSort(data,k+1,j);
       
    }
    /** *//**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private int partition(int[] data, int l, int r,int pivot) ...{
        do...{
           while(data[++l]<pivot);
           while((r!=0)&&data[--r]>pivot);
           SortUtil.swap(data,l,r);
        }
        while(l<r);
        SortUtil.swap(data,l,r);       
        return l;
    }

}
//改进后的快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedQuickSort implements SortUtil.Sort ...{

    private static int MAX_STACK_SIZE=4096;
    private static int THRESHOLD=10;
    /**//* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        int[] stack=new int[MAX_STACK_SIZE];
       
        int top=-1;
        int pivot;
        int pivotIndex,l,r;
       
        stack[++top]=0;
        stack[++top]=data.length-1;
       
        while(top>0)...{
            int j=stack[top--];
            int i=stack[top--];
           
            pivotIndex=(i+j)/2;
            pivot=data[pivotIndex];
           
            SortUtil.swap(data,pivotIndex,j);
           
            //partition
            l=i-1;
            r=j;
            do...{
                while(data[++l]<pivot);
                while((r!=0)&&(data[--r]>pivot));
                SortUtil.swap(data,l,r);
            }
            while(l<r);
            SortUtil.swap(data,l,r);
            SortUtil.swap(data,l,j);
           
            if((l-i)>THRESHOLD)...{
                stack[++top]=i;
                stack[++top]=l-1;
            }
            if((j-l)>THRESHOLD)...{
                stack[++top]=l+1;
                stack[++top]=j;
            }
           
        }
        //new InsertSort().sort(data);
        insertSort(data);
    }
    /** *//**
     * @param data
     */
    private void insertSort(int[] data) ...{
        int temp;
        for(int i=1;i<data.length;i++)...{
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--)...{
                SortUtil.swap(data,j,j-1);
            }
        }      
    }

}

//归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class MergeSort implements SortUtil.Sort...{

    /**//* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }
   
    private void mergeSort(int[] data,int[] temp,int l,int r)...{
        int mid=(l+r)/2;
        if(l==r) return ;
        mergeSort(data,temp,l,mid);
        mergeSort(data,temp,mid+1,r);
        for(int i=l;i<=r;i++)...{
            temp[i]=data[i];
        }
        int i1=l;
        int i2=mid+1;
        for(int cur=l;cur<=r;cur++)...{
            if(i1==mid+1)
                data[cur]=temp[i2++];
            else if(i2>r)
                data[cur]=temp[i1++];
            else if(temp[i1]<temp[i2])
                data[cur]=temp[i1++];
            else
                data[cur]=temp[i2++];           
        }
    }

}

//改进后的归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/** *//**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedMergeSort implements SortUtil.Sort ...{

    private static final int THRESHOLD = 10;

    /**//*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) ...{
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data, int[] temp, int l, int r) ...{
        int i, j, k;
        int mid = (l + r) / 2;
        if (l == r)
            return;
        if ((mid - l) >= THRESHOLD)
            mergeSort(data, temp, l, mid);
        else
            insertSort(data, l, mid - l + 1);
        if ((r - mid) > THRESHOLD)
            mergeSort(data, temp, mid + 1, r);
        else
            insertSort(data, mid + 1, r - mid);

        for (i = l; i <= mid; i++) ...{
            temp[i] = data[i];
        }
        for (j = 1; j <= r - mid; j++) ...{
            temp[r - j + 1] = data[j + mid];
        }
        int a = temp[l];
        int b = temp[r];
        for (i = l, j = r, k = l; k <= r; k++) ...{
            if (a < b) ...{
                data[k] = temp[i++];
                a = temp[i];
            } else ...{
                data[k] = temp[j--];
                b = temp[j];
            }
        }
    }

    /** *//**
     * @param data
     * @param l
     * @param i
     */
    private void insertSort(int[] data, int start, int len) ...{
        for(int i=start+1;i<start+len;i++)...{
            for(int j=i;(j>start) && data[j]<data[j-1];j--)...{
                SortUtil.swap(data,j,j-1);
            }
        }
    }

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/hias_asia/archive/2008/03/31/2234166.aspx

coding01
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法总结java
05-13
在编程领域，尤其是在Java开发中，算法扮演...以上就是Java中常见的算法总结，熟练掌握这些算法对于提升编程能力、优化代码效率具有重要作用。在实际开发中，根据问题的具体情况灵活选择合适的算法，往往能够事半功倍。
Java排序算法总结
12-22
【Java排序算法总结】 在计算机科学中，排序算法是用于对数据进行排列的算法，而Java作为一种广泛应用的编程语言，提供了多种实现排序的方案。以下是对几种常见的Java排序算法的详细解析： 一、冒泡排序 冒泡排序...
排序算法
weixin_41188227的博客
05-02 103
1;插入排序 public static void main(String[] args) { //使用插入排序的方式，将每一个元素按照大小插入到适合大小的位置 //思想就是将前一个元素与后一个元素作比较，小的元素放在前面形成一个初步的有序数列，另一边则是无序的数列 //然后将有序数列中的最后一个元素与无需数列中的第一个元素作比较形成一个新的有序数...
Java中哈希算法总结
m0_73514610的博客
07-10 2207
/Hash算法(消息摘要算法)工具类 public class HashTools {//消息摘要对象 private static MessageDigest digest;//构造方法 private HashTools () {} //按照MD5进行消息摘要计算(哈希算法) public static String digestByMD5 (String source) throws NoSuchAlgorithmException{
动态规划算法及Java实例
万猫学社
03-25 1382
我们已经走过了动态规划算法的概念，解题步骤到实战的道路，从中我们可以看到，这是一种以空间换时间的策略，它通过存储子问题的解，避免了重复计算，从而提高了算法的效率。同时，我们也看到了动态规划算法的实用性，它可以解决各种实际问题，如商品的最优购买组合问题。然而，动态规划并非万能的，它也有自己的局限性。比如，动态规划算法通常需要大量的内存空间来存储子问题的解，这对于内存资源有限的场合是一种挑战。
Java-进程调度算法
向诸位大佬虚心学习
08-23 1663
欢迎各位大佬前来喝茶，本文主要介绍了Java中与进程相关的进程调度算法，包括先进先出算法、短作业优先算法、优先级算法和时间片轮转算法。
Java加密：常见哈希算法总结
qq_46853052的博客
07-21 2997
哈希算法总结以及简单应用实现代码
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
java常见的查找算法
white_218的博客
06-06 2021
java常见四种查找算法： 1、线性查找2、二分法查找3、插值查找4、斐波那契查找
java排序算法总结
kevin的博客
04-19 3101
java排序算法总结 排序，这是一个很古老但是又很经典的问题，世界上有很多中优秀排序算法的实现，在这里，我总结了其他比较常用的几种排序算法 1.java排序算法一览 冒泡排序和基数排序 桶排序和计数排序 归并排序和快速排序 堆排序 插入排序和希尔排序 2.分类 3.比较 1.时间复杂度比较 算法 乱序时间复杂度 有序时间复杂度 插入排序 O(N^2) O(N) 希尔排序 ...
Java哈希算法总结
weixin_72718348的博客
07-10 2060
编码算法 URL编码 Base64编码 哈希算法 哈希碰撞 常见哈希算法 Hmac算法 BouncyCastle
Java实现加密算法
qq_44016171的博客
07-30 2399
一、常用的加密算法及简略介绍 常用加密算法 Base64 严格来说只是一种编码方式，并不算是加密算法 Base64 编码是从二进制到字符的过程，用 64 个字符来表示任意的二进制数据，常用于在 HTTP 加密，图片编码传输等 MD5 Message Digest algorithm 5，信息摘要算法 一般用于确保信息的传输完整一致性，校验传输的数据是否被修改，一旦原始信息被修改，生成的 MD5 值将会变得很不同 SHA 家族 是一个密码散列函数家族，是 FIPS 所认证的安全散列算法，和 MD5
总结Java常用排序算法
08-26
在编程领域，排序算法是数据处理的核心部分，尤其是在Java这样的高级编程语言中。本文主要讨论了四种常用的排序算法：冒泡排序、选择排序、插入排序和希尔排序，并提供了每种算法的Java实现。 1. **冒泡排序**： ...
java-排序算法总结
02-27
在编程领域，排序算法是计算机科学中的核心概念，特别是在Java这样的高级编程语言中。排序算法是用来组织和优化数据结构的关键工具，它可以帮助我们快速查找、分析和处理大量数据。本篇将深入探讨Java中实现的几种...
java各种排序算法总结
11-18
排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际...
函数模板与类模板
程序员_小兵
07-12 1565
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
算法014：找到字符串中所有字母异位词
最新发布
m0_62319039的博客
07-14 414
算法014：找到字符串中所有字母异位词
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 382
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 823
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
排序算法复习大全(Java实现).doc
09-01
"排序算法复习大全(Java实现).doc" 这篇文档主要涵盖了五种常见的排序算法，包括插入排序、冒泡排序、选择排序、Shell排序和快速排序，并提供了每种排序算法的Java实现。这些算法都是基于Java编程语言，利用抽象类`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值