1.冒泡排序：（右边排好序，冒泡出最大（小）值）外面大循环i<size，里面小循环x<size-1-i（小循环每次把一个极值推向右侧，每次循环次数都-1-i）
for(int i=0;i<size;i++)//第i轮
{
bool bHadSwap=false;
for(int x=0;x<size-1-i/*排除本轮可以不用再比较的元素个数*/;x++)
{
if(ndata[x]>ndata[x+1])//相邻元素数据比较
{bHadSwap=true;//如果至少发生过一次交换,意味着数可能后边还没有排好
swap(ndata[x],ndata[x+1]);}
}
if(!bHadSwap)break;//本轮没有再出现数据交换,就认为排序已提前完成
}
============================
2.插入排序：大循环从1开始哦，小循环从i-1开始，条件判断是在小循环的条件判断里面，每次排好左边的序。。用临时变量保存外层循环变量，然后如果通过小循环的条件/
for(int i=1;i<size;i++)//第i个目标位
{
T tmp=ndata[i]; int x;bool bSwap=false;
for(x=i-1;x>=0&&ndata[x]>tmp;x--)
{
ndata[x+1]=ndata[x];
bSwap=true;
}
if(bSwap)ndata[x+1]=tmp;//前面如果有位置移动,而最后一次比较不成功(指向原有的空位x被自减1),意味着tmp里的值可以降下来时必须x+1才是真正的空位
}
=================================
3.选择排序（左边排好序，记住最大（小）下标，然后再交换左边和最小下标值）外面大循环i<size，里面小循环x=i+1;x<size（小循环每次把一个极值推向左侧，每次循环次数都-1-i）
for(int i=0;i<size;i++)//第i个目标位<--最终要存确定值的位
{
int minIdx=i;
for(int x=i+1;x<size;x++)
{
if(ndata[x]<ndata[minIdx])minIdx=x;//确定本轮最小值下标
}
swap(ndata[i],ndata[minIdx]);//最终一次交换
//前面如果有位置移动,而最后一次比较不成功(指向原有的空位x被自减1),意味着tmp里的值可以降下来时必须x+1才是真正的空位
}
O(logN)<O(N)<O(NlogN)<O(N^2)<O(2^N)
二叉树 < 线性 < 快速 < 冒泡、插入、选择 < ..
快速排序：
1.判断参数大否：随机筛选出裁判、把裁判与最后一个元素交换值、用临时变了存一下裁判、从b-1开始循环
2.进入裁判选择：
3.调用自己 2次，1次前，一次后
（每次排完，1.确定了裁判中间数，左边都是小于裁判的数无序的；右边都是大于裁判的数无序的；下一次的比较则不包括裁判在内的左右两侧了）
以下转载：
一、
i p/j
2 8 7 1 3 5 6 4(主元)
j指的2<=4，于是i++，i也指到2，2和2互换，原数组不变。
j后移，直到指向1..
二、
j（指向1）<=4，于是i++
i指向了8，所以8与1交换。
数组变成了：
i j
2 1 7 8 3 5 6 4
三、j后移，指向了3,3<=4，于是i++
i这是指向了7，于是7与3交换。
数组变成了：
i j
2 1 3 8 7 5 6 4
四、j继续后移，发现没有再比4小的数，所以，执行到了最后一步，
即上述PARTITION(A, p, r)代码部分的 第7行。
因此，i后移一个单位，指向了8
i j
2 1 3 8 7 5 6 4
A[i + 1] <-> A[r]，即8与4交换，所以，数组最终变成了如下形式，
2 1 3 4 7 5 6 8
ok，快速排序第一趟完成。
1. sort(){
sortIn(0,size-1);
}
2. sortIn(int p,int r)
{ if(p>r)return;
int index=divies(p,r);
sortIn(p,index-1);
sortIn(index+1, r ) ;
}
3. divies(int p,int r)
{ int index= rand()%(r-p+1)+p;
swap(arr[index],arr[r]);
int i=p-1;
for(int j=p; j<r; j++)
{
if(arr[j] > arr[r])
{ ++i;
swap(arr[j] , arr[i]);
}
}
swap(arr[++i],arr[r]) ;
return i
}