基础排序算法(插入、选择、冒泡)

1.插入排序
基本思想：每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
时间复杂度：最坏O(N^2)，最好O(N)
空间复杂度O(1)

vector<int> insertionSort9(vector<int>& nums) {
        if(nums.size <= 1)
            return nums;
        for(int i = 1; i < nums.size(); i++)
        {
            int v = nums[i];        //临时变量保存nums[i]的值
            int j = i - 1;            
            while(j >= 0 && nums[j] > v)  //在已排序部分寻找插入位置
            {
                nums[j + 1] = nums[j];
                j--;
            }
            nums[j + 1] = v;
        }
        return nums;
    }

2.冒泡排序
基本思想：对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序。
时间复杂度：O(N^2)
空间复杂度：O(1)

   vector<int> bubbleSort(vector<int>& nums) {
      if(nums.size() <= 1)
          return nums;
      bool flag = true;
      for(int i = 0; flag; i++)
      {
          flag = false;
          for(int j = nums.size() - 1; j >= i + 1; j--)
          {
              if(nums[j - 1] > nums[j])
              {
                  int temp = nums[j - 1];
                  nums[j - 1] = nums[j];
                  nums[j] = temp;
                  flag = true;
              }
          }
      }
      return nums;
  }

3.选择排序
基本思想：基本思想为每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。
时间复杂度：O(N^2)
空间复杂度：O(1)

   vector<int> sortArray(vector<int>& nums) {
       
       for(int i = 0; i < nums.size() - 1; i++)
       {
           int minNum = i;
           for(int j = i + 1; j < nums.size(); j++)   //从未排序序列中选取最小值，记录最小值位置
           {
               if(nums[j] < nums[minNum])
               {
                   minNum = j;
               }
           }
            int temp = nums[minNum];   
            nums[minNum] = nums[i];
            nums[i] = temp;
       }
       return nums;
   }
};