1. 算法概述
-
通常来讲，排序的目的是为了快速查找
-
衡量排序算法的优劣：
1. 时间复杂度：分析关键字的比较次数 和 记录的移动次数
2. 空间复杂度：分析排序算法中需要多少辅助内存
3. 稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。 -
排序算法分类：内部排序和外部排序。
内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。 -
十大内部排序算法：
- 选择排序 ：
直接选择排序、堆排序 - 交换排序 ：
冒泡排序、快速排序 - 插入排序 ：
直接插入排序、折半插入排序、Shell排序 - 归并排序
- 桶式排序
- 基数排序
- 选择排序 ：
2. 算法特征
算法的5大特征：
- 输入（Input）：有0个或多个输入数据，这些输入必须有清楚的描述和定义
- 输出（Output）：至少有1个或多个输出结果，不可以没有输出结果
- 有穷性（有限性，Finiteness）：算法在有限的步骤之后会自动结束而不会无限循环，并且每一个步骤可以在可接受的时间内完成
- 确定性（明确性，Definiteness）：算法中的每一步都有确定的含义，不会出现二义性
- 可行性（有效性，Effectiveness）：算法的每一步都是清楚且可行的，能让用户用纸笔计算而求出答案
3. 冒泡排序
排序思想：
- 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。
public static void main(String[] args) {
int[] arr = new int[]{0,1,8,7,-62,45,-11,35,-48,55,101};
//遍历排序前的数组
for (int a : arr){
System.out.print(a +"\t");
}
System.out.println();
// 外层控制比较次数 n 个元素 比较 n-1
// 内存循环来控在每次比较时的相邻元素的比较和交换
for (int i = arr.length -1 ;i >= 0;i--){ //比较的次数是递减的
for (int j = 0;j < i;j++){ //控制要比较的元素 元素的个数是随着比较的次数变换的
//比较相邻的两个元素
if (arr[j] > arr[j+1]){ //如果左边的大于右边 则需要交换两个元素的位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
// 遍历数组
for (int a : arr){
System.out.print(a +"\t");
}
}
结果截图：
4. 快速排序
排序思想：
- 从数列中挑出一个元素，称为"基准"（pivot），
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后， 该基准就处于数列的中间位置。这个称为分区（partition）操作。
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
- 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代 （iteration）中，它至少会把一个元素摆到它最后的位置去。
public class QuickSort {
public static void main(String[] args) {
int[] arr = new int[]{0,1,8,7,-62,45,54,-11,35,-48,55,101};
quickSort(arr);
printArr(arr);
}
// 快速排序
public static void quickSort(int[] arr) {
if (arr.length <= 1){
return;
}
sort(arr,0,arr.length - 1); //这是第一次
}
// 核心算法
public static void sort(int[] arr,int left,int right){
if (left > right){ //对于传入的参数要判断 不能交叉越界
return;
}
int base = arr[left]; //基准元素
int l = left, r = right;
while (l != r){
//从右往左找
while (arr[r] >= base && l < r){ //从右往左 while结束 就是找见比基准小的元素
r--;
}
//从左往右找
while (arr[l] <= base && l < r){ //找到比基准打的数
l++;
}
if (l < r){
int temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
}
}
// base归回 回到中间位置 此时位于base左边的都是比他小的 位于base右边都是比他大的
arr[left] = arr[l];
arr[l] = base;
sort(arr,left,l - 1);//对左半边进行递归排序
sort(arr,r + 1,right); //对右半边
}
public static void printArr(int[] arr){
for (int a : arr){
System.out.print(a +"\t\t");
}
}
}
5. 选择排序
- 工作原理为：在未排序的序列中找出最小(大)元素与第一个位置的元素交换位置
- 选择排序与冒泡排序的区别：
冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；
选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。然后在剩下的元素中再找最小(大)元素与第二个元素的位置交换，依此类推，直到所有元素排序排序完成。 - 算法简介：
1.初始状态：序列为无序状态。
2.第1次排序：从n个元素中找出最小(大)元素与第1个记录交换
3.第2次排序：从n-1个元素中找出最小(大)元素与第2个记录交换
4.第i次排序：从n-i+1个元素中找出最小(大)元素与第i个记录交换
5.以此类推直到排序完成
public class SelectSort {
public static void main(String[] args) {
int[] arr = new int[]{0,1,8,7,-62,45,54,-11,35,-48,55,101};
System.out.println("排序前的数组：");
printArr(arr);
selectSort(arr);
System.out.println("最终结果：");
printArr(arr);
}
public static void selectSort(int[] arr) {
for (int i = 0;i < arr.length;i++) { //控制比较的次数
int minIndex = i; //minIndex表示 记录最小元素所在的位置 假设每次开始的位置为最小元素
for (int j = i; j < arr.length - 1; j++) { //控制元素之间的比较
if (arr[minIndex] > arr[j]) {
minIndex = j;
}
}
swap(arr,i,minIndex);
System.out.println("第"+ i +"次比较：");
printArr(arr);
}
}
//交换数组中两个元素的位置
private static void swap(int[] arr,int index1,int index2) {
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
public static void printArr(int[] arr){
for (int a : arr){
System.out.print(a +"\t");
}
System.out.println();
}
}
6. 插入排序
- 算法简介：
1.从第一个元素开始，该元素可认为已排序。
2.取出下一个元素，在排序好的元素序列中从后往前扫描
3.如果元素(已排序)大于新元素，将该元素移到下一位置
4.重复3.直到找到已排序的元素小于或等于新元素的位置
5.将新元素插入该位置后
6.重复2-5直到排序完成
public class InsertSort {
public static void main(String[] args) {
int[] arr = new int[]{0,1,8,7,-62,45,54,-11,35,-48,55,101};
insertSort(arr);
}
private static void insertSort(int[] arr) {
for (int i = 0;i < arr.length - 1;i++){
for (int j = i + 1;j > 0;j--){
if (arr[j] < arr[j - 1]){
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j-1] = temp;
}else{ //当后边的元素比前边的元素大或者相等的时候不用交换 直接结束循环
break;
}
}
}
for (int a : arr){
System.out.print(a +"\t");
}
}
}
7. 排序算法的选择
-
(1)若n较小(如n ≤ 50)，可采用直接插入或直接选择排序。 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
-
(2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
-
(3)若n较大，则应采用时间复杂度为O(nlog₂n)的排序方法：快速排序、堆排序或 归并排序。
扫一扫
2899
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
