1.时间复杂度
①一般情况下，算法中的基本操作语句的重复执行次数是时间规模n的某个函数，用T（n）表示，若某个辅助函数f(n),使得当趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n))为算法的渐进复杂度，简称时间复杂度。
②T(n)不同，但是时间复杂度可能相同。如：T(n)=n²+7n+6与T(n)=3n²+2n+2它们的T(n)不同，但是时间复杂度相同，都为O(n²).
2.冒泡排序
冒泡排序的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前向后部，就像水底的气泡一样向上冒。
优化：因为排序的过程中，各个元素不断接近自己的位置，如果一趟比较下来没有进行比较，说明序列有序，因此要在排序过程中设置一个标志判断flag判断元素是否进行交换过，从而减少比较。
代码实现：
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int []arr={5,56,3,89,486,-4,656,446};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
// 冒泡排序方法
public static void bubbleSort(int []arr){
boolean flag=false;// 标识变量，表示是否进行过交换
for(int i=0;i<arr.length-1;i++){
for (int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){ // 如果前面的数比后面的数大，则交换
flag=true;
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
if (!flag){ // 在一趟排序中，一次交换都没有发生过
break;
}else {
flag=false; // 重置flag!!!, 进行下次判断
}
}
}
}
小结：
(1) 一共进行 数组的大小-1 次 大的循环。
(2)每一趟排序的次数在逐渐的减少。
(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。这个就是优化。
3.选择排序
思路：
1. 选择排序一共有 数组大小 - 1 轮排序。
2. 每1轮排序，又是一个循环, 循环的规则(代码)，先假定当前这个数是最小数， 然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标。
3 当遍历到数组的最后时，就得到本轮最小数和下标。
代码实现：
import java.util.Arrays;
public class SelectSort {
public static void main(String[] args) {
int []arr={5,56,3,89,486,-4,656,446,78,98,45,-67};
selectSort(arr);
System.out.println(Arrays.toString(arr));
}
// 选择排序
public static void selectSort(int []arr){
for(int i=0;i<arr.length-1;i++){
int min=i;
for(int j=i+1;j<arr.length;j++){
if(arr[min]>arr[j]){
min=j;
}
}
// 将最小值，放在arr[0], 即交换
if(i!=min){
int temp=arr[i];
arr[i]=arr[min];
arr[min]=temp;
}
}
}
}
4.插入排序
思路：插入排序的基本思路是把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表只包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序依次与有序元素的排序进行比较，将它插入到表中的适当位置，使之成为新的有序表。
代码实现
import java.util.Arrays;
public class InsertSort {
public static void main(String[] args) {
int []arr={5,56,3,89,486,-4,656,446,78,98,45,-67};
insertSort(arr);
System.out.println(Arrays.toString(arr));
}
//插入排序
public static void insertSort(int []arr){
int insertVal = 0;
int insertIndex = 0;
for(int i=1;i<arr.length;i++){
//定义待插入的数
insertVal=arr[i];
insertIndex=i-1;// 给insertVal 找到插入的位置
// 说明
// 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
// 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
// 3. 就需要将 arr[insertIndex] 后移
while(insertIndex>=0&&insertVal<arr[insertIndex]){
arr[insertIndex+1]=arr[insertIndex];
insertIndex-=1;
}
// 当退出while循环时，说明插入的位置找到, insertIndex + 1
// 举例：理解不了，我们一会 debug
//这里我们判断是否需要赋值
if(insertIndex+1!=i){
arr[insertIndex+1]=insertVal;
}
}
}
}
5.希尔排序
希尔排序是希尔于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更加高效的版本，也称之为缩小增量排序。
基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序；随着增量逐渐减少，每组包含的关键次越来越多，当增量减至1时，整个文件恰被分成一组，算法终止。
①采用在插入时采用交换法代码实现：
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int []arr={5,56,3,89,486,-4,656,446,78,98,45,-67};
shellSort(arr);
System.out.println(Arrays.toString(arr));
}
// 希尔排序时， 对有序序列在插入时采用交换法,
public static void shellSort(int []arr){
for(int gap=arr.length/2;gap>0;gap/=2){
for(int i=gap;i<arr.length;i++){
// 遍历各组中所有的元素(共gap组，每组有个元素), 步长gap
for(int j=i-gap;j>=0;j-=gap){
// 如果当前元素大于加上步长后的那个元素，说明交换
if(arr[j]>arr[j+gap]){
int temp=arr[j];
arr[j]=arr[j+gap];
arr[j+gap]=temp;
}
}
}
}
}
}②对交换式的希尔排序进行优化->移位法代代码实现：
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int []arr={5,56,3,89,486,-4,656,446,78,98,45,-67};
shellSort2(arr);
System.out.println(Arrays.toString(arr));
}
public static void shellSort2(int []arr){
for(int gap=arr.length/2;gap>0;gap/=2){
// 从第gap个元素，逐个对其所在的组进行直接插入排序
for (int i=gap;i<arr.length;i++){
int j=i;
int temp=arr[j];
if(arr[j]<arr[j-gap]){
while(j-gap>=0&&temp<arr[j-gap]){
// 移动
arr[j]=arr[j-gap];
j-=gap;
}
//当退出while后，就给temp找到插入的位置
arr[j] = temp;
}
}
}
}
}
6.快速排序
快速排序是对冒泡排序的一种改进。基本思想是通过一趟排序将要排序的数据分割成独立的两个部分，其中一部分的所有数据都比另一个部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
示意图：
代码实现：
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
// int []arr={5,56,3,89,486,-4,656,446,78,98,45,-67};
int []arr={2,423,45,464,43,5,432,42,545,3424,324};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int arr[],int left, int right){
int l=left;// 左下标
int r=right;// 右下标
//pivot 中轴值
int pivot=arr[(right+left)/2];
int temp = 0; //临时变量，作为交换时使用
//while循环的目的是让比pivot 值小放到左边
//比pivot 值大放到右边
while (l<r) {
//在pivot的左边一直找,找到大于等于pivot值,才退出
while (arr[l] < pivot) {
l+=1;
}
//在pivot的右边一直找,找到小于等于pivot值,才退出
while (arr[r] > pivot) {
r-=1;
}
//如果l >= r说明pivot 的左右两的值，已经按照左边全部是
//小于等于pivot值，右边全部是大于等于pivot值
if (l >= r) {
break;
}
// 交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移
if (arr[l] == pivot) {
r--;
}
//如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移
if (arr[r] == pivot) {
l++;
}
}
// 如果 l == r, 必须l++, r--, 否则为出现栈溢出
if (l == r) {
l++;
r--;
}
// 左递归
if(left<r){
quickSort(arr,left,r);
}
// 右递归
if(l<right){
quickSort(arr, l, right);
}
}
}
7.归并排序
归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治策略（分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的答案“修补”在一起，即分而自治之）
我们需要已经有序序列合并成一个有序序列，比如上图中的最后一次合并。
代码实现：
import java.util.Arrays;
public class MergetSort {
public static void main(String[] args) {
int []arr={5,56,3,89,486,-4,656,446,78,98,45,-67};
int temp[] = new int[arr.length]; //归并排序需要一个额外空间
mergeSort(arr,0,arr.length-1,temp);
System.out.println(Arrays.toString(arr));
}
//分+合方法
public static void mergeSort(int []arr,int left,int right,int [] temp){
if(left<right){
int mid=(left+right)/2; //中间索引
//向左递归进行分解
mergeSort(arr,left,mid,temp);
//向右递归进行分解
mergeSort(arr,mid+1,right,temp);
// 合并
merge(arr, left, mid, right, temp);
}
}
/**
*
* @param arr 排序的原始数组
* @param left 左边有序序列的初始索引
* @param mid 中间索引
* @param right 右边索引
* @param temp 做中转的数组
*/
//合并的方法
public static void merge(int []arr,int left, int mid,int right,int[]temp){
int i=left; // 初始化i, 左边有序序列的初始索引
int j=mid+1; //初始化j, 右边有序序列的初始索引
int t=0;// 指向temp数组的当前索引
//(一)
//先把左右两边(有序)的数据按照规则填充到temp数组
//直到左右两边的有序序列，有一边处理完毕为止
while (i<=mid&&j<=right){
//如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
//即将左边的当前元素，填充到 temp数组
//然后 t++, i++
if(arr[i]<=arr[j]){
temp[t]=arr[i];
i++;
t++;
}else {
temp[t]=arr[j];
j++;
t++;
}
}
//(二)
//把有剩余数据的一边的数据依次全部填充到temp
while(i<=mid){//左边的有序序列还有剩余的元素，就全部填充到temp
temp[t]=arr[i];
t++;
i++;
}
while(j<=right){//右边的有序序列还有剩余的元素，就全部填充到temp
temp[t]=arr[j];
t++;
j++;
}
//(三)
//将temp数组的元素拷贝到arr
//注意，并不是每次都拷贝所有
t=0;
int templeft=left;
while(templeft<=right){
arr[templeft]=temp[t];
t++;
templeft++;
}
}
}
8.基数排序
基本思想：将所有代比较数值统一为同样的位数长度，位数较短的前面补零。然后，从最低为开始，依次进行排序。这样从最低排序一直到最高位排序完成以后，数列变成一个有序序列。
代码实现：
import java.util.Arrays;
public class RadixSort {
public static void main(String[] args) {
int []arr={5,56,3,89,486,656,446,78,98,45};
radixSort(arr);
System.out.println(Arrays.toString(arr));
}
//基数排序方法
public static void radixSort(int []arr){
//1. 得到数组中最大的数的位数
int max=arr[0];//假设第一数就是最大数
for(int i=1;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
}
//得到最大数是几位数
int maxlength=(max+"").length();
//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
//说明
//1. 二维数组包含10个一维数组
//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
//3. 名明确，基数排序是使用空间换时间的经典算法
int [][]bucket=new int[10][arr.length];
//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
//可以这里理解
//比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
int []bucketCount=new int[10];
for(int i=0,n=1;i<maxlength;i++,n*=10){
//(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
for(int j=0;j<arr.length;j++){
//取出每个元素的对应位的值
int digitElement=arr[j]/n%10;
bucket[digitElement][bucketCount[digitElement]]=arr[j];
bucketCount[digitElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
int index=0;
//遍历每一桶，并将桶中是数据，放入到原数组
for(int k=0;k<bucketCount.length;k++){
//如果桶中，有数据，我们才放入到原数组
if(bucketCount[k]!=0){
for(int l=0;l<bucketCount[k];l++){
arr[index++]=bucket[k][l];
}
}
//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
bucketCount[k]=0;
}
}
}
}
说明：基数排序是对传统桶排序扩展，速度很快，是经典的空间换时间的方式，占用内存很大，当时海量数据排序时，容易造成OutOfMemory。基数排序稳定的。（假定在待排序的记录序列中，存在多个具有相同关键字记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]之前，而排序后的序列中，r[i]仍在r[j]之前，则这种排序算法是稳定的，否则称为稳定，否则称为不稳定的）有负数的数组，我们不用基数排序来进行排序，如果要支持负数，参考：https://code.i-harness.com/zh-CN/q/e98fa9
9.堆排序
基本思路：
①将无序序列构建一个堆，根据升序降序需求选择大顶堆或小顶堆。
②将堆顶元素末尾元素交换，将最大元素“沉”到数组末端；
③重新调整结构，使其满足堆定义，然后继续交换堆元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
代码实现：
import java.util.Arrays;
public class HeapSort {
public static void main(String[] args) {
int arr[] = {4, 6, 8, 5, 9,-1,-34,42,56,1};
heapSort(arr);
System.out.println(Arrays.toString(arr));
}
//编写一个堆排序的方法
public static void heapSort(int arr[]){
//将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
for(int i=arr.length/2-1;i>=0;i--){
adjustHeap(arr,i,arr.length);
}
/*
* 2).将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
*/
for(int j=arr.length-1;j>0;j--){
int temp=arr[j];
arr[j]=arr[0];
arr[0]=temp;
adjustHeap(arr,0,j);
}
}
//将一个数组(二叉树), 调整成一个大顶堆
/**
* 功能： 完成 将 以 i 对应的非叶子结点的树调整成大顶堆
* 举例 int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6}
* 如果我们再次调用 adjustHeap 传入的是 i = 0 => 得到 {4, 9, 8, 5, 6} => {9,6,8,5, 4}
* @param arr 待调整的数组
* @param i 表示非叶子结点在数组中索引
* @param length 表示对多少个元素继续调整， length 是在逐渐的减少
*/
public static void adjustHeap(int arr[],int i,int length){
int temp=arr[i]; // 临时变量存放最顶端的值
// 1. k = i * 2 + 1 k 是 i结点的左子结点
for(int k=2*i+1;k<length;k=2*k+1){
if(k+1 < length&&arr[k]<arr[k+1]){//说明左子结点的值小于右子结点的值
k++;// k 指向右子结点
}
if(temp<arr[k]){//如果子结点大于父结点
arr[i]=arr[k];//把较大的值赋给当前结点
i=k; // !!! i 指向 k,继续循环比较
}else {
break;
}
}
//当for 循环结束后，我们已经将以i 为父结点的树的最大值，放在了 最顶(局部)
arr[i]=temp;//将temp值放到调整后的位置
}
}
简单的说，堆排序就是将一个无序的数组，首先构建一个大顶堆或小顶堆，然后交换，将这个大顶堆或小顶堆的第一个元素和最后一个元素交换，然后除去这个数组的最后一个元素，将剩下的元素的数组再构建一个新的大顶堆或小顶堆，然后再交换，以此类推，直到剩下最后一个元素。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
