冒泡排序
介绍
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法描述
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
代码实现
/**
* 冒泡排序 大的数字往右边移动 大的泡泡往右边冒
*/
public class BubbleSort {
public static void main(String[] args) {
int [] a = {3,6,1,2,5};
//开始排序
bubbleSort(a);
for(int i = 0; i<a.length;i++){
System.out.println(a[i]);
}
}
public static int[] bubbleSort(int[] arr){
if (arr.length == 0) return arr;
for (int i =arr.length-1;i>0;i--){
for (int j=0;j<i;j++){
if (arr[j]>arr[j+1]){
// 交换位置
int temp;
temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
}
选择排序
介绍
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。选择排序介绍：选择排序
算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
- 初始状态：无序区为R[1…n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
代码实现
/**
* 选择排序 每一轮 选择一个最小或者最大的数 放入 有序区
*/
public class SelectSort {
public static void main(String[] args) {
int[] a = {3, 1, 6, 2, 5};
//选择排序
selectSort(a);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
public static int[] selectSort(int[] arr){
if (arr.length == 0 ) return arr ;
for (int i=0;i<arr.length-1;i++){
int min = i;
for (int j=i+1;j<arr.length;j++){
if (arr[j]<arr[min]){
min = j; // 选择一个最小或者最大的数的下标
}
}
// 放入有序区
if (min!=i){
int temp;
temp=arr[min];
arr[min]=arr[i];
arr[i]=temp;
}
}
return arr;
}
}
快速排序
介绍
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。快速排序：快速排序
算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
代码实现
/**
* 快速排序
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {3,6,5,2,1,86,152,35,75,56};
quickSort(arr,0,arr.length-1);
for(int i = 0; i<arr.length;i++){
System.out.println(arr[i]);
}
}
/**
* 快速排序方法
* @param arr
* @param left
* @param right
* @return
*/
public static int[] quickSort(int[] arr, int left, int right) {
if (arr.length < 1 || left < 0 || right >= arr.length || left > right) return null;
int L = left; // 左比较值,每次从左边界开始
int R = right; // 由6比较值,每次从右边界开始
int pivotIndex = (int) (left + Math.round(Math.random() * (right - left )));
int pivot = arr[pivotIndex]; //得到基准值
while (L<R){
while (arr[L] < pivot) L++; //左比较值 小于 基准值 L往后移
while (arr[R] > pivot) R--; //右比较值 大于 基准值 R往前移
if (L >= R) break; // L与R相遇 跳出循环
swap(arr,L,R); // 交换左比较值与右比较值
if (arr[L] == pivot) R--; // 交换左比较值与右比较值后 左比较值等于基准值 R往前移
if (arr[R] == pivot) L++; // 交换左比较值与右比较值后 右比较值等于基准值 L往后移
}
if (L == R){ // 不写会栈溢出
L++;
R--;
}
if (left < R) quickSort(arr,left,R); // 递归
if (right > L) quickSort(arr,L,right); // 递归
return arr;
}
/**
* 交换数组内两个元素
* @param array
* @param i
* @param j
*/
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
插入排序
介绍
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。插入排序：直接插入排序
算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
代码实现
/**
* 插入排序
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {3,6,5,2,1,86,152,35,75,56};
insertionSort(arr);
for (int i : arr) {
System.out.println(i);
}
}
public static int[] insertionSort(int[] array) {
if (array.length == 0)
return array;
int current;
for (int i = 0; i < array.length - 1; i++) {
current = array[i + 1];
int preIndex = i;
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex];
preIndex--;
}
array[preIndex + 1] = current;
}
return array;
}
}
二分查找法(数组的元素必须有序):
思路:
计算一个数在一段有序数组里面的下标
- 划定界定的左右下标计算出中间值的下标
- 比较该数与中间值,比中间值大,则该中间值下标为左界定下标,比中间值小,则该中间值下标为右界定下标,如果相等直接返回下标,循环条件是左界定下标小于右界定下标
- 没有找到返回-1
代码实现
public class Search {
public static void main(String[] args) {
int[] arr = {1,4,7,8,9,10,14,16,19};
System.out.println(binarySearch(arr,16));
}
public static int binarySearch(int[] array,int key){
int left = 0;
int right = array.length-1;
while (left <= right){
int mid = (left + right) / 2;
if(array[mid] < key){
left = mid + 1;
} else if (array[mid] == key) {
return mid;
}else {
right = mid - 1;
}
}
return -1;
}
}
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
