算法学习Day3排序

排序算法-冒泡排序：

冒泡思想：

比较两个相邻的元素，将值大的元素交换至右端。

思路：
依次比较相邻的两个数，将小数放在前面，大数放在后面。
即在第一趟：
首先比较第1个和第2个数，将小数放前，大数放后。
然后比较第2个数和第3个数，将小数放前，大数放后，
如此继续，直至比较最后两个数，将小数放前，大数放后。
重复第一趟步骤，直至全部排序完成。

核心代码：

//外层循环控制排序的次数
        for (int i = 0; i < arr.length; i++) {
            //内层循环控制每一趟排序次数
            for (int j = 0; j <arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

for (int i = 0; i < arr.length; i++)
控制外层循环控制排序的次数，在每一次排序后，最大的数都会在最右边，所以相当于依次从右边往左边递进。
for (int j = 0; j

 if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }

temp是一个临时存元素的变量。

冒泡复杂度分析：

冒泡排序的优点：
每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

相比于其他排序来说：冒泡可以检测输入序列是否是已经排序的。

用时间复杂度来说：
　
在上述代码中，时间复杂度为O(n2)

改进：
可以通过增加一个附加的标记改进算法，在排序的过程中，没有交换操作表示排序完成。如果序列是有序的，可以通过判断该标记点来结束算法。

 void ButtbleSort(int a[],int n){
        int pass, i ,temp,swapped=1;
        for(pass=n-1;pass>0&&swapped;pass--){
            swapped=0;
            for (i = 0; i <pass; i++) {
                if (a[i]>a[i+1]){
                    temp=a[i];
                    a[i]=a[i+1];
                    a[i+1]=temp;
                    swapped=1;
                }
            }
        }
    }

swapped标记元素，用来查看是否排序。

全部代码（JAVA）：

import java.util.Scanner;
public class 冒泡排序{
    冒泡排序(){
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入个数：");
        int max=scanner.nextInt();
        int arr[]=new int[max];
        System.out.println("依次输入待排序得数：");
        for (int i = 0; i < arr.length; i++) {
            arr[i]= Integer.parseInt(scanner.next());
        }
        System.out.println("排序前：");
        for (int num : arr){
            System.out.print(num+" ");
        }
        //外层循环控制排序的次数
        for (int i = 0; i < arr.length; i++) {
            //内层循环控制每一趟排序次数
            for (int j = 0; j <arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println();
        System.out.println("排序后：");
        for (int num : arr){
            System.out.print(num+" ");
        }
    }
    public static void main(String[] args) {
        冒泡排序 n=new 冒泡排序();
    }

}

Python代码：

list=[]
while True:
    print('排几个数')
    try:
        num=int(input())
        for i in range(num):
            a=int(input("请输入第"+str((i+1))+'个数'))
            list.append(a)
    except ValueError:
        print('error')
    print(list)

    for j in range(len(list)-1):
        for k in range(len(list)-1):
            if list[k]>list[k+1]:
                t=list[k]
                list[k]=list[k+1]
                list[k+1]=t

    # print(sorted(list,reverse=True))


    print(list)