算法
最近看了写文章，发现自己的算法了解的比较少，于是开始找教程开始彻底的学习一下算法<<韩顺平-图解java数据结构和算法>>。
1.算法的时间复杂度
1.1.时间频度：一个算法花费的时间与算法中语句执行次数成正比例，那个算法中语句执行次数多，它花费时间就多。一个算法的语句执行次数称为语句频度或者时间频度。记为T(n)
表达式有三个特点：忽略常数项，忽略低次项，忽略系数
1.2时间复杂度
推算过程：a.一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大的时候，T(n)/f(n)的极限值为不等于0的常数，则称f(n)是T(n)的同数量级函数。记做T(n)=O(f(n)),称O(f(n))为算法的渐进时间复杂度，简称时间读咋读。
b.T(n)不同，但是时间复杂不到可能相同。如T(n)=n2+7n+6 与 T(n)=3n2+2n+2他们的T(n)不同，但是时间复杂度相同，都是O(n2)
c.计算时间复杂度的方法：
用常数1代替运行时间中的所有加法常数
修改后的运行次数函数中，只保留最高阶项
去除最高阶项的系数
常见时间复杂度
常数阶 O(1)
对数阶 O(log2n)
线性阶O(n)
线性对数阶O(log2n)
平方阶 O(n2)
立方阶O(n3)
k次方阶O(n^k)
指数阶O(2^n)
排序算法：
1.冒泡排序 时间复杂度（O(n^2)）：
通过对待排序下序列从前往后（从下标娇小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐往上冒。因为排序的过程中，各元素不断的接近自己的位置，如果一趟比较下来没有进行过交换，说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行交换，从而减少不必要的比较。
1 public class BubbleSort { 2 public static void main(String[] args) { 3 int[] arr = {9,-1,22,10,33,45}; 4 int temp = 0; 5 for (int i = 0; i < arr.length - 1; i++) { 6 boolean flag = true; // 优化标识，当一次循环时所有位置没有发生变化，则标识该序列已经时有序的，可以跳出循环 7 for (int j = 0; j < arr.length-1-i; j++) { 8 if(arr[i]>arr[i+1]){ 9 temp = arr[i+1]; 10 arr[i+1]=arr[i]; 11 arr[i]=temp; 12 flag=false; 13 } 14 if(flag){ 15 break; 16 } 17 } 18 } 19 System.out.println(Arrays.toString(arr)); 20 } 21 }
2.选择排序 时间复杂度（O(n^2)）：
第一次从arr[0]-arr[n-1]中选择最小值，与arr[0]交换，第二次从arr[1]-arr[n-1]中选择最小值，与arr[1]进行交换，....总共通过n-1次没到一个排序从最小到最大的排序
public static void selectSott(int[] arr) {
int min = 0;
for (int i = 0; i < arr.length - 1; i++) {
min = arr[i];
int minIndex = i;
for (int j = i; j < arr.length - 1; j++) {
if (min > arr[j + 1]) {
min = arr[j+1];
minIndex=j+1;
}
}
arr[minIndex]=arr[i];
arr[i] = min;
}
}
3.插入排序
插入式排序属于内部排序发，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中选取第一个元素，把它与有序表中的每个元素进行比较，将它插入到有序表中适当的位置，使之成为新的有序表
public static void inertSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int insertIndex = i;
int insertVal = arr[i + 1];
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];
insertIndex--;
}
if (insertIndex + 1 != i) {
arr[insertIndex + 1] = insertVal;
}
}
}
4.希尔算法
在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，以后每次减半，直到增量为1。希尔排序是不稳定的。
// 希尔排序法一：交换法
// 首先分为5组数据，每组2个数据 9，7 2，8 3，6 4，5 1，0 // 排序之后在分为2组， 每组5个数据 public static void shellSort(int[] arr) { int temp = 0; for (int i = arr.length / 2; i > 0; i = i / 2) { for (int j = i; j < arr.length; j++) { for (int k = j - i; k >= 0; k = k - i) { if (arr[k] > arr[k + i]) { temp = arr[k]; arr[k] = arr[k + i]; arr[k + i] = temp; } } } } }
// 希尔排序法二 移动插入（效率比一高）
public static void shellSort2(int[] arr) {
for (int i = arr.length / 2; i > 0; i = i / 2) {
for (int j = i; j < arr.length; j++) {
int index = j;
int indexValue = arr[index];
while (index - i >= 0 && indexValue < arr[index - i]) {
arr[index] = arr[index - i];
index = index - i;
}
arr[index] = indexValue;
}
}
}
5.快速排序
是对冒泡排序的改进，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后在按此方法分对两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
public static void quickSort(int[] arr, int left, int right) {
int l = left;
int r = right;
int pivot = arr[(left + right) / 2];
int temp = 0;
while (l < r) {
while (arr[l] < pivot) {
l++;
}
while (arr[r] > pivot) {
r--;
}
if (l >= r) {
break;
}
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
if (arr[l] == pivot) {
r--;
}
if (arr[r] == pivot) {
l++;
}
}
if (l == r) {
l++;
r--;
}
if (left < r) {
quickSort(arr, left, r);
}
if (right > l) {
quickSort(arr, l, right);
}
}
6.归并排序
是利用归并的思想实现排序方法，该算法采用经典的分治策略（将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案修补在一起，即分而治之）
public static void mergeSort(int arr[],int left,int right,int[] temp){
if(left< right){
int mid = (left + right) / 2;
mergeSort(arr,left,mid,temp);
mergeSort(arr,mid+1,right,temp);
merge(arr,left,mid,right,temp);
}
}
// 合并
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left; // 初始化i，左边有序序列的初始索引
int j = mid + 1; // 初始化j，右边有序序列的初始索引
int t = 0;//指向temp数组的当前索引
while (i <= mid && j <= right) {
if (arr[i] < arr[j]) {
temp[t] = arr[i];
t += 1;
i += 1;
} else {
temp[t] = arr[j];
t += 1;
j += 1;
}
}
while (i <= mid) {
temp[t] = arr[i];
t += 1;
i += 1;
}
while (j <= right) {
temp[t] = arr[j];
j += 1;
t += 1;
}
t=0;
int tempLeft = left;
while (tempLeft<=right){
arr[tempLeft] = temp[t];
t+=1;
tempLeft+=1;
}
}
7.基数排序
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
public static void radixSort(int[] arr) { //1. 得到数组中最大的数的位数 int max = arr[0]; //假设第一数就是最大数 for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } //得到最大数是几位数 int maxLength = (max + "").length(); //定义一个二维数组，表示 10 个桶, 每个桶就是一个一维数组 //说明 //1. 二维数组包含 10 个一维数组 //2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为 arr.length //3. 名明确，基数排序是使用空间换时间的经典算法 int[][] bucket = new int[10][arr.length]; //为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数 //可以这里理解 //比如:bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数 int[] bucketElementCounts = new int[10]; //这里我们使用循环将代码处理 for (int i = 0, n = 1; i < maxLength; i++, n *= 10) { //(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位.. for (int j = 0; j < arr.length; j++) { //取出每个元素的对应位的值 int digitOfElement = arr[j] / n % 10; //放入到对应的桶中 bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j]; bucketElementCounts[digitOfElement]++; } //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组) int index = 0; //遍历每一桶，并将桶中是数据，放入到原数组 for (int k = 0; k < bucketElementCounts.length; k++) { //如果桶中，有数据，我们才放入到原数组 if (bucketElementCounts[k] != 0) { //循环该桶即第 k 个桶(即第 k 个一维数组), 放入 for (int l = 0; l < bucketElementCounts[k]; l++) { //取出元素放入到 arr arr[index++] = bucket[k][l]; } } //第 i+1 轮处理后，需要将每个 bucketElementCounts[k] = 0 !!!! bucketElementCounts[k] = 0; } } }
常用算法比较：
-
) 稳定:如果a原本在b前面，而a=b，排序之后a仍然在b的前面;
-
) 不稳定:如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面;
-
) 内排序:所有排序操作都在内存中完成;
-
) 外排序:由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行;
-
) 时间复杂度:一个算法执行所耗费的时间。
-
) 空间复杂度:运行完一个程序所需内存的大小。
-
) n: 数据规模
-
) k: “桶”的个数
-
) In-place: 不占用额外内存
10. ) Out-place: 占用额外内存
