冒泡排序
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
/**
* @Classname Main
* @Description 冒泡排序实现
* @Date 2020/7/15 10:51
* @Created by yang.zhao
*/
public class Main {
//1.比较相邻的元素如果第一个元素比第二个元素大就进行一次交换
//2.依次向后重复进行比较，最后的元素一定是最大的数。
//3.依次进行刚才的操作直到数组变的有序
/**
* @param a 需要交换的数组
* @param i 交换位置1
* @param j 交换位置2
* @Description 交换两个节点的数字位置
*/
public static void swap(int a[], int i, int j) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
public static void bubbleSort(int a[]){
for(int i=0;i<a.length-1;i++){
//从第一个元素到最后一个元素，依次缩小范围对节点的值进行判断并对大值进行交换。
for(int j=0;j<a.length-1-i;j++){
if(a[j]>a[j+1]){
swap(a,j,j+1);
}
}
}
}
public static void main(String[] args) {
int arr[] = {3,4,6,2,11,1,4, 6, 8, 5, 9};
bubbleSort(arr);
for (int i = 0; i < arr.length; i++) {
System.err.println(arr[i]);
}
}
}
选择排序
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。
/**
* @Classname Main
* @Description 选择排序实现
* @Date 2020/7/15 10:51
* @Created by yang.zhao
*/
public class Main {
/**
* @param a 需要交换的数组
* @param i 交换位置1
* @param j 交换位置2
* @Description 交换两个节点的数字位置
*/
public static void swap(int a[], int i, int j) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
/**
* @param a 待排序的数组
* @Description 选择排序
*/
public static void selectionSort(int a[]) {
for (int i = 0; i < a.length; i++) {
int miniPosition = i;
for (int j = i + 1; j < a.length; j++) {
if(a[j]<a[miniPosition]){
miniPosition = j ;
}
}
//将最小值放在第一位
swap(a,miniPosition,i);
}
}
public static void main(String[] args) {
int arr[] = {3,4,6,2,11,1,4, 6, 8, 5, 9};
selectionSort(arr);
for (int i = 0; i < arr.length; i++) {
System.err.println(arr[i]);
}
}
}
快速排序递归实现
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）
- 从数列中挑出一个元素，称为 “基准”（pivot）;
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
代码实现如下：
/**
* @Classname Main
* @Description 快速排序实现
* @Date 2020/7/15 10:51
* @Created by yang.zhao
*/
public class Main {
/**采用分治的方法对其进行排序，步骤如下：
* 1．先从数列中取出一个数作为基准数。
* 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
* 3．再对左右区间重复第二步，直到各区间只有一个数。
*/
/**
* @param a 需要我们进行填数的数组
* @param l 基准数所在初始位置
* @param r 查找开始的初始位置
* @Description 进行一次的数字的移动和对应位置的填充。
*/
public static int moveAndFill(int[] a, int l, int r) {
int i = l;
int j = r;
//我们按照填充的位置去尝试从数组中取出第一个数字。
int x = a[i];
while (i < j) {
//既然我们的右区间要比X大，那么我们从右查找将小于X的数字放在左面,填充a[i]的空位。------找比x小的值放在左面
for (; i < j && a[j] >= x; j--) {
//通过从j开始向i方向循环，查找到一个小于x的数字为止，获取数组的位置j。
}
if (i < j) {//找到的j的位置必须在i的右面，如果在i的左面则已经满足了我们定义的i左小右大的条件，此时的赋值就没有意义。
//将找到的j对应的数字a[j] 赋值到我们的i的位置上如下：
a[i] = a[j];
//i继续向右查找
i++;
}
// ----------------------------------------------------------------------
//同理我们从左查找将大于x的数字放在右面，填充a[j]的空位------找比x大的数字放在右面填上上一步a[j]的坑
for (; i < j && a[i] < x; i++) {
//通过从i开始向j方向循环，查找到一个小于x的数字为止，获取数组的位置j。
}
if (i < j) {
a[j] = a[i];
j--;
}
}
//当这一次的填坑过程结束，我们将被移动到右侧的原来的i所在的坑，填入我们最开始的基准数x。
a[i] = x;
//返回一个我们计算出来的新的基准位置，方便下一次填坑使用。
return i;
}
/**
* @param a 待排序数组
* @param l 基准数所在位置
* @param r 第一次查找开始的位置
* @Description 快速排序实现
*/
public static void quickSort(int a[], int l, int r) {
if (l < r) {
//进行一次移动填充。
int i = moveAndFill(a, l, r);
//通过递归的方式对左区间进行一次划分并填充。
quickSort(a, l, i - 1);
//同理对右区间再进行一次划分并填充。
quickSort(a, i + 1, r);
}
}
public static void main(String[] args) {
int a[] = {1, 7, 4, 3, 2, 10, 6, 5, 8, 9};
quickSort(a, 0, a.length - 1);
for (int i = 0; i < a.length; i++) {
System.out.printf("%d", a[i]);
}
System.out.println();
}
}
堆排序实现
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：
大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
/**
* @Classname Main
* @Description 堆排序实现
* @Date 2020/7/15 10:51
* @Created by yang.zhao
*/
public class Main {
//1.构造初始堆。将给定无序序列构造成一个大顶堆
//2.交换堆首元素和堆尾元素
//3.排除最后一个最大的元素重新构建堆，并交换。
/**
* @param a 需要交换的数组
* @param i 交换位置1
* @param j 交换位置2
* @Description 交换两个节点的数字位置
*/
public static void swap(int a[], int i, int j) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
/**
* @param a 需要构建的数组
* @param start 起始位置
* @param end 结束位置
* @Description 构建一个大顶堆 父节点 大于或等于两个子节点
*/
public static void maxHeapify(int a[], int start, int end) {
//父节点位置
int parent = start;
//左孩子位置
int child = parent * 2 + 1;
while (child <= end) {//在数组大小范围内进行排序
if (child + 1 <= end && a[child] < a[child + 1]) {
//对于两个子节点取最大的，即左孩子大 取 左孩子 左孩子小 child++取右孩子
child++;
}
if (a[parent] > a[child]) {
//父节点大于最大的子节点，满足我们的要求，函数退出。
return;
}
//如果 父节点小于等于最大的子节点，那么我们需要交换一下节点的数字，并继续在子节点上进行交换操作。
swap(a, parent, child);
parent = child;
child = parent * 2 + 1;
}
}
public static void heapSort(int a[]) {
//获取a的长度
int len = a.length;
for (int i = len / 2 - 1; i >= 0; i--) {// i第一个非叶子结点 即 arr.length/2-1,从左到右 从下到上进行移动。
//获取一个大顶堆，堆首元素为当前的最大元素。
maxHeapify(a, i, len - 1);
}
for (int i = len - 1; i > 0; i--) {
//将堆顶元素与末尾元素进行交换，使得末尾元素在当前堆中最大。
swap(a, 0, i);
//在剩下的元素中继续构建最大堆，不断的将最大的元素放到当前堆的末尾。
maxHeapify(a, 0, i - 1);
}
}
public static void main(String[] args) {
int arr[] = {4, 6, 8, 5, 9};
heapSort(arr);
for (int i = 0; i < arr.length; i++) {
System.err.println(arr[i]);
}
}
928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
