文章目录
1. 冒泡排序与选择排序的区别
参考博客
以从小到大排序为例：
- 冒泡排序通过比较两两相邻值的大小，将最大一直往右侧推，来达到将最大值或最小值放到正确位置的目的
参考博客
//冒泡排序两两比较的元素是没有被排序过的元素--->
public void bubbleSort(int[] array){
for (int i=0;i<array.length-1;i++) {//控制比较轮次，一共 n-1 趟
for (int j=0;j<array.length-1-i;j++) {//控制两个挨着的元素进行比较
if (array[j] > array[j+1]) {
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
- 选择排序通过用一个变量smallerIndex暂存最小值的下标，然后将a[smallerIndex] 挨个与其他每个未确定位置的值比较，每比较一次都更新smallerIndex为最小值的下标，比较完一轮后，再更换a[i]与a[smallerIndex]的数据
参考博客
import com.jd.fastjson.JSON;
public class SelectedSortTest_7 {
public static void main(String[] args) {
int[] array = {4, 2, 1, 6, 5};
selectionSort(array);
System.out.println(JSON.toJSONString(array));
}
public static void selectionSort(int[] array) {
int i, j, smallerIndex;
int len = array.length;
for (i = 0; i <= len - 1; i++) {
//第一步：找到最小值对应的索引
smallerIndex = i;
for (j = i + 1; j <= len - 1; j++) {
if (array[j] < array[smallerIndex]) {
smallerIndex = j;
}
}
//第二步：交换位置
if (i != smallerIndex) {
int temp = array[i];
array[i] = array[smallerIndex];
array[smallerIndex] = temp;
}
}
}
}
2. 归并排序
/* 归并排序 */
public class MergeSort {
public static void main(String [] args){
int [] data = {8, 3, 10, 1, 6, 14, 4, 7};
System.out.println((9+2)/2);
/* 归并排序 */
MergeSort mergeSort = new MergeSort();
mergeSort.printSortMain();
}
public void printSortMain() {
int i = 0;
int [] a = {5, 4, 9, 8, 7, 6, 0, 1, 3, 2, 10};
int len = a.length;
mergeSort(a, 0, len-1);
System.out.print("\n归并排序结果：");
for(i = 0; i<len; i++){
System.out.print(a[i] + "->");
}
}
private void mergeSort(int[] array, int p, int r) {
if( p < r){
int q = (p + r)/2;
mergeSort(array, p, q);
mergeSort(array,q+1, r);
merge(array,p,q,r); //合并两个数组array[p]~array[q]， array[q+1]~array[r]为一个有序数组
}
}
public static void merge(int[] a, int low, int mid, int high) {
int i= low;
int j = mid+1;
int k=0;
int[] temp = new int[high-low+1];
// 把较小的数先移到新数组中
while(i<=mid && j<=high){//0~5,6~10
if(a[i]<a[j]){
temp[k] = a[i];
i++;
}else{
temp[k] = a[j];
j++;
}
k++;
}
// 把左边剩余的数移入数组
while(i<=mid){
temp[k++] = a[i++];
}
// 把右边边剩余的数移入数组
while(j<=high){
temp[k++] = a[j++];
}
// 把新数组中的数覆盖nums数组
for(int x=0;x<temp.length;x++){
a[x+low] = temp[x];
}
}
}
3. 快速排序
3.1 快速排序性质
快速排序的本质：给基准数据找其正确索引位置的过程。
快速排序基本性质：时间复杂度NlogN
3.2 快速排序步骤
如下图所示,假设最开始的基准数据为数组第一个元素23,则
- 首先用一个临时变量去存储基准数据,即tmp=23;然后分别从数组的两端扫描数组，设两个指示标志:low指向起始位置，high指向末尾.
- 首先从后半部分开始，如果扫描到的值大于基准数据就让high减1,如果发现有元素比该基准数据的值小(如上图中18<=tmp)，就将high位置的值赋值给low位置 ,结果如下:
- 然后开始从前往后扫描,如果扫描到的值小于基准数据就让low加1,如果发现有元素大于或等于基准数据的值(如上图46=>tmp)，就再将low位置的值赋值给high位置的值,指针移动并且数据交换后的结果如下:
- 然后再开始从后向前扫描,原理同上,发现上图11<=tmp,则将low位置的值赋值给high位置的值,结果如下:
- 然后再开始从前往后遍历,直到low=high结束循环,此时low或high的下标就是基准数据23在该数组中的正确索引位置.如下图所示.
这样一遍走下来,可以很清楚的知道,其实快速排序的本质就是把比基准数小的都放在基准数的左边,把比基准数大的放在基准数的右边,这样就找到了该数据在数组中的正确位置是data[i]处.
以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。
3.3 代码
public class QuickSort {
public static void main(String [] args){
int [ ] data = {8, 3, 10, 1, 6, 14, 4, 7};
/* 实现 快速排序 */
QuickSort quickSort = new QuickSort();
quickSort.quickSort(data, 0, data.length-1);
System.out.print("\n快速排序结果：");
for(int i=0; i<data.length; i++){
System.out.print(data[i] + "->");
}
}
//快排
public void quickSort(int [] data, int low, int high) {
int i = low;
int j = high;
int baseValue = data[i];
if(low >= high){
return;
}
//直到左值下标等于右值下标
while(i<j){
//从右往左扫描，直到右值小于基准值 或者左值下标等于右值下标，才停止循环
while(i<j && baseValue<=data[j] ){
j--;
}
//把右值data[j]赋值给左值data[i]
if(i<j){
data[i]=data[j];
i++;
}
//从左往右扫描，直到左值>=基准值 或者左值下标等于右值下标，才停止循环
while(i<j && data[i]<baseValue ){
i++;
}
//把左值data[i]赋值给右值data[j]
if(i<j){
data[j]=data[i];
j--;
}
}
//此时data[i]前面的数都比baseValue小，data[i]后面的数都比baseValue大
data[i]=baseValue;
//对data[i]的左边重新进行快排
quickSort(data,low,i-1);
//对data[i]的右边重新进行快排
if( i < (data.length-1 )) {
quickSort(data, i + 1, high);
}
}
}
4. 用二叉树排序
即二叉树的中序遍历，参见博客：专项攻克——二叉树
5. 堆排序
5.1 堆排序介绍
算法复杂度：O(nlogn)
堆排序：堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
堆是完全二叉树，分两类：
- 大顶堆：每个结点的值都大于或等于其左右孩子结点的值，arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
- 小顶堆：每个结点的值都小于或等于其左右孩子结点的值arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子
5.2 堆排序的基本思路
堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
- a. 将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
- b. 将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
- c. 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
5.3 具体步骤
给定无序序列结构如下
目标堆：
5.4 代码
/**
* @Author 黄军威
* @create 2019/9/2 0:39
* @email hjunwei@foxmail.com
*/
//堆排序
public class HeapSort {
private static int len;
public static void main(String [] args){
int [ ] data = {8, 3, 10, 1, 6, 14, 4, 7};
/* 实现 堆排序，使 */
heapSort(data);
}
public static int [] heapSort(int [] array){
len = array.length;
if(len<1){
return array;
}
//构建一个最大堆；
for(int i=(len-1)/2; i>=0; i--){
adjustHeap(array,i);
}
//循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
while(len>1){
swap(array, 0, len-1);
len--;
adjustHeap(array, 0);
}
return array;
}
//将堆首位（最大值）与末位交换
private static void swap(int[] array, int i, int j) {
int a = array[i];
array[i] = array[j];
array[j] = a;
}
/** 调整使array成为最大堆 * */
private static void adjustHeap(int[] array, int i) {
int maxIndex = i;
//如果有左子树，且左子树大于父节点，则将最大自增指向左子树
if(i*2 < len && array[i*2] > array[maxIndex]){
maxIndex = i*2;
}
//如果有右子树，且右子树大于父节点，则将最大自增指向右子树
if(i*2+1 < len && array[i*2+1] > array[maxIndex]){
maxIndex = i*2 + 1;
}
//如果父节点不是最大值，这将父节点与最大值交换，并且递归调整与父节点交换的位置
if(maxIndex != i){
swap(array, maxIndex, i);
adjustHeap(array, maxIndex);
}
}
}
输出结果
排序前：[7, 6, 7, 11, 5, 12, 3, 0, 1]
排序后：[0, 1, 3, 5, 6, 7, 7, 11, 12]
882
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
