SortUtils.java
package prms.utils.sort;
import java.util.Arrays;
/**
* @ClassName: SortUtils
* @Description: <p> 排序算法 工具类 </p>
* @author edgar
* @email 【[email protected]】
* @version V 1.0
* @date 2017-3-28 15:35:12
*/
public class SortUtils {
/**
* @Title: SortUtils
* @Description: 私有化构造 :类不能实例化
*/
private SortUtils(){}
public static void main(String[] args) {
int[] arr = { 2, 5, 3, 1, 4 };
System.out.println("排序前:" + Arrays.toString(arr));
bubbleSort(arr);
heapSort(arr);
insertSort(arr);
mergeSort(arr);
quickSort(arr);
selectionSort(arr);
shellSort(arr);
System.out.println("排序后:" + Arrays.toString(arr));
}
/**
* @Title: bubbleSort
* @Description: 冒泡排序
* 依次比较相邻的两个数,将小数放在前面,大数放在后面。
* 即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。
* 然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,
* 直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,
* 将最大的数放到了最后。在第二趟:仍从第一对数开始比较
* (因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),
* 将小数放前,大数放后,一直比较到倒数第二个数(倒数第一的位置上已经是最大的),
* 第二趟结束,在倒数第二的位置上得到一个新的最大数
* (其实在整个数列中是第二大的数)。如此下去,重复以上过程,直至最终完成排序。
* @param data
* @return void
*/
public static void bubbleSort(int[] data){
for (int i = 0; i < data.length - 1; i++) {
for (int j = 0; j < data.length - 1 - i; j++) {
if (data[j] > data[j + 1]) {
swap(data, j, j + 1);
}
}
}
}
/**
* @Title: heapSort
* @Description: 堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征, 使得在当前无序区中选取最大(或最小)关键字的记录变得简单。
* (1)用大根堆排序的基本思想
* ① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区
* ②再将关键字最大的记录R[1](即堆顶)和无序区的最后一个 记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],
* 且满足R[1..n-1].keys≤R[n].key ③由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。
* 然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换,
* 由此得到新的无序区R[1..n-2]和有序区R[n-1..n],
* 且仍满足关系R[1..n-2].keys≤R[n-1..n].keys,同样要将R[1..n-2]调整为堆。 直到无序区只有一个元素为止。
* (2)大根堆排序算法的基本操作:
* ① 初始化操作:将R[1..n]构造为初始堆;
* ②每一趟排序的基本操作:将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换, 然后将新的无序区调整为堆(亦称重建堆)。
*
* @param data
* @return void
*/
public static void heapSort(int[] data) {
MaxHeap h = new MaxHeap();
h.init(data);
for (int i = 0; i < data.length; i++)
h.remove();
System.arraycopy(h.queue, 1, data, 0, data.length);
}
private static class MaxHeap {
private int size = 0;
private int[] queue;
void init(int[] data) {
this.queue = new int[data.length + 1];
for (int i = 0; i < data.length; i++) {
queue[++size] = data[i];
fixUp(size);
}
}
@SuppressWarnings("unused")
public int get() {
return queue[1];
}
public void remove() {
swap(queue, 1, size--);
fixDown(1);
}
// fixdown
private void fixDown(int k) {
int j;
while ((j = k << 1) <= size) {
if (j < size && queue[j] < queue[j + 1])
j++;
if (queue[k] > queue[j]) // 不用交换
break;
swap(queue, j, k);
k = j;
}
}
private void fixUp(int k) {
while (k > 1) {
int j = k >> 1;
if (queue[j] > queue[k])
break;
swap(queue, j, k);
k = j;
}
}
}
/**
* @Title: insertSort
* @Description: 插入排序基本思想
* 将n个元素的数列分为已有序和无序两个部分,如插入排序过程示例下所示:
* {
{a1},{a2,a3,a4,…,an}}
* {
{a1⑴,a2⑴},{a3⑴,a4⑴ …,an⑴}}
* {
{a1(n-1),a2(n-1) ,…},{an(n-1)}}
* 每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较,
* 找出插入位置,将该元素插入到有序数列的合适位置中。
* @param data
* @return void
*/
public static void insertSort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
}
/**
* @Title: mergeSort
* @Description: 归并操作(merge),也叫归并算法,指的是将两个已经排序的序列合并成一个序列的操作。
* 如设有数列{6,202,100,301,38,8,1}
* 初始状态: [6] [202] [100] [301] [38] [8] [1] 比较次数
* i=1 [6 202 ] [ 100 301] [ 8 38] [ 1 ] 3
* i=2 [ 6 100 202 301 ] [ 1 8 38 ] 4
* i=3 [ 1 6 8 38 100 202 301 ] 4
* @param data
* @return void
*/
public static void mergeSort(int[] data) {
int[] temp = new int[data.length];
mergeSort(data, temp, 0, data.length - 1);
}
private static 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++];
}
}
}
/**
* @Title: quickSort
* @Description:快速排序
* 一趟快速排序的算法是:
* 1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;
* 2)以第一个数组元素作为关键数据,赋值给key,即 key=A[0];
* 3)从j开始向前搜索,即由后开始向前搜索(j=j-1即j--),找到第一个小于key的值A[j],A[i]与A[j]交换;
* 4)从i开始向后搜索,即由前开始向后搜索(i=i+1即i++),找到第一个大于key的A[i],A[i]与A[j]交换;
* 5)重复第3、4、5步,直到 I=J; (3,4步是在程序中没找到时候j=j-1,i=i+1,直至找到为止。
* 找到并交换的时候i, j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。)
* @param data
* @return void
*/
public static void quickSort(int[] data) {
quickSort(data, 0, data.length - 1);
}
private static void quickSort(int[] data, int i, int j) {
int pivotIndex = (i + j) / 2;
// swap
swap(data, pivotIndex, j);
int k = partition(data, i - 1, j, data[j]);
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 static int partition(int[] data, int l, int r, int pivot) {
do {
while (data[++l] < pivot);
while ((r != 0) && data[--r] > pivot);
swap(data, l, r);
} while (l < r);
swap(data, l, r);
return l;
}
/**
* @Title: shellSort
* @Description: 希尔排序:
* 先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成(n除以d1)个组。所有距离为d1的倍数的记录放在同一个组中。
* 先在各组内进行直接插入排序;然后,取第二个增量d2<d1重复上述的分组和排序,直至所取的增量dt=1(dt<dt-l<…<d2<d1),
* 即所有记录放在同一组中进行直接插入排序为止。
*
*
* 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序
* 排序过程:先取一个正整数d1<n,把所有序号相隔d1的数组元素放一组,
* 组内进行直接插入排序;然后取d2<d1,重复上述分组和排序操作;直至di=1, 即所有记录放进一个组中排序为止
* 初始:d=5 49 38 65 97 76 13 27 49 55 04
* 49 13 |-------------------|
* 38 27 |-------------------|
* 65 49 |-------------------|
* 97 55 |-------------------|
* 76 04 |-------------------|
* 一趟结果 13 27 49 55 04 49 38 65 97 76
* d=3 13 27 49 55 04 49 38 65 97 76
* 13 55 38 76 |------------|------------|------------|
* 27 04 65 |------------|------------|
* 49 49 97 |------------|------------|
* 二趟结果 13 04 49* 38 27 49 55 65 97 76
* d=1 13 04 49 38 27 49 55 65 97 76
* |----|----|----|----|----|----|----|----|----| 三趟结果
* 04 13 27 38 49 49 55 65 76 97
* @param data
* @return void
*/
public static void shellSort(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 static void insertSort(int[] data, int start, int inc) {
for (int i = start + inc; i < data.length; i += inc) {
for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
swap(data, j, j - inc);
}
}
}
/**
* @Title: selectionSort
* @Description: 选择排序基本思路:
* 把第一个元素依次和后面的所有元素进行比较。第一次结束后,就会有最小值出现在最前面。依次类推
* @param data
* @return void
*/
public static void selectionSort(int[] data) {
for (int x = 0; x < data.length - 1; x++) {
for (int y = x + 1; y < data.length; y++) {
if (data[y] < data[x]) {
swap(data, x, y);
}
}
}
}
/**
* @Title: swap
* @Description: 交换数组中的两个元素
* @param data
* @param i
* @param j
* @return void
*/
public static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
文章浏览阅读814次。Android 有序广播创建广播接收者动态注册广播模拟发送一条广播由于Android8.0以后 静态注册比较麻烦,这里都采用动态注册。创建广播接收者优先级较高的接收者public class OrderReceiver extends BroadcastReceiver {private static final String TAG = “OrderReceiver”;@Overri..._getresultextras
文章浏览阅读163次。自定义数据加载动画自定义View继承ProgressDialog:import android.app.ProgressDialog;import android.content.Context;import android.os.Bundle;import android.view.WindowManager;import android.widget.ImageView;import com.bumptech.glide.Glide;public class Lo..._progressdialog 加载动画
文章浏览阅读5.7k次,点赞10次,收藏63次。12_python 插值
文章浏览阅读608次。1.iptables规则备份和恢复iptables备份数据到配置文件/etc/sysconfig/iptables,使用如下命令[root@linux-001 ~]# service iptables saveiptables备份规则到另外一个文件,而不是配置文件[root@linux-001 ~]# iptables-save > my.ipt[root@linux-00..._kmod-static-nodes.service
文章浏览阅读556次。概述“工欲善其事,必先利其器”,如果说编程是程序员的手艺,那么IDE就是程序员的吃饭家伙了。IDE的全称是Integration Development Environment(集成开发环境),一般以代码编辑器为核心,包括一系列周边组件和附属功能。一个优秀的IDE,最重要的就是在普通文本编辑之外,提供针对特定语言的各种快捷编辑功能,让程序员尽可能快捷、舒适、清晰的浏览、输入、修改代_我们编程用的是ide还是idle
文章浏览阅读2.3k次。因为项目中需要用到socket实现端到端的实时通信对话网上的教程也多是后台使用node,笔者这里项目后台使用的是java,所以只能另辟蹊径话不多说开搞,这里记录一下搞得过程遇到的需要注意的问题Java 后端1.在pom.xml添加netty-socketio的jar包<!-- 引入socketIo的jar包 --> <dependency> <groupId>com.corundumstudio.socketio<..._netty-socketio和socketio建立联系
文章浏览阅读844次。wordpress表单调用Anyone running an online business will know the importance of offering visitors (read: potential customers) a seamless checkout experience. Aside from your sales copy, it’s the single mos..._wordpress form
文章浏览阅读3.8k次。但一般现在设计网页都是用DreamWeaver多,我写php也是用DW。绝对路径就是一个网络地址或者本地地址是完整写全的路径。例如你d盘的名为“abc”的目录里,有个图片叫“def.jpg”。绝对路径就是d:\abc\def.jpg(若在linux系统里要改用斜杠“/”)。相对路径就是不完整的路径。如上例,我有另一个叫asdf.htm的网页文件需要调用刚才的图片。asdf.htm所在位置是d盘根目..._web用绝对路径添加图片
文章浏览阅读3.3k次。cdms功能CDMS系统具有强大的功能,主要包括以下6大核心功能模块:1文档共享管理 能够在网络环境中实现分布式文档管理,将分布在异地的文档集中在一个统一的环境中管理。以发布的方式实现文件的共享,确保文档的安全性、唯一性、可控制性、可追溯性。 能管理各种格式的文档,例如:WORD、EXCEL等Office文档、DWG、DGN、PDF、AVI、MP3_电脑里的cdms是什么
文章浏览阅读801次。when running hadoop program, errors like that.packageJobJar: [./map.py, ./red.py, /usr/local/src/hadoop-1.2.1/tmp/hadoop-unjar1576276863998395028/] [] /tmp/streamjob8951329431624757277.19/07/29 07:..._request execution failed with message: java.net.noroutetohostexception: no r
文章浏览阅读854次。题目链接题意:找出所给图形中,没有被染色的最大的三角形的面积。思路:仔细观察图形可以发现大三角形的形成是已一个未染色小三角形为基础,然后一层一层往上叠加(如果整层没被染色)。从上往下看图形不难发现,如果小三角形的底边朝上,叠加是向上形成的,底边朝下,叠加是向下形成的。所以我们可以枚举每一个没有被染色的小三角,更新能叠加的最大的层数,也就能得到最大三角形的面积。_uva585
文章浏览阅读2.2k次,点赞10次,收藏33次。1.思路图解兼样例:接下来将用此图例作为测试用例2.输出结果:(1)邻接矩阵:(2)邻接表:一、邻接矩阵import java.util.ArrayList;import java.util.Arrays;import java.util.LinkedList;public class AdjacencyMatrix { private ArrayList<String> vexs; // 顶点表 private int[][] edges; // 边表_邻接矩阵和邻接表 java