一、所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
二、排序算法可以分为内部排序和外部排序。
内部排序是数据记录在内存中进行排序。
外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
常见的内部排序算法有:冒泡排序, 选择排序,插入排序,希尔排序,快速排序,归并排序等.
三、这里主要介绍常见的几种排序算法
1) 冒泡排序low版本
a、冒泡排序，是通过每一次遍历获取最大/最小值
b、将最大值/最小值放在尾部/头部
c、然后除开最大值/最小值，剩下的数据在进行遍历获取最大/最小值
d、代码实现
public classMaoPao {public static void sort(int[] arr){for (int i = 1; i < arr.length; i++) { //第一层for循环,用来控制冒泡的次数
for (int j = 0; j < arr.length-1; j++) { //第二层for循环,用来控制冒泡一层层到最后//如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层
if (arr[j] > arr[j+1] ){int temp =arr[j];
arr[j]= arr[j+1];
arr[j+1] =temp;
}
}
}
}
}
冒泡的bigger版本
在这个版本中,改动了两点
第一点是加入了一个布尔值,判断第二层循环中的调换有没有执行,如果没有进行两两调换,说明后面都已经排好序了,已经不需要再循环了,直接跳出循环,排序结束.
第二点是第二层循环不再循环到arr.length - 1,因为外面的i循环递增一次,说明数组最后就多了一个排好序的大泡泡.第二层循环也就不需要到最末尾一位了,可以提前结束循环
/*** 终极版冒泡排序
* 加入一个布尔变量,如果内循环没有交换值,说明已经排序完成,提前终止
*@paramarr*/
public static void sortPlus(int[] arr){if(arr != null && arr.length > 1){for(int i = 0; i < arr.length - 1; i++){//初始化一个布尔值
boolean flag = true;for(int j = 0; j < arr.length - i - 1 ; j++){if(arr[j] > arr[j+1]){//调换
inttemp;
temp=arr[j];
arr[j]= arr[j+1];
arr[j+1] =temp;//改变flag
flag = false;
}
}if(flag){break;
}
}
}
}
2)选择排序
a、将第一个值看成最小值
b、然后和后续的比较找出最小值和下标
c、交换本次遍历的起始值和最小值
d、说明：每次遍历的时候，将前面找出的最小值，看成一个有序的列表，后面的看成无序的列表，然后每次遍历无序列表找出最小值。
e、代码实现
public static voidmain(String[] args) {int arr[] = {6, 5, 3, 2, 4};//选择
for (int i = 0; i < arr.length; i++) {//默认第一个是最小的。
int min =arr[i];//记录最小的下标
int index =i;//通过与后面的数据进行比较得出，最小值和下标
for (int j = i + 1; j < arr.length; j++) {if (min >arr[j]) {
min=arr[j];
index=j;
}
}//然后将最小值与本次循环的，开始值交换
int temp =arr[i];
arr[i]=min;
arr[index]=temp;//说明：将i前面的数据看成一个排好的队列，i后面的看成一个无序队列。每次只需要找无需的最小值，做替换
}
}
3)插入排序
a、默认从第二个数据开始比较。
b、如果第二个数据比第一个小，则交换。然后在用第三个数据比较，如果比前面小，则插入(狡猾)。否则，退出循环
c、说明：默认将第一数据看成有序列表，后面无序的列表循环每一个数据，如果比前面的数据小则插入(交换)。否则退出。
d、代码实现
public static voidmain(String[] args) {int arr[] = {7, 5, 3, 2, 4};//插入排序
for (int i = 1; i < arr.length; i++) {//外层循环，从第二个开始比较
for (int j = i; j > 0; j--) {//内存循环，与前面排好序的数据比较，如果后面的数据小于前面的则交换
if (arr[j] < arr[j - 1]) {int temp = arr[j - 1];
arr[j- 1] =arr[j];
arr[j]=temp;
}else{//如果不小于，说明插入完毕，退出内层循环
break;
}
}
}
}
4)希尔排序(插入排序变种版)
a、基本上和插入排序一样的道理
b、不一样的地方在于，每次循环的步长，通过减半的方式来实现
c、说明：基本原理和插入排序类似，不一样的地方在于。通过间隔多个数据来进行插入排序。
d、代码实现
public static voidmain(String[] args) {int arr[] = {7, 5, 3, 2, 4};//希尔排序(插入排序变种版)
for (int i = arr.length / 2; i > 0; i /= 2) {//i层循环控制步长
for (int j = i; j < arr.length; j++) {//j控制无序端的起始位置
for (int k = j; k > 0 && k - i >= 0; k -=i) {if (arr[k] < arr[k -i]) {int temp = arr[k -i];
arr[k- i] =arr[k];
arr[k]=temp;
}else{break;
}
}
}//j,k为插入排序，不过步长为i
}
}
5)堆排序(后补的)
堆排序时间复杂度(O(nlogn)),不是稳定的排序法.空间复杂度O(1).
关于堆排序可自行在网上搜索详细步骤,这里只是附上代码:
public static voidmain(String[] args) {int[] arr = {1,3,9,7,3,5,0,25,15,34};
heapSort(arr);for(int i = 0 ; i < arr.length;i++) {
System.out.println("排序后: "+arr[i]);
}
}private static void heapSort(int[] arr) {if(arr == null || arr.length <=1) {return;
}//建立最大堆;
buildMaxHeap(arr);for(int i = arr.length-1;i>=1;i--) {//最大的在0位置,那么,每次交换最大值放到最后面.
swap(arr,0,i);//获取0位置最大值
maxHeap(arr,i,0);
}
}//创建大堆
private static void buildMaxHeap(int[] arr) {int half = (arr.length-1)/2;//树知道一半,其他的节点就都知道//从向想上遍历
for(int i = half;i>=0;i--) {//大堆
maxHeap(arr,arr.length,i);
}
}private static void maxHeap(int[] arr, int heapSize, intindex) {int left =2*index+1;int right = 2*index+2;int largest =index;if(left < heapSize && arr[left] >arr[index]) {
largest=left;
}if(right < heapSize && arr[right] >arr[largest]) {
largest=right;
}if(index !=largest) {
swap(arr,largest,index);
maxHeap(arr,heapSize,largest);
}
}private static void swap(int[] arr, int index1, intindex2) {int temp =arr[index1];
arr[index1]=arr[index2];
arr[index2]=temp;
}
6)快速排序
a、确认列表第一个数据为中间值，第一个值看成空缺(低指针空缺)。
b、然后在剩下的队列中，看成有左右两个指针(高低)。
c、开始高指针向左移动，如果遇到小于中间值的数据，则将这个数据赋值到低指针空缺，并且将高指针的数据看成空缺值(高指针空缺)。然后先向右移动一下低指针，并且切换低指针移动。
d、当低指针移动到大于中间值的时候，赋值到高指针空缺的地方。然后先高指针向左移动，并且切换高指针移动。重复c、d操作。
e、直到高指针和低指针相等时退出，并且将中间值赋值给对应指针位置。
f、然后将中间值的左右两边看成行的列表，进行快速排序操作。
g、代码实现
public classSort {public static voidmain(String[] args) {int arr[] = {7, 5, 3, 2, 4, 1, 8, 9, 6};//快速排序
int low = 0;int high = arr.length - 1;
quickSort(arr, low, high);
}public static void quickSort(int[] arr,int begin,intend) {//先定义两个参数接收排序起始值和结束值
int a =begin;int b =end;//先判断a是否大于b
if (a >=b) {//没必要排序
return;
}//基准数,默认设置为第一个值
int x =arr[a];//循环
while (a x,就一直往下找,直到找到后面的值大于x
while (a < b && arr[b] >=x) {
b--;
}//跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值
if (a
arr[a] =arr[b];//排序的起始位置后移一位
a++;
}//从前往后找,找到一个比基准数x大的值,放在最后面arr[b]
while (a < b && arr[a] <=x) {
a++;
}if (a
arr[b]=arr[a];//排序的终止位置前移一位
b--;
}
}//跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a]
arr[a] =x;//调用递归函数,再细分再排序
quickSort(arr,begin,a-1);
quickSort(arr,a+1,end);
}
}
//另一种表达快排
public static void quickSort(int[] arr) {
qsort(arr,0, arr.length - 1);
}private static void qsort(int[] arr, int low, inthigh) {if (low
qsort(arr, low, pivot - 1); //递归排序左子数组
qsort(arr, pivot + 1, high); //递归排序右子数组
}
}private static int partition(int[] arr, int low, inthigh) {int pivot = arr[low]; //枢轴记录
while (low = pivot) --high;
arr[low]= arr[high]; //交换比枢轴小的记录到左端
while (low < high && arr[low] <= pivot) ++low;
arr[high]= arr[low]; //交换比枢轴小的记录到右端
}//扫描完成，枢轴到位
arr[low] =pivot;//返回的是枢轴的位置
returnlow;
}
7)归并排序
a、将列表按照对等的方式进行拆分
b、拆分小最小快的时候，在将最小块按照原来的拆分，进行合并
c、合并的时候，通过左右两块的左边开始比较大小。小的数据放入新的块中
d、说明：简单一点就是先对半拆成最小单位，然后将两半数据合并成一个有序的列表。
e、代码实现
public static voidmain(String[] args) {int arr[] = {7, 5, 3, 2, 4, 1，6};//归并排序
int start = 0;int end = arr.length - 1;
mergeSort(arr, start, end);
}public static void mergeSort(int[] arr, int start, intend) {//判断拆分的不为最小单位
if (end - start > 0) {//再一次拆分，知道拆成一个一个的数据
mergeSort(arr, start, (start + end) / 2);
mergeSort(arr, (start+ end) / 2 + 1, end);//记录开始/结束位置
int left =start;int right = (start + end) / 2 + 1;//记录每个小单位的排序结果
int index = 0;int[] result = new int[end - start + 1];//如果查分后的两块数据，都还存在
while (left <= (start + end) / 2 && right <=end) {//比较两块数据的大小，然后赋值，并且移动下标
if (arr[left] <=arr[right]) {
result[index]=arr[left];
left++;
}else{
result[index]=arr[right];
right++;
}//移动单位记录的下标
index++;
}//当某一块数据不存在了时
while (left <= (start + end) / 2 || right <=end) {//直接赋值到记录下标
if (left <= (start + end) / 2) {
result[index]=arr[left];
left++;
}else{
result[index]=arr[right];
right++;
}
index++;
}//最后将新的数据赋值给原来的列表，并且是对应分块后的下标。
for (int i = start; i <= end; i++) {
arr[i]= result[i -start];
}
}
}
//个人感觉这个更好理解
public static voidmain(String[] args) {int[] arr = {1,3,9,7,3,5,-3,0,25,15,34};
mergeSort(arr,0,arr.length-1);for(int i = 0 ; i < arr.length;i++) {
System.out.println(arr[i]);
}
}public static void mergeSort(int[] a,int left,intright) {if(left
mergeSort(a,left,middle);
mergeSort(a,middle+1,right);
merge(a,left,middle,right);//合并
}
}private static void merge(int[] a, int left, int middle, intright) {int[] tempArray = new int[a.length];int rightStart = middle+1;int tmp =left;int index =left;//比较两个小数组相应下标位置数组的大小,小的先放进新数组
while(left <= middle && rightStart <=right) {if(a[left] <=a[rightStart]) {
tempArray[index++] = a[left++];
}else{
tempArray[index++] = a[rightStart++];
}
}while(left <=middle) {//左边剩下的拷贝剩余的数
tempArray[index++] = a[left++];
}while(rightStart <=right) {//拷贝剩余的数
tempArray[index++] = a[rightStart++];
}while(tmp <=right) {
a[tmp]= tempArray[tmp++];
}
}
归并(后补的,更好理解)
7)其他排序
比如Arrays工具类提供的排序方法。它内部实现也是快速排序
private static void arraysSort(int[] a){
Arrays.sort(a);
}
还有就是将数组转为list,使用集合的排序方法,但是这无异于兜圈子,因为集合底层也是数组
private static void listSort(int[] a){
List integers =Ints.asList(a);
Collections.sort(integers);
integers.toArray(newInteger[a.length]);
}
扫一扫
1213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
