八大排序

1.冒泡排序
思想：两两比较，大的放后面，每一回都能得出最大值放在最后，然后开始新一轮。
解决：两个for循环，第一个用于控制长度，第二个用于比较
时复：O（n*n）
代码：

class BubbleSort {
public:
    int* bubbleSort(int* A, int n) {
        // write code here
        for(int i=n-1;i>0;i--) //用于存每一次的max
        {
            for(int j=0;j<i;j++)  //两两比较
            {
                if(A[j]>A[j+1])
                {
                    int temp = A[j];
                    A[j] = A[j+1];
                    A[j+1] = temp;
                }
            }
        }
        return A;
    }
};

好久没写博客，因为新接了项目，导致一直没写算法，忏悔。

2.选择排序
思想：每次选出最小值
解决：两个for循环，第一个用于控制长度，第二个用于比较，需要一个min和key来记录每次的最小值和位置。
时复：O（n*n）
代码：

class SelectionSort {
public:
    int* selectionSort(int* A, int n) {
        // write code here
        for(int i=0;i<n;i++) //用于控制每一轮的循环和存放每次找出得min
        {
            int min=A[i];
            int key=i;;
            for(int j=i;j<n;j++)
            {
                if(A[j]<min)
                {
                    min=A[j];
                    key=j;
                }
            }
            int temp=A[i];
            A[i]=A[key];
            A[key]=temp;
        }
        return A;
    }
};

2.插入排序
思想：就是不断地把一个数组中的元素，未排序的元素不断插入到已成功排序的队列之中。
解决：用两个循环，外层控制当前需要排序的元素，内层用于对前几个有序数字进行比较。
时复：O（n*n）
代码：

class InsertionSort {
public:
    int* insertionSort(int* A, int n) {
        // write code here
        for(int i=1;i<n;i++)
        {
            for(int j=i;j>0;j--)
            {
                if(A[j]<A[j-1])
                {
                    int temp = A[j];
                    A[j]=A[j-1];
                    A[j-1]=temp;
                }
            }
        }
        return A;
    }
};