选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
public class SelectTest { public static void main(String[] args) { //{1,2,3,4,5}有序数组 int arrays[]={9,6,2,3,5};//任意一个无序数组 //int arrays[]={1,2,3,4,5}; select_sort(arrays); for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]+" "); } } //实现选择排序的函数 /** * 选择要注意的特点:整体比较的次数为数组的长度-1 * 原因是最后的元素无需比较，就已经是最大的元素值了 * @param arrays */ public static void select_sort(int arrays[]){ //整体的比较次数 for (int i = 0; i < arrays.length-1; i++) { //找一个最小的元素下标 int minIndex=i; for (int j = i+1; j < arrays.length; j++) { //如果在数组的剩余元素中 还存在着比MinIndex对应更小的元素 //将minIndex的值重新赋值 if(arrays[j]<arrays[minIndex]){ minIndex=j; } } if(minIndex!=i){//不满足此条件证明arrays[i]已经是最小的元素值了 不发生交换 System.out.println("hello"); //元素值交换的过程 int temp=arrays[i]; arrays[i]=arrays[minIndex]; arrays[minIndex]=temp; } } } }
插入排序
插入排序:以数组左边的第一个元素视为有序列表，将右侧剩余的元素进行插入操作
如果插入的第一个元素比左侧的元素值要小 那么就将该元素的值放置到最左侧
public class InsertSort { public static void main(String[] args) { //{1,2,3,4,5}有序数组 int arrays[]={9,6,2,3,5};//任意一个无序数组 //int arrays[]={1,2,3,4,5}; insert_sort(arrays); for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]+" "); } } /** * 外层循环第一次执行 * i=1 k=0(有序列表) * temp=6 * arrays[k]=9 {9,6,2,3,5} 后移过的结果 {9,9,2,3,5} * k-- k=-1 k+1 * 1 声明临时变量 保存无序列表中的第一个元素的值 * 2 临时变量和有序列表中的元素进行对比(全部对比) 找到了要插入的位置 * 3 真正的插入操作 * * @param arrays */ private static void insert_sort(int[] arrays) { //条件需要改吗？ for (int i = 1; i < arrays.length; i++) { //第一次要区分有序部分和无序部分 将数组下表为0的元素视为有效元素 //后续的元素:无序元素 int k=i-1;//当前元素的前一个元素的下标 int temp=arrays[i];//将要比较的变量放置到临时变量中 for (; k>=0&&arrays[k]>temp;k--) { //元素后移的操作 arrays[k+1]=arrays[k]; } arrays[k+1]=temp;//插入动作 } } }
冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
-
function bubbleSort(arr) { var len = arr.length; for (var i = 0; i < len - 1; i++) { for (var j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j+1]) { // 相邻元素两两对比 var temp = arr[j+1]; // 元素交换 arr[j+1] = arr[j]; arr[j] = temp; } } } return arr; }
希尔排序
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
function shellSort(arr) { var len = arr.length; for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) { // 注意：这里和动图演示的不一样，动图是分组执行，实际操作是多个分组交替执行 for (var i = gap; i < len; i++) { var j = i; var current = arr[i]; while (j - gap >= 0 && current < arr[j - gap]) { arr[j] = arr[j - gap]; j = j - gap; } arr[j] = current; } } return arr; }
计数排序
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
1.找出待排序的数组中最大和最小的元素；
2.统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
4.反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
public class CountSortTest { public static void main(String[] args) { // 长度为20的0~10之间的随机数组 int arrays[] = { 9, 8, 2, 3, 5, 4, 9, 7, 1, 10, 0, 6, 9, 7, 10, 8, 3, 2, 1, 4 }; countSort(arrays); for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]+" "); } } private static void countSort(int[] arrays) { //真正实现计数排序逻辑 int len=arrays.length; //20 int max=arrays[0];//将数组中的第一个元素视为最大值 for (int i = 1; i < len; i++) { //找到数组中真正的那个最大值 if(max<arrays[i]){ max=arrays[i];//打擂思想 } } //创建一个下标为从0~10这样的数组 长度为11 int nums[]=new int[max+1]; //arrays数组中的每个元素都是nums数组的下标 //nums=[1, 2, 2, 2, 2, 1, 1, 2, 2, 3, 2] for (int i = 0; i < arrays.length; i++) { nums[arrays[i]]++;//nums[9]++ 三次 nums[9] 0==>3 } int k=0;//作为我们一会的迭代变量 i 0~10 //外层循环变量:索引 随机数组中的元素 for (int i = 0; i < nums.length; i++) { //内层循环变量:nums数组的元素 次数 for (int j = nums[i]; j >0; j--) { //k++:++是写在后面的 先操作 再加 arrays[k++]=i;//将无序数列覆盖为有序数列 } } } }
快速排序
什么是快速排序:和归并排序稍微有点类似 也是在这里要获取中间值
基于:中轴元素(保证在中轴元素左侧 所有的元素均小于该中轴元素
保证在中轴元素的右侧 所有的元素均大于该中轴元素)
public class QuickSortTest { public static void main(String[] args) { int arrays[]={1,3,5,7,2,4,6,8};//要排序的数组 quickSort(arrays,0,arrays.length-1); for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]+" "); } } /** * @param arrays:要排序的数组 * @param left:左边界 * @param right:右边界 * 停止递归的条件:在左右边界完全相等的情况下 证明数组只剩下一个元素了 * 其必定是中轴元素 (有序) */ private static void quickSort(int[] arrays,int left,int right) { if(left<right){ //编写一个方法: 1 能够找到中轴元素放在合适的位置上 2 返回中轴元素对应的下标位置 int middle=getMiddle(arrays,left,right); //递归操作 quickSort(arrays, left, middle-1); quickSort(arrays, middle+1, right); } } private static int getMiddle(int[] arrays, int left, int right) { //1:默认选择一个元素 作为数组中的中轴元素(左边界的第一个值) int middle=arrays[left]; //2:从默认的中轴元素后的第一个元素开始寻找小于中轴元素的序列 int i=left+1; //3:从数组末尾的元素寻找比中轴元素大的元素 int j=right; // 情况:巧合(恰好选择的中轴元素是最大的)i<=j下标越界的问题 // 巧合(恰好选择的中轴元素是最小的) 中轴元素位置不动 while(true){ while(i<=j&&arrays[i]<middle) i++; while(i<=j&&arrays[j]>middle) j--; if(i>=j)break; //防止的意外情况:中轴元素后的第一个元素本身就比他大 获取比它小的元素进行位置交换 int temp=arrays[i]; arrays[i]=arrays[j]; arrays[j]=temp; } //实现元素交换 把中轴元素middle放在该放的位置上 arrays[left]=arrays[j]; arrays[j]=middle; return j; } }
归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
1.把长度为n的输入序列分成两个长度为n/2的子序列；
2.对这两个子序列分别采用归并排序；
3.将两个排序好的子序列合并成一个最终的排序序列。
public class MergeSortTest { public static void main(String[] args) { //局部数组1和局部数组2都必须是有序的 //[1]和[2] [1,2] 什么时候不能排 left=right left=0 right=1 //[1,2,3,5,7]和[4,6,8,10]=1 2 3 4 5 6 7 8 10 //int arrays[]={1,2,3,5,7,4,6,8,10};//是由两个局部数组构成的大数组 int arrays[]={7,2,3,5,6,1,10};//不是规则数组 递归 dg(arrays,new int[arrays.length],0,arrays.length-1); for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]+" "); } } public static void dg(int arrays[],int temp[],int left,int right){ //middle的值是通过自行计算的 left=right的情况下 只剩下一个了 有序 进行归并 int middle=(left+right)/2; if(left<right){ //实现递归操作 dg(arrays,temp,left,middle); //遍历数组左侧的值 dg(arrays,temp,middle+1,right);//遍历右侧的值 //直到变成元素个数为1的数组的情况下 归并操作 mergeSort(arrays,temp,left,middle,right); } } /** * 在没有做递归的情况下 : left=0 right=length-1 0 right=middle * 注意递归问题:左右边界的开始 * @param arrays:要排序的数组 * @param temp:临时数组 存放已排序好的元素 * @param left:左边界 * @param middle:分割边界 * @param right:右边界 * @return */ private static void mergeSort(int[] arrays, int[] temp, int left, int middle, int right) { //i:局部数组1的下标起始位置 j:局部数组2的下标的起始位置 int i=left,j=middle+1; //递归情况下 要不断 以左边界的位置开始 到右边界结束 for (int k =left; k<=right; k++) { //总共会有四种情况 /** * 为什么是小于等于:稳定排序(排序后元素的位置并没有发生改变) * i++:将++操作写在后面 先赋值再累计 */ if(i>middle){//如果左边的数组的元素已取完 则拼接右侧数组剩余的元素 temp[k]=arrays[j++]; }else if(j>right){ //如果右边的数组的元素已取完 则拼接左侧数组剩余的元素 temp[k]=arrays[i++]; }else if(arrays[i]<=arrays[j]){ temp[k]=arrays[i++];//把较小的元素放置到临时数组 }else{ temp[k]=arrays[j++]; } } //temp已被排序好了 从左边距开始 一直到右边距 对原有数组元素的值进行覆盖 for (int k = left; k <=right; k++) { arrays[k]=temp[k];//把排序好的值覆盖到原数组 } } }
桶排序
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
public class BucketSortTest { public static void main(String[] args) { double arrays[] = { 4.5, 3.14, 2.56, 2.02, 0.5};// 长度为5的随机数组 bucket_sort(arrays); for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i] + " "); } } private static void bucket_sort(double[] arrays) { //声明了最大值和最小值 double max=arrays[0]; double min=arrays[0]; for (int i = 0; i < arrays.length; i++) { if(max<arrays[i]) max=arrays[i]; if(min>arrays[i]) min=arrays[i]; } //获取一下两者的差值 double sub=max-min; //声明一下桶的数量 int bucketNum=arrays.length; //创建数据结构了 二维集合 一个ArrayList 我们把ArrayList集合中的LinkedList作为每一个桶 //声明集合中元素的个数为bucketNum ArrayList<LinkedList<Double>> lists=new ArrayList<LinkedList<Double>>(bucketNum); //初始化一下 for (int i = 0; i < bucketNum; i++) { lists.add(new LinkedList<Double>()); } //向桶中放置元素 思路？ for (int i = 0; i < arrays.length; i++) { //随机元素:arrays[i] //获取随机元素应该放置的下标位置 int int index=(int)((arrays[i]-min)/(sub/(bucketNum-1))); //插入操作 lists.get(index).add(arrays[i]); } //对桶进行局部排序 LinkedList Collections.sort() for (int i = 0; i < lists.size(); i++) { Collections.sort(lists.get(i));//局部排序 } int k=0; //输出回原数组 for (LinkedList<Double> linkedList : lists) { for (Double item : linkedList) {//一个桶中可能保存了多个元素值 //使用有序数列覆盖无序数列 arrays[k++]=item; } } } }
基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
1.取得数组中的最大数，并取得位数；
2.arr为原始数组，从最低位开始取每个位组成radix数组；
3.对radix进行计数排序（利用计数排序适用于小范围数的特点）；
var counter = []; function radixSort(arr, maxDigit) { var mod = 10; var dev = 1; for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) { for(var j = 0; j < arr.length; j++) { var bucket = parseInt((arr[j] % mod) / dev); if(counter[bucket]==null) { counter[bucket] = []; } counter[bucket].push(arr[j]); } var pos = 0; for(var j = 0; j < counter.length; j++) { var value = null; if(counter[j]!=null) { while ((value = counter[j].shift()) != null) { arr[pos++] = value; } } } } return arr; }
堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
var len; // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量 function buildMaxHeap(arr) { // 建立大顶堆 len = arr.length; for (var i = Math.floor(len/2); i >= 0; i--) { heapify(arr, i); } } function heapify(arr, i) { // 堆调整 var left = 2 * i + 1, right = 2 * i + 2, largest = i; if (left < len && arr[left] > arr[largest]) { largest = left; } if (right < len && arr[right] > arr[largest]) { largest = right; } if (largest != i) { swap(arr, i, largest); heapify(arr, largest); } } function swap(arr, i, j) { var temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } function heapSort(arr) { buildMaxHeap(arr); for (var i = arr.length - 1; i > 0; i--) { swap(arr, 0, i); len--; heapify(arr, 0); } return arr; }
posted on
