数据结构--排序--简单排序

1 /*插入排序--是基本排序里面性能比较好的(比较适合基本有序的排序)
 2  *排序的思想：一个序列，前边是有序的，后边是无序的，拿出一个元素进行插入到已经有序
 3  *           的部分(这里就涉及移动的操作)--先找到位置，再移动
 4  *特点：一趟排序下来每个元素的位置可能不是固定的
 5  *时间复杂度：O(N2)
 6  *排序的稳定性：稳定的
 7  *使用场景：数据基本有序的情况下
 8  * */
 9 public class TestInsertSort {
10 
11     public static void main(String[] args) {
12         int[] list1 = {10,8,9,7};
13         insertSort(list1);
14         for(int i = 0; i < list1.length; i++){
15             System.out.print(list1[i] + " ");
16         }
17 
18     }
19     
20     public static void insertSort(int[] list){
21         for(int i = 1; i <list.length; i++){
22             //记录现在被比较的值
23             int temp = list[i];
24             int j = i;
25             //和前面有序的部分比较找到位置插入【满足>0和比前面的元素小】
26             while(j > 0 && list[j-1] > temp){
27                 list[j] = list[j-1];//向右边移动
28                 j--;
29             }
30             list[j] = temp;
31         }
32     }
33 
34 }      

1 /*冒泡排序--属于简单排序
 2  *思想：就是每两个相邻的元素比较-交换直到排完一趟排序，确定出最大的一个元素
 3  *具体实现：需要嵌套循环 
 4  *外循环：控制排序趟数--n-1
 5  *内循环：控制每趟的比较次数n-1/n-2....
 6  *冒泡排序的时间复杂度：O(N2)--比较+交换
 7  *排序的稳定性：指的是存在相同的值的元素排序后相对位置不变
 8  *本质就是较换的条件是：大于而不是大于等于
 9  * */
10 public class TestBubbleSort {
11 
12     public static void main(String[] args) {
13         int[] list = {10, 8,7,9,2,3,1,0};
14         int[] list1 = bubbleSort(list);
15         for(int i = 0; i < list1.length; i++){
16             System.out.print(list1[i] + " ");
17         }
18     }
19     
20     public static int[] bubbleSort(int[] list){
21         //外部循环控制排序的趟数
22         for(int i = 1; i < list.length; i++){
23             //内部比较每趟比较的次数
24             for(int j = 0; j <list.length - i; j++ ){
25                 if(list[j] > list[j+1]){//保证排序的稳定性
26                     int temp = list[j];
27                     list[j] = list[j+1];
28                     list[j+1] = temp;
29                     
30                 }
31             }
32         }
33         return list;
34     }
35     
36     
37 
38 }      

1 /*选择排序--对冒泡排序的一定的改进，减少了较好的次数
 2  *基本思路：将第一个元素与后面的所有元素比较，找到最小的元素与第一个交换
 3  *          完成一次排序，后面依次找出第二小等等
 4  *具体实现：嵌套循环(外控制排序趟数，内控制交换次数)
 5  *选择排序的时间复杂度：O(N2)
 6  *排序的稳定性：稳定
 7  *使用场景：数据量比较小的情况下
 8  * */
 9 public class TestSelectSort {
10 
11     public static void main(String[] args) {
12         int[] list1 = {10,8,0,7,9,7,6,5,4};
13         selectSort(list1);
14         for(int i = 0; i < list1.length; i++){
15             System.out.print(list1[i] + " ");
16         }
17     }
18     
19     //以及有序的不在参与比较【减少较好次数】
20     public static void selectSort(int[] list){
21         for(int i = 0; i < list.length -1; i++){
22             for(int j = i + 1; j < list.length; j++){
23                 if(list[i] > list[j]){
24                     int temp = list[i];
25                     list[i] =list[j];
26                     list[j] = temp;
27                 }
28             }
29         }
30     }
31 
32 }