1. 冒泡排序
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
时间复杂度：O（n²）
public class BubbleSort {
/**
* 冒泡排序
* 1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
* 2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
* 3. 针对所有的元素重复以上的步骤，除了最后一个。
* 4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
*/
@Test
public void bubbleSortDemo() {
Integer[] array = {1, 12, 6, 19, 18, 9, 66, 89};
for (int i = 0; i < array.length - 1; i++) {
boolean mark = false; //标记是否有交换数据，如果没有交换数据则表明数组已是有序数组，无需再进行排序
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;
mark = true ;
}
}
if(!mark){
//没有交换数据则表明数组已是有序数组，无需再进行排序
break;
}
System.out.println(Arrays.toString(array));
}
// System.out.println(Arrays.toString(array));
}
/**
* 冒泡排序加强版
* 记录最后一次交换索引的位置
*
*/
@Test
public void bubbleSortPlusDemo() {
Integer[] array = {1, 12, 6, 19, 18, 9, 66, 89};
int lastIndex = array.length - 1;
while (true) {
int index = 0;
for (int j = 0; j <lastIndex; j++) {
System.out.println("array : "+Arrays.toString(array)+" ::: "+j);
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
//记录最后一次交换索引的位置
index = j;
}
}
//记录最后一次交换索引的位置
lastIndex = index;
if(lastIndex==0){
break;
}
System.out.println(Arrays.toString(array));
}
// System.out.println(Arrays.toString(array));
}
}
2. 选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法
最好复杂度：O(n^2)
最差复杂度：O(n^2)
public class SelectionSort {
/**
* 选择排序 是一种简单直观的排序算法。
* 1. 第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，
* 2. 再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。
* 3. 以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法
*/
@Test
public void selectionSortDemo() {
Integer[] array = {1, 12, 6, 19, 18, 9, 66, 89};
for (int i = 0; i < array.length; i++) {
int tempIndex = i;//用于记录最小索引
for (int j = i; j < array.length; j++) {
//判断最小值
if(array[tempIndex] > array[j]){
tempIndex = j; // 获取最小索引
}
}
//与最小索引进行替换
int temp = array[i];
array[i] = array[tempIndex];
array[tempIndex] = temp;
}
System.out.println(Arrays.toString(array));
}
}
3. 插入排序
插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法 。
插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动
空间复杂度：O(1)
时间复杂度：O(N^(1-2))
public class InsertionSort {
/**
* 插入排序
* 将数组分为两个区域，排序区和未排序区，每一轮从未排序区选取第一个元素与排序区做对比，直到对比结束。默认第一个是排序好的
* 例：[6, 5, 2]
* 1. 默认6是排序好的，5是未排序的 ---> 6>5 交换位置 -->[5, 6, 2]
* 2. 5，6是排序好的，2是未排序的 ---> 2<6 6往后移一位，然后2还要与5比较 2<5 --》[2， 5， 6] 直到2找到合适位置
*/
@Test
public void insertionSortDemo() {
Integer[] array = {1, 12, 6, 19, 18, 9, 66, 89};
for (int i = 1; i < array.length; i++) {//默认第一个是排序好的，所以要从索引为1的位置开始
int insertVal = array[i]; // 待插入的值
int index = i - 1; //待比较的索引
while (index >= 0) {
if (insertVal < array[index]) {//如果待插入的值比前面的值小
array[index + 1] = array[index]; //那么比较的值往后移一位
index--;
}else{
break;
}
}
//插入值
array[index + 1] = insertVal;
System.out.println(Arrays.toString(array));
}
// System.out.println(Arrays.toString(array));
}
@Test
public void insertionSortDemo02() {
Integer[] array = {1, 12, 6, 19, 18, 9, 66, 89};
for (int i = 1; i < array.length; i++) {
for (int j = i - 1; j >= 0; j--) {
if (array[j + 1] < array[j]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
} else {
break;
}
}
System.out.println(Arrays.toString(array));
}
// System.out.println(Arrays.toString(array));
}
}
4. 快速单边循环排序
快速排序采用的是分治思想，即在一个无序的序列中选取一个任意的基准元素pivot，利用pivot将待排序的序列分成两部分，前面部分元素均小于或等于基准元素，后面部分均大于或等于基准元素，然后采用递归的方法分别对前后两部分重复上述操作，直到将无序序列排列成有序序列
public class QuickSort {
@Test
public void quickSortDemo() {
Integer[] array = {1, 12, 6, 19, 18, 9, 66, 89};
recursionQuickSort(array, 0, array.length - 1);
System.out.println(Arrays.toString(array));
}
/**
* 递归调用
*
* @param array
* @param startIndex
* @param endIndex
*/
public void recursionQuickSort(Integer[] array, Integer startIndex, Integer endIndex) {
if (startIndex >= endIndex) {//如果起始边界大于等于结束边界 结束递归
return;
}
//获取基准点的索引位置，此时比基准点小的全在左侧，比基准点大的全在右侧,可以分而治之
Integer pvIndex = quickSort(array, startIndex, endIndex);
//分而治之-->对基准点左侧元素递归调用
recursionQuickSort(array, startIndex, pvIndex - 1);
//分而治之-->对基准点右侧元素递归调用
recursionQuickSort(array, pvIndex + 1, endIndex);
}
/**
* 单边循环快速排序---->基准点选择最右侧得元素
* 1. 选择右侧元素做为基准点
* 2. I 指针维护小于基准点的边界，也就是每次交换的目标索引
* 3. J 指针负责找到比基准点小的元素，一旦找到则与 I 索引交换
* 4. 最后交换基准点与 I 交换， 因为基准点选择是的右侧的, I 一定是大于基准点的，所以大于基准点的放在右
*
* @param array
*/
public int quickSort(Integer[] array, Integer startIndex, Integer endIndex) {
int pv = array[endIndex];//设置基准点 基准点选择最右侧得元素
int j = startIndex; //设置比基准点小的元素索引
for (int i = startIndex; i < endIndex; i++) {
if (array[i] < pv) { //如果当前元素比基准点小 那么将当前元素与基准点大的元素进行交换
int temp = array[i];
array[i] = array[j];
array[j] = temp;
j++; //默认比基准点小的元素索引为0，一旦发现比基准点小的元素就与J交换位置,此时就能保证比基准点小的元素全在基准点的左侧
}
}
//调换基准点元素，因为基准点选择的是最右侧得元素，所以与 j(此时的j是++后的) 互换位置，换过去的一定是大于基准点的元素
array[endIndex] = array[j];
array[j] = pv;
// System.out.println(Arrays.toString(array));
return j;
}
}
5. 快速双边循环排序
快速排序采用的是分治思想，即在一个无序的序列中选取一个任意的基准元素pivot，利用pivot将待排序的序列分成两部分，前面部分元素均小于或等于基准元素，后面部分均大于或等于基准元素，然后采用递归的方法分别对前后两部分重复上述操作，直到将无序序列排列成有序序列
public class QuickSort {
@Test
public void quickSortDemo() {
Integer[] array = {1, 12, 6, 19, 18, 9, 66, 89};
recursionQuickSort(array, 0, array.length - 1);
System.out.println(Arrays.toString(array));
}
/**
* 递归调用
*
* @param array
* @param startIndex
* @param endIndex
*/
public void recursionQuickSort(Integer[] array, Integer startIndex, Integer endIndex) {
if (startIndex >= endIndex) {//如果起始边界大于等于结束边界 结束递归
return;
}
//获取基准点的索引位置，此时比基准点小的全在左侧，比基准点大的全在右侧,可以分而治之
Integer pvIndex = quickSort(array, startIndex, endIndex);
//分而治之-->对基准点左侧元素递归调用
recursionQuickSort(array, startIndex, pvIndex - 1);
//分而治之-->对基准点右侧元素递归调用
recursionQuickSort(array, pvIndex + 1, endIndex);
}
/**
* 双边循环快速排序---->基准点选择最左侧的元素
* 1. 选择左侧元素做为基准点
* 2. rl指针负责从右向左找比基准点小的元素，lr指针负责从左向右找比基准点大的元素。
* 3. 一旦找到，二者交换 直到 rl == lr 说明两个指针重合，结束循环
* 4. 最后交换基准点位置
*
* @param array
*/
public int quickSort(Integer[] array, Integer startIndex, Integer endIndex) {
Integer pv = array[startIndex]; //确定基准点--以最左侧为基准点
Integer lrIndex = startIndex;//确定比基准点大的索引--》左-右
Integer rlIndex = endIndex;//确定比基准点小的索引--》右-左
while (rlIndex > lrIndex) {
//从右向左找比基准点小的索引
while (rlIndex > lrIndex && pv <= array[rlIndex]) {
rlIndex--;
}
//从左向右找比基准点大的索引
while (rlIndex > lrIndex && pv >= array[lrIndex]) {
lrIndex++;
}
//互换位置
int temp = array[lrIndex];
array[lrIndex] = array[rlIndex];
array[rlIndex] = temp;
}
//基准点换位置
array[startIndex] = array[rlIndex];
array[rlIndex] = pv;
return rlIndex;
}
}
6. 二分查找
折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是：（这里假设数组元素呈升序排列）将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止；如 果x<a[n/2]，则我们只要在数组a的左半部继续搜索x；如果x>a[n/2]，则我们只要在数组a的右 半部继续搜索x。
public class BinarySearch {
@Test
public void binarySearchDemo() {
//二分查找默认有序数组
Integer[] array = {1, 6, 9, 12, 18, 19, 66, 89};
//调用二分查找方法
int index = binarySearch(array, 0, array.length, 12);
System.out.println(index);
}
/**
* 二分查找
* 折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。
* 它的基本思想是：（这里假设数组元素呈升序排列）将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，
* 算法终止；如 果x<a[n/2]，则我们只要在数组a的左半部继续搜索x；如果x>a[n/2]，则我们只要在数组a的右 半部继续搜索x。
*
* @param array
* @param leftRange 左边界
* @param rightRange 右边界
* @param target 目标元素
* @return
*/
public int binarySearch(Integer[] array, Integer leftRange, Integer rightRange, Integer target) {
while (rightRange >= leftRange) {
//获取中间索引位置 防止整数溢出
int middleIndex = (leftRange + rightRange) >>> 1; // 第一种解决办法
//推导：middleIndex = (leftRange + rightRange)/2 ==>leftRange - leftRange/2 + rightRange/2 ==>leftRange + (rightRange - leftRange) / 2;
// int middleIndex = leftRange + (rightRange - leftRange) / 2; // 第二解决办法
if (array[middleIndex] == target) {//中间值与目标值正好相等
return middleIndex;
} else if (array[middleIndex] < target) {//中间值小于目标值
leftRange = middleIndex + 1; // 设置左边界
} else if (array[middleIndex] > target) {//中间值大于目标值
rightRange = middleIndex - 1;// 设置右边界
}
}
return -1;
}
}
扫一扫
854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
