本文共 10545 字，大约阅读时间需要 35 分钟。
希尔排序
选定步长，将步长间距的几个数进行比较排序，然后初始位后移一位，同样还是将步长间距的几个数进行比较排序，这样的话比较的几个数就是第一次的每个数的后一个数。然后步长就变小，同样进行前面的比较。package example;public class ShellSort { public static void main(String[] args) { int[] arr = { 5, 1, 7, 3, 1, 6, 9, 4}; shellSort(arr); for (int i : arr) { System.out.print(i + "\t"); } } private static void shellSort(int[] arr) { //step:步长 for (int step = arr.length / 2; step > 0; step /= 2) { //步长的变化依次变小 //对一个步长区间进行比较 [step,arr.length) for (int i = step; i < arr.length; i++) { //固定步长下的隔步长距离的比较，i+即后移一位的另一步长组的比较 int value = arr[i]; int j; //对步长区间中具体的元素进行比较 for (j = i - step; j >= 0 && arr[j] > value; j -= step) { //固定步长的数据大的依次后移 //j为左区间的取值，j+step为右区间与左区间的对应值。 arr[j + step] = arr[j]; } //此时step为一个负数，[j + step]为左区间上的初始交换值 arr[j + step] = value; } } } } 选择排序
和冒泡类似的两次循环，每次循环找到最小的那个数，然后下次循环，冒泡是找到最大的那个，就我个人感觉差不多。package example;public class SelectSort { public static int[] selectSort(int[] arr,int n) { for (int i = 0; i < n - 1; i++) { //外循环是趟数，每一趟就位置加一 int index = i; int j; // 找出最小值得元素下标 for (j = i + 1; j < n; j++) { //内循环是每一趟一个元素与其他元素的每一次比较 if (arr[j] < arr[index]) { index = j;//每次将小的赋给index，循环结束后index就是最小的 } } int tmp = arr[index]; arr[index] = arr[i]; arr[i] = tmp;//将找到的数赋给外循环的那个循环位置 } return arr; } public static void main(String[] args) { int[] arr={ 12,3,23,2,3,2314,23,45,3425,34,53,45,4,65,7,56,786,78,34}; arr=selectSort(arr,arr.length); for (int i : arr) { System.out.println(i); } }} RSA案例
package example;import java.security.InvalidKeyException;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.NoSuchAlgorithmException;import java.security.PrivateKey;import java.security.PublicKey;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.InvalidKeySpecException;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import javax.crypto.BadPaddingException;import javax.crypto.Cipher;import javax.crypto.IllegalBlockSizeException;import javax.crypto.NoSuchPaddingException;import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;public class RSADemo { private static String src="infcn"; private static RSAPublicKey rsaPublicKey; private static RSAPrivateKey rsaPrivateKey; static{ KeyPairGenerator keyPairGenerator; try { keyPairGenerator=KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(512); KeyPair keyPair=keyPairGenerator.generateKeyPair(); rsaPublicKey=(RSAPublicKey) keyPair.getPublic(); rsaPrivateKey=(RSAPrivateKey)keyPair.getPrivate(); System.out.println("Public key:"+Base64.encode(rsaPublicKey.getEncoded())); System.out.println("Private key:"+Base64.encode(rsaPrivateKey.getEncoded())); } catch (NoSuchAlgorithmException e) { // TODO: handle exception e.printStackTrace(); } } /**公钥加密，私钥解密 * @author 29284 * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException * @throws NoSuchPaddingException * @throws InvalidKeyException * @throws BadPaddingException * @throws IllegalBlockSizeException */ public static void pubEn2PriDe() throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException { //公钥加密 X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded()); KeyFactory keyFactory=KeyFactory.getInstance("RSA"); PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec); Cipher cipher=Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] result=cipher.doFinal(src.getBytes()); System.out.println("公钥加密，私钥解密--加密："+Base64.encode(result)); //私钥解密 PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded()); keyFactory=KeyFactory.getInstance("RSA"); PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec); cipher.init(Cipher.DECRYPT_MODE, privateKey); result=cipher.doFinal(result); System.out.println("公钥加密，私钥解密--解密："+new String(result)); } /** * 私钥加密，公钥解密 * @author jijs * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException * @throws NoSuchPaddingException * @throws InvalidKeyException * @throws BadPaddingException * @throws IllegalBlockSizeException */ public static void priEn2PubDe() throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException { //私钥加密 PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded()); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec); Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, privateKey); byte[] result = cipher.doFinal(src.getBytes()); System.out.println("私钥加密，公钥解密 --加密 : " + Base64.encode(result)); //公钥解密 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded()); keyFactory = KeyFactory.getInstance("RSA"); PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec); cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.DECRYPT_MODE, publicKey); result = cipher.doFinal(result); System.out.println("私钥加密，公钥解密 --解密: " + new String(result)); } public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { pubEn2PriDe(); priEn2PubDe(); }} 快排
使用快速排序，首先选取数组中某个元素t，然后将其他元素重新排列，使数组中所有在t前面的元素都小于或等于t，所有在t后面的元素都大于或等于t。这里我们使用最简单的选择策略：每次都选取数组第一个元素当做中轴（即前面的t），然后同时从左右开始扫描，左边找到一个比中轴大的，右边找到一个比中轴小的，然后交换两个元素的位置。，然后就是每次都进行同样的过程，这就类似与分治，左边的一部分，右边的一部分。public static int partition(int[] arr,int left,int right){ int pivot = arr[left]; while(left < right){ while(left = pivot) right--; arr[left] = arr[right]; while(left < right && arr[left]<= pivot) left++; arr[right] = arr[left]; } arr[left] = pivot; return left; } 插入排序
插入排序就是首先认为数组已经是有序了的，先找到一个数放入，然后依次将下一个数与他们进行比较找到合适的位置插进去，每次插入后数组都是有序的。package example;public class InsertSort{ public static int[] insertSort(int[] arr) { for (int i = 1; i < arr.length; i++)//每次选择一个插入 { int k = arr[i];//k用来代替arr【i】进行大小判断 int j = i;//j内循环用来判断当前位与前一位的大小 while (j > 0 && arr[j - 1] > k)//如果要插入的元素的前一位比他大则前一位后移 { arr[j] = arr[j - 1];//元素后移 j--;//变量前移 } arr[j] = k;//k插入到这 } return arr; } public static void main(String[] args) { int[] arr={ 1,23,3,44,5,4,56,57,6,7,568,67,89,67,986,7,6,79,23,86,78,6,8}; arr=insertSort(arr); for (int i : arr) { System.out.println(i); } }} 冒泡排序
这个最简单就没得什么说的了@Test void test15() { List list = new ArrayList<>(); list.add(1); list.add(2); list.add(10); list.add(5); list.add(17); list.add(6); for (int i = 0; i < list.size(); i++) { for (int j = 0; j 0) { Integer temp = list.get(j); list.set(j,list.get(j+1)); list.set(j+1,temp); } } } list.stream().forEach(e-> System.out.println(e)); } 线程池
package example.testForJava;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class threadPool { public static void main(String[] args) { //线程池容量为5，最大可扩展到10 /*保持200表示线程没有任务执行时最多保持多久时间会终止。 默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用， 直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时， 如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。 unit为前一参数的单位*/ //等待队列 ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5)); for (int i = 0; i < 15; i++) { MyTask myTask = new MyTask(i); executor.execute(myTask); System.out.println("thread pool num " + executor.getPoolSize() + " queue num " + executor.getQueue().size() + " already complected num " + executor.getCompletedTaskCount()); } executor.shutdown(); }} 基数排序
基数排序介绍
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用 基数排序法是属于稳定性的排序，基数排序法是效率高的稳定性排序法。LSD
排序过程就是先将一组数以个位数的顺序排列后，再将得到的序列按十位数的顺序排列，再依次往高位移动，最后得到数列。适用与位数较小的序列。MSD
位数多的话用次方法，由高位开始，但是分配后并不马上合并回一个数组中，而是在每个桶中建立子桶，每个桶中按下一位分配到桶，在进行完最低位数的分配后再合并回单一的数组中//LSDpublic class RadixSort { public static void main(String[] args) { int arr[]={ 53, 3, 542, 748, 14, 214}; radixSort(arr); } public static void radixSort(int[] arr){ //先求出数组中的最大的数 int max=arr[0]; for(int i=1;i max){ max=arr[i]; } } //得到最大数是几位数 int maxLength=(max+"").length(); //定义一个二维数组，表示10个桶，每个桶就是一个数组 //为了在放入数时防止数据溢出，我们每个桶的大小为arr.length,即每个桶最多放进数组里的所有元素 int[][] bucket=new int[10][arr.length]; //定义一个一维数组来记录各个桶的每次放入的数据个数 int[] bucketElementCount=new int[10]; for(int i=0,n=1;i 合并排序（归并排序）使用分治思想
每次就将一个大数组分成两个小数组，然后递归调用，直到最后只剩一个数，就是排好序的，然后就递归回去，每次将已经排好序的两个小数组合并成一个大数组。分后的图就类似于一个二叉树。void Copy(int a[],int b[],int left,int right){ //将b[0]至b[right-left+1]拷贝到a[left]至a[right] int size=right-left+1; for(int i=0; i a1end) { b[bcout++]=a[a2cout++]; continue; } //如果第一个数组结束，拷贝第二个数组的元素到b if(a2cout>a2end) { b[bcout++]=a[a1cout++]; continue; } //如果第二个数组结束，拷贝第一个数组的元素到b if(a[a1cout] 转载地址：http://ihrwi.baihongyu.com/