排序算法
算法的时间复杂度
常见的时间复杂度由小到大：
O ( 1 ) < O ( l o g 2 n ) < O ( n ) < O ( n 2 ) < O ( n 3 ) < O ( n k ) < O ( 2 n ) < O ( n ! ) O(1)<O(log_2 n)<O(n)<O(n^2)<O(n^3)<O(n^k)<O(2^n)<O(n!) O(1)<O(log2n)<O(n)<O(n2)<O(n3)<O(nk)<O(2n)<O(n!)
冒泡排序
时间复杂度： O ( n 2 ) O(n^2) O(n2)
思想：对待排序列从前到后，依次比较相邻元素的值，若发现逆序进行交换。
/*
* 从小到大排序 思想：n个元素，相邻元素进行比较。
* 每次遍历确定倒数第i位的顺序
* 需要进行i=n-1次遍历，每次遍历需要进行j=n-1-i次比较
* 直接在第二层for循环进行交换
*/
public static void bubbleSort(int[] array) {
boolean flag = false; //
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]) {
flag = true;
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
if (!flag) {
System.out.println("冒泡排序后的数组：");
System.out.println(Arrays.toString(array));
return;
}
}
System.out.println("冒泡排序后的数组：");
System.out.println(Arrays.toString(array));
}
选择排序
时间复杂度： O ( n 2 ) O(n^2) O(n2)
/*
* 从小到大排序 思路：逐一比较，将最小值与第1位互换，
* 然后从第2位再开始比较，再将次小值与第2位互换，依次类推
* 先假设最小值为第1位
* 每次比较将第二层for循环中找到的最小值赋值给min，下标赋给minIndex,
* 第二次for循环结束后交换
*/
public static void selectSort(int[] arr) {
int min;
int minIndex;
for(int i=0;i<arr.length-1;i++) {
min=arr[i];
minIndex=i;
for(int j=i+1;j<arr.length;j++) {
if(min>arr[j]) {
min=arr[j];
minIndex=j;
}
}
if(minIndex!=i) {
arr[minIndex]=arr[i];
arr[i]=min;
}
}
}
插入排序
思路：分为有序和无序区域 。将第一个数设为有序，后一个数与其比较
/*
* 思路：从小到大 分为有序和无序区域
* 将第一个数设为有序，后一个数与其比较
* index指向i-1个元素（有序区域的最后一个元素），value保存第i个元素的值（无序区域的第一个元素）
* 当无序区域的第一个元素小于有序区域的index个元素时，进入while循环，
* 将第index+1个元素用第index个元素覆盖，并使index--，
* 直到index=-1 或 当无序区域的第一个元素不小于有序区域的index个元素时退出循环
* 最后将value的值赋给index+1
*/
public static void insertSort(int[] arr) {
int index=0,value=0;
for (int i = 1; i < arr.length; i++) {
value=arr[i];
index=i-1;
while(index>=0 && value<arr[index]) {
arr[index+1]=arr[index];
index--;
}
if(index+1!=i) {
arr[index+1]=value;
}
}
}
希尔排序
是对插入排序的升级。
方法1： 4层循环
/* 是对插入排序法的升级
* 从小到大
* 思想：分为gap组，每组进行插入排序，
* 每次分组gap/=2，直到最后只剩1组，再用插入排序
* */
public static void shellSort3(int[] arr) {
int index = 0, value = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
// 共gap组，每组arr.length/gap个元素，步长gap
for (int i = 0; i < gap; i++) {
for (int j = i + gap; j < arr.length; j += gap) {
value = arr[j];
index = j - gap;
while (index >= 0 && arr[index] > value) {
arr[index + gap] = arr[index];
index -= gap;
}
if (index + gap != j) {
arr[index + gap] = value;
}
}
}
}
}
方法2： 3层循环
/* 移动法改版，是对插入排序法的升级
* 从小到大
* 思想：分为gap组，每次从第gap个元素开始遍历，
* 每次遍历直接采用插入排序法进行排序
* */
public static void shellSort4(int[] arr) {
int value = 0;
int index = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
// 共gap组，每组arr.length/gap个元素，步长gap
for (int i = gap; i < arr.length; i++) {
index = i - gap;
value = arr[index];
while (index >= 0 && value < arr[index]) {
arr[index + gap] = arr[index];
index -= gap;
if (index + gap != i) {
arr[index] = value;
}
}
}
}
}
实测：方法2性能明显优于方法1。
快速排序
需要用到递归。是对冒泡排序的改进。
思路：通过取支点（pivot）的方式，将需要排序的数据分割成独立的两部分，然后使左部分的值小于右部分的值。整个排序过程可以递归进行，以此使得整个序列变得有序。
每次对左右部分排序时（从小到大排序）：
- 假设取pivot为序列中间点的数据。Left指向序列头，Right指向序列尾。在排序过程中，支点pivot数据的位置可能会发生改变。
- 序列为奇数序列，且左边小于pivot的数据个数恰好等于右边大于pivot的数据个数时，此时pivot的位置不会发生改变。最终左索引（left）和右索引（right）都指向支点（pivot）（或在支点附近，且值与支点相同），其也是中间点。退出循环。
- 序列为偶数序列或者序列为奇数序列但左边小于pivot的个数不等于右边大于pivot的个数时，此时pivot的位置会进行改变。
- 因为最终必有一个索引（假设为right）先指向pivot(arr[right]==pivot)，则先进行数据交换，使得pivot数据交换至left索引处，原left所指向的数据交换至right索引处。
- 则此时arr[left]=pivot，令right左移，然后判断right所指向的数据是否小于pivot，若大于则进行数据交互；否则，right继续左移。
- 直到最后左索引（left）和右索引（right）都指向支点（pivot）（或在支点附近，且值与支点相同），退出循环。
- 然后左索引左移，右索引右移，与Left和Right比较判断以进行递归。
/*
* 快速排序 从小到大
* 思路：指定左右下标，确定中轴值，将左右索引l,r分别指向左右下标；
* l右移，直到p左侧的值大于pivot；
* 同理，r左移，直到p右侧的值小于pivot；
* 若直到l右移p-1处仍未找到，则l==p,
*/
/*
* 快速排序 从小到大
* 思路：指定左右下标left,right，确定中轴值pivot，将左右索引l,r分别指向左右下标；
* 直到l>=r时（当pivot附近的值等于pivot时，l,r不会同时指向pivot），循环结束，此时中轴值左侧全小于中轴值，右侧全大于中轴值。
*
* 若r先左移到pivot处，l还未右移到，则先将l所指向的值与r所指向的值（即pivot值）进行交换；
* 此时arr[l]=pivot，r再次左移，若arr[r]>pivot，则再次交换；
* 此时arr[r]=pivot,l右移,.....;
* 直到l和r同时指向pivot，退出循环；
* 然后r--,l++;
* 判断l,right left,r的相对位置以进入递归
*/
public static void quickSort2(int[] arr, int left, int right) {
int temp = 0;
int pivot = arr[(left + right) / 2];// 中轴值
int l = left, r = right;
while (true) {
while (arr[l] < pivot) {
l++;
}
while (arr[r] > pivot) {
r--;
}
//退出循环的条件：l>=r
if (l >= r) {
l++;
r--;
break;
}
if (arr[l] != arr[r]) {
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
}
if (arr[l] == pivot) {
r--;
}
if (arr[r] == pivot) {
l++;
}
}
if (left < r) {
quickSort2(arr, left, r);
}
if (right > l) {
quickSort2(arr, l, right);
}
}
归并排序
特点：空间换时间，需要用到递归。
思路：该算法采用分治策略，将问题分成一些小问题然后递归求解。
left=0,right=7 → \rightarrow → left=0,right=3 → \rightarrow → left=0,right=1 → \rightarrow → left=1,right=2
left=0,right=7 ← \leftarrow ← left=4,right=7 ← \leftarrow ← left=0,right=3 ← \leftarrow ← left=1,right=2
/*
* 思路：
* 通过递归将原数组最终分割为单个元素，期间不会执行merge方法，相当于入栈
* 然后逐层退出递归，其中每次退出均会执行merge方法，相当于出栈。
* 相当于执行merge方法先进行左侧有序排列，然后进行右侧有序排列，直至返回到最后一层
*/
/**
* @param arr 要进行分组的数组
* @param left 该数组的左索引
* @param right 该数组的右索引
* @param temp 用来转移数据的数组
*/
public static void mergeSort(int[] arr, int left, int right, int[] temp) {
// 退出递归的条件：left>=right
if (left >= right) {
return;
}
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 t = 0;
int i = left, j = mid + 1;
// 当左有序序列和右有序序列均未遍历完
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
i++;
t++;
} else {
temp[t] = arr[j];
j++;
t++;
}
}
// 仅左有序序列未遍历完
while (i <= mid) {
temp[t] = arr[i];
i++;
t++;
}
// 仅右有序序列未遍历完
while (j <= right) {
temp[t] = arr[j];
j++;
t++;
}
// 将temp临时数组数据转移到arr数组上
t = 0;
int arrLeft = left;
while (arrLeft <= right) {
arr[arrLeft] = temp[t];
arrLeft++;
t++;
}
}
}
基数排序（桶排序）
基数排序，是桶排序的扩展，是效率高的稳定性排序。
注：假定在待排序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次序保持不变，则称这种排序算法是稳定的；否则是不稳定的。
思路：将待比较的数据统一为相同数位长度，数位较短的数前补零。然后，从最低位开始，依次进行一次排序。从最低位排序一直到最高位排序完成之后，数列变为有序序列。
堆排序
堆排序是利用堆这种数据结构而设计的一种选择排序。
堆排序最坏、最好和平均时间复杂度均为 O ( n l o g n ) O(nlogn) O(nlogn)，堆排序也是不稳定排序。
大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列。
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列。
基本思路：
- 将无序序列构建成一个堆数组，升序选择大顶堆，降序选择小顶堆；
- 将堆顶元素与末尾元素交换，将最大元素“沉”到数组末端；
- 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
/*
* 思路：首先利用for循环和adjustHeap方法将原数组构建成大顶堆，
* 然后，将堆顶元素与末尾元素交换，
* 再次利用adjustHeap方法将剩余j-1个元素以第1个元素为顶构建大顶堆
* */
public static void heapSort(int arr[]) {
int temp = 0;
System.out.println("堆排序~");
//最后一个子节点为arr.length-1,其父结点为(arr.length-1-1)/2
// 调整数组结构，构建大顶堆
for (int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
// 将堆顶元素“沉”到数组末端，然后再次调整数组结构
for (int j = arr.length - 1; j > 0; j--) {
temp = arr[j];
arr[j] = arr[0];
arr[0] = temp;
adjustHeap(arr, 0, j);
}
}
/**
* 功能：完成将以i对应的非叶子节点的树调整成大顶堆
*
* @param arr 待排序的数组
* @param i 表示非叶子节点在数组中的索引
* @param length 表示对多少个元素继续调整
*/
/*
* 首先，将父节点的初值赋给temp，
* 然后选出左右子节点中较大值（左右子节点比较大小，但并不互换），
* 与父节点比较，若子节点中较大值都小于父节点，退出循环；
* 否则，将较大值赋值给父节点，
* 父节点指针i指向较大子节点k，然后再次进入for循环，
* 直到子节点中较大值都小于父节点或者遍历到数组末端，退出循环；
*/
public static void adjustHeap(int arr[], int i, int length) {
int temp = arr[i];
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
// 选出子节点中的最大值
// 若左子节点<右子节点，k指向右子节点
if (k + 1 < length && arr[k] < arr[k + 1]) {
k++;
}
// 子节点与父节点比较得到最大值
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;
}
扫一扫
158
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
