如何建开发手机网站首页外贸 国外推广网站

📕1. 直接插入排序

稳定性 : 稳定

时间复杂度 : 最好情况O(N) 最坏情况O(N^2) 平均情况O(N ^2)

空间复杂度 : O(1)

算法思路 :

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

 public static void insertSort(int[] array){for (int i = 1; i < array.length; i++) {int tmp = array[i];int j = i-1;for (; j >=0 ; j--) {if (array[j]>tmp){array[j+1] = array[j];}else {break;}}array[j+1] = tmp;}}

📕2. 希尔排序

稳定性 : 不稳定

空间复杂度 : O(1)

算法思路 :

1. 选择一个步长序列，建议初始步长 n/2，每次减半直到步长为1
2. 对每个步长，对数组进行分组，对应位置相隔为步长的元素视为一组
3. 对每一组使用插入排序进行排序
4. 减小步长，重复步骤2和3，直到步长减少到1
5. 当步长为1时，相当于对整个数组做一次插入排序，此时数组已基本有序，所需的比较和移动次数大大减少

public static void shellsort(int[] array){int gap = array.length/2;while (gap>0){for (int i = gap; i < array.length; i++) {int tmp = array[i];int j = i - gap;for (; j >=0 ; j-=gap) {if (array[j]>tmp){array[j+gap] = array[j];}else{break;}}array[j+gap] = tmp;}gap/=2;}}

📕3. 冒泡排序

稳定性 : 稳定

时间复杂度 : 最好情况O(N) 最坏情况O(N^2) 平均情况O(N ^2)

空间复杂度 : O(1)

算法思路 :

1. 比较相邻的元素。如果第一个比第二个大，就交换它们
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对
3. 这步做完后，最后的元素会是最大的数
4. 针对所有的元素重复以上的步骤，除了已经是最大数的最后一个
5. 持续每次对越来越少(每次重复都会少一个最大数)的元素重复上面的步骤，直到没有任何一对数字需要比较

public static void bubbleSort(int[] array){for (int i = 0; i < array.length-1; i++) {for (int j = 0; j < array.length-1-i; j++) {if (array[j]>array[j+1]){int tmp = array[j];array[j] = array[j+1];array[j+1] = tmp;}}}}

📕4. 选择排序

稳定性 : 不稳定

时间复杂度 : 最好情况O(N^2) 最坏情况O(N ^2) 平均情况O(N ^2)

空间复杂度 : O(1)

算法思路 :

1. 从下标0开始遍历数组 , 首先把0下标认为是最小元素的下标
2. 如果有比0下标元素更小的元素则调换下标 , 然后交换值
3. 不断重复上述过程 , 直到遍历完数组

public static void selectSort(int[] array){for (int i = 0; i < array.length-1; i++) {int midIndex = i;for (int j = i+1; j < array.length; j++) {if (array[j] < array[midIndex]){midIndex = j;}}int tmp = array[midIndex];array[midIndex] = array[i];array[i] = tmp;}}

📕5. 堆排序

稳定性 : 不稳定

时间复杂度 : 最好情况O(nlogn) 最坏情况O(nlogn) 平均情况O(n*logn)

空间复杂度 : O(1)

算法思路 :

1. 将无序序列构建成一个最大堆
2. 将堆顶元素（最大值）与堆的最后一个元素交换
3. 剔除最后一个元素（已排序），将剩余元素重新构建为最大堆
4. 重复步骤2和3，直到堆中只剩下一个元素

    public static void heapSort(int[] array){for (int parent = (array.length-1-1)/2; parent>=0 ; parent--) {siftDown(array,parent,array.length);}int end = array.length-1;while(end>0){int key = array[0];array[0] = array[end];array[end] = key;siftDown(array,0,end);end--;}}public static void siftDown(int[] array , int parent,int length){int child = parent*2+1;while(child<length){if (child+1<length&&array[child+1]>array[child]){child++;}if (array[child]>array[parent]){int tmp = array[child];array[child] = array[parent];array[parent] = tmp;parent = child;child = parent*2+1;}else{break;}}}

📕6. 归并排序

稳定性 : 稳定

时间复杂度 : O(nlogn)

空间复杂度 : O(n)

算法思路:

1. 划分 : 将待排序数组从中间划分为两个子序列
2. 求解子问题 : 分别对这两个子序列进行排序 , 得到两个有序的子序列
3. 合并 : 将这两个子序列合并为一个有序数列

public static void mergeSort(int[] array) {mergeSortChild(array,0,array.length-1);}private static void mergeSortChild(int[] array,int left,int right) {//防御性编程if(left >= right) {return;}int mid = (left + right) / 2;mergeSortChild(array,left,mid);mergeSortChild(array,mid+1,right);//开始合并merge(array,left,mid,right);}private static void merge(int[] array, int left, int mid, int right) {//临时数组int[] tmpArr = new int[right-left+1];//tmpArr数组下标int k = 0;int s1 = left;int e1 = mid;int s2 = mid+1;int e2 = right;//当2个段都有数据的时候while (s1 <= e1 && s2 <= e2) {if(array[s1] <= array[s2]) {tmpArr[k++] = array[s1++];}else {tmpArr[k++] = array[s2++];}}//一个段走完了 把另一个段的数据 拷贝到临时数组while (s1 <= e1) {tmpArr[k++] = array[s1++];}while (s2 <= e2) {tmpArr[k++] = array[s2++];}//临时数组当中存储的是有序的数据 -> 拷贝数据到原始数组当中for (int i = 0; i < k; i++) {array[i+left] = tmpArr[i];}}

📕7. 快速排序

稳定性 : 不稳定

时间复杂度 : 最好情况O(nlogn) 最坏情况O(n^2) 平均情况O(nlogn)

空间复杂度 : 最好情况O(logn) 最坏情况O(n) 平均情况O(logn)

算法思路(挖坑法):

1. 选择基准元素：从列表中选择一个元素作为基准（pivot）。选择方式可以是第一个元素、最后一个元素、中间元素或随机元素。

2. 分区：将列表重新排列，使得所有小于基准元素的元素都在基准的左侧，所有大于基准元素的元素都在基准的右侧。基准元素的位置在分区完成后确定。

3. 递归排序：对基准元素左侧和右侧的子列表分别递归地进行快速排序。

4. 合并：由于分区操作是原地进行的，递归结束后整个列表已经有序。

 public static void quickSort(int[] array){quick(array,0,array.length-1);}private static void quick(int[] array, int startindex, int endindex) {if (startindex>=endindex){return;}int par = getpartition(array,startindex,endindex);quick(array,startindex,par-1);quick(array,par+1,endindex);}private static int getpartition(int[] array, int startindex, int endindex) {int index = startindex;int left = startindex;int right = endindex;int pivot = array[index];while (left<right){while (left<right){if (array[right]<pivot){array[index] = array[right];left++;index = right;break;}else {right--;}}while (left<right){if (array[left]>pivot){array[index] = array[left];index = left;right--;break;}else {left++;}}}array[index] = pivot;return index;}