• 数据结构与算法-选择&冒泡&快排&计数

        一：选择排序

        场景：找出一个班上身高最高的人你会怎么找？A B C D A B

    选择排序的思路和插入排序非常相似，也分已排序和未排序区间。但选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。但是不像插入排序会移动数组 选择排序会每次进行交换，如以下例子：     

    4 5 6 3 2 1

    第一次：    1 5 6 3 2 4

    第二次：    1 2 6 3 5 4

    1.时间复杂度：O(N^2)

    2.空间复杂度:O(n)

    3.交换次数

    4.稳定性:不稳定

    1. package com.laoyang.新手班;
    2.  
    3. /**
    4.  * @author:Kevin
    5.  * @create: 2023-09-26 19:08
    6.  * @Description: 选择排序  时间： order(n^2)
    7.  */
    8.  
    9. public class selectSort {
    10.  
    11.     public static void main(String[] args) {
    12.         int [] arr = {5,7,23,43,1,2,45,66,32};
    13.         selectSort(arr);
    14.         print(arr);
    15.     }
    16.     public static void print(int[] arr){
    17.         for (int i = 0; i < arr.length; i++) {
    18.             System.out.println(arr[i] + "");
    19.         }
    20.     }
    21.     public static void selectSort(int[] arr){
    22.         if (arr == null && arr.length <2) {
    23.             return;
    24.         }
    25.         int N= arr.length;
    26.         for (int i = 0; i < N; i++) {
    27.             // 0 - n-1
    28.             // 1 - n-1
    29.             // 2 - n-1
    30.             // i - n-1
    31.             int minIndex = i; //最小值下标
    32.             for (int j = i+1;j
    33.                 minIndex = arr[j] < arr[minIndex] ? j : minIndex;
    34.             }
    35.             swap(arr,i,minIndex);
    36.         }
    37.     }
    38.     /**
    39.      * 交换
    40.      * @param arr
    41.      * @param i
    42.      * @param j
    43.      */
    44.     public static void swap(int[] arr,int i,int j){
    45.         int tmp = arr[j];
    46.         arr[j] = arr[i];
    47.         arr[i] = tmp;
    48.     }
    49. }
       二：冒泡排序

            核心思路：冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复n次，就完成了n个数据的排序工作。

            举例说明：4 5 6 3 2 1,从小到大排序。 1 2 3 4 5 6

    进行排序：什么样的情况下不做任何交换了呢，那就是所有的数都在它应该在的位置；O(n)

    1.时间复杂度:O(n^2)

    2.空间复杂度:O(n)

    3.交换次数:挺大的

    4.稳定性:稳定

    1. package Sort2;
    2.  
    3. import java.util.Arrays;
    4.  
    5. /**
    6.  * 冒泡排序
    7.  */
    8.  
    9. public class BubbleSort {
    10.  
    11. 	public static void main(String[] args) {
    12.  
    13. 		int data[] = { 4, 5, 6, 3, 2, 1 };
    14. 		int n = data.length;
    15.  
    16. 		//n-1：这里是因为判断两个数是只比较一次 例如： 1  2   比较次数只会比一次
    17. 		for (int i = 0; i < n - 1; i++) {	//排序的次数
    18. 			//优化：如果所有的数都排好了，不需要交换了，就不需要冒泡了，所以直接退出
    19. 			boolean flag = false;
    20. 			// n-1-i：要减掉i是因为每次冒泡排序都会将后面的值确定，所以i就是后面已经排好的数字，所以就不需要再比较了，所以得减掉
    21. 			for (int j = 0; j < n - 1 - i; j++) {	//具体冒泡 n - 1 - i,6,5,4,3,2,1
    22. 				if (data[j] > data[j + 1]) {
    23. 					//交换
    24. 					int temp = data[j];	//用了第三个变量，不用第三个变量
    25. 					data[j] = data[j + 1];
    26. 					data[j + 1] = temp;
    27. 					flag = true;
    28.  
    29. 					//异或实现
    30. //					data[j] = data[j] ^ data[j+1];
    31. //					data[j+1] = data[j] ^ data[j+1];
    32. //					data[j] = data[j] ^ data[j+1];
    33. 				}
    34. 			}
    35. 			if(!flag) break;
    36. 		}
    37. 		System.out.println(Arrays.toString(data));
    38. 	}
    39. }
    40. /**
    41.  * 下面是交换的时候如果不用第三方变量存储的话如何交换
    42.  */
    43. // a:2 b:3
    44. // 3 2 => a:3 b:2
    45. // 用加减
    46. //a = a + b => a = 3+2 =5;
    47. //b = a - b => b = 5-3 =2;
    48. //a = a - b => a = 5-2 =3;
       2.1 如何进行简单的优化：

                    1.  在交换的时候会需要第三方变量，会占空间，所以可以用异或交换。

                    2. 当排好序了就不需要继续循环了，所以加flag作为标签。

           2.2 如何实现异或交换？

            异或操作可以实现交换两个数字的值的原因是因为异或操作具有以下几个性质：

    1. 任何数和0异或的结果仍然是这个数本身：a ^ 0 = a
    2. 任何数和自身异或的结果是0：a ^ a = 0
    3. 异或操作满足交换律：a ^ b = b ^ a 利用这些性质，我们可以通过异或操作实现交换两个数字的值，具体步骤如下： 假设有两个变量a和b，它们的初始值分别为a0和b0。
    4. 第一步：通过将a与b异或，将结果保存在a中：a = a ^ b。 此时，a的值为a0 ^ b0，b的值保持不变。
    5. 第二步：再将a与b异或，将结果保存在b中：b = a ^ b。 在这一步中，我们可以将上一步得到的a的值(a0 ^ b0)再与b0异或，得到的结果就是a0，即原始的a的值。 同时，由于异或操作满足交换律，所以b = (a0 ^ b0) ^ b0 = a0 ^ (b0 ^ b0) = a0 ^ 0 = a0。 此时，a的值保持不变，b的值变为a0。
    6. 第三步：最后将a与b异或，将结果保存在a中：a = a ^ b。 在这一步中，我们将上一步得到的a的值a0 ^ b0与上一步得到的b的值(a0)异或，得到的结果就是b0。
    1. public class SwapNumbers {
    2.     public static void main(String[] args) {
    3.         int a = 10;
    4.         int b = 20;
    5.         
    6.         System.out.println("交换前：");
    7.         System.out.println("a = " + a);
    8.         System.out.println("b = " + b);
    9.         
    10.         // 使用异或操作交换a和b的值
    11.         a = a ^ b;
    12.         b = a ^ b;
    13.         a = a ^ b;
    14.         
    15.         System.out.println("交换后：");
    16.         System.out.println("a = " + a);
    17.         System.out.println("b = " + b);
    18.     }
    19. }
            三： 快速排序

    45 28 80 90 50 16 100 10

    基准数：一般就是取要排序序列的第一个。

    第一次排序基准数：45

    从后面往前找到比基准数小的数进行对换： 10 28 80 90 50 16 100 45

    从前面往后面找比基准数大的进行对换： 10 28 45 90 50 16 100 80    

       10 28 16 90 50 45 100 80  

       10 28 16 45 50 90 100 80

    以基准数分为3部分，左边的比之小，右边比之大：

    {10 28 16} 45 {50 90 100 80}

    到此第一次以45位基准数的排序完成。

    1.时间复杂度:nlogn 最坏的情况就是O(n^2)

    2.空间复杂度:O(n)

    3.稳定性：不稳定

    4.快排和归并的对比：

    （1）归并排序的处理过程是由下到上的，先处理子问题，然后再合并。

    （2）快排其实就是从上到下，先分区，在处理子问题，不用合并。 其优化就是优化基准数,提供一个取三个数中间的思路.

    1. package Sort2;
    2.  
    3. public class QuiklySort {
    4.  
    5. 	public static void qSort(int data[], int left, int right) {
    6.  
    7. 		int base = data[left]; // 就是我们的基准数，取序列的第一个,不能用data[0]
    8. 		int ll = left; // 表示的是从左边找的位置
    9. 		int rr = right; // 表示从右边开始找的位置
    10. 		while (ll < rr) {
    11. 			// 从后面往前找比基准数小的数
    12. 			while (ll < rr && data[rr] >= base) {
    13. 				rr--;
    14. 			}
    15. 			//这里有个小技巧，如果ll < rr为true，说明 data[rr] >= base = false，就找到比基准数小的，就要交换
    16. 			if (ll < rr) { // 表示是找到有比之大的
    17. 				int temp = data[rr];
    18. 				data[rr] = data[ll];
    19. 				data[ll] = temp;
    20. 				ll++;
    21. 			}
    22. 			// 从前面往后找比基准数大的数
    23. 			while (ll < rr && data[ll] <= base) {
    24. 				ll++;
    25. 			}
    26. 			if (ll < rr) {
    27. 				int temp = data[rr];
    28. 				data[rr] = data[ll];
    29. 				data[ll] = temp;
    30. 				rr--;
    31. 			}
    32. 		}
    33. 		// 肯定是递归 分成了三部分,左右继续快排，注意要加条件不然递归就栈溢出了
    34. 		//ll:循环终止时为基准数在最中间,然后将ll左右两部分继续递归
    35. 		if (left < ll)
    36. 			qSort(data, left, ll - 1);
    37. 		if (ll < right)
    38. 			qSort(data, ll + 1, right);
    39.  
    40. 	}
    41. }
            各种排序比较：

    这么多种排序算法我们究竟应该怎么选择呢？

    1.分析场景：稳定还是不稳定

    2.数据量：数据量小的时候选什么？比如就50个数，优先选插入（5000*5000=25000000）

    3.分析空间： 综上所述，没有一个固定的排序算法，都是要根据情况分析的。但是如果你不会分析的情况下 选择归并或者快排。

            四：计数排序

            如何对一个省200万学生的高考成绩（假设成绩最多只有2位小数，0~900范围）进行排序，用尽可能高效的算法。

    1. package sorttest;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.File;
    5. import java.io.FileInputStream;
    6. import java.io.FileNotFoundException;
    7. import java.io.FileWriter;
    8. import java.io.IOException;
    9. import java.io.InputStreamReader;
    10. import java.io.UnsupportedEncodingException;
    11. import java.io.Writer;
    12.  
    13. /**
    14.  * 如何对一个省200万学生的高考成绩（假设成绩最多只有2位小数，0~900范围）进行排序，用尽可能高效的算法。
    15.  *	计数排序
    16.  */
    17.  
    18. public class CountSort {
    19. 	public static void main(String[] args) throws Exception {
    20. 		String str = null;
    21. 		String fileName = "D:\\JavaCode\\tulin\\src\\sorttest\\200w.txt";
    22. 		InputStreamReader isr = new InputStreamReader(new FileInputStream(fileName), "UTF-8");
    23. 		BufferedReader br = new BufferedReader(isr);
    24. 		int data[] = new int[2100002];
    25. 		int i = 0;
    26. 		//遍历所有的数据存到数组中
    27. 		while ((str = br.readLine()) != null) {
    28. 			double a = Double.valueOf(str);
    29. 			a = a * 100;
    30. 			data[i++] = (int) a;
    31. 			// System.out.println((int) a);
    32. 		}
    33. 		System.out.println("开始值为" + i);
    34. 		long start = System.currentTimeMillis();
    35. 		countSort(data, 0, data.length - 1);
    36. 		System.out.println("结束时间为" + (System.currentTimeMillis() - start) + "ms");
    37. 	}
    38.  
    39. 	public static void countSort(int data[], int min, int max) throws Exception {
    40. 		int counts[] = new int[max + 1];
    41. 		//将所存的数字按照数组下标存储计数，
    42. 		for (int i = 0; i < data.length; i++) {
    43. 			counts[data[i]]++;
    44. 		}
    45.  
    46. 		File file = new File("D:\\JavaCode\\tulin\\src\\sorttest\\200w-csort.txt");
    47. 		Writer out = new FileWriter(file);
    48.  
    49. 		//同时从0开始遍历，所以也默认排好序，直接输出
    50. 		for (int i = 0; i <= max; i++) {
    51. 			if (counts[i] > 0) {
    52. 				for (int j = 0; j < counts[i]; j++) {
    53. 					out.write(((double) (i / 100.0)) + "\r\n");
    54. 				}
    55. 			}
    56. 		}
    57. 		out.close();
    58. 	}
    59. }

  • 相关阅读:
    SP297 AGGRCOW - Aggressive cows
    塑钢门窗三位焊接机中工位设计
    Ruo-Yi 前后端分离防止XSS攻击和自定义可以重复读取InputStream流
    缓和曲线与原曲线任意点坐标计算程序
    异步爬取+多线程+redis构建一个运转丝滑且免费http-ip代理池 (二)
    BERT模型可视化分析总结：BertVi注意力分布与dodrio句法语义分析使用实录
    [管理与领导-111]：IT人看清职场中的隐性规则 - 8 - 顺势而为在职场中的应用
    java计算机毕业设计师大家教中心管理系统源程序+mysql+系统+lw文档+远程调试
    【mysql】复杂语句的分析过程
    北京互联网公司、外企、国企大盘点
  • 原文地址：https://blog.csdn.net/qq_67801847/article/details/132692649