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)的排序方法:快速排序、堆排序或 归并排序。