数据结构算法的一些排序笔记

冒泡排序：特点：两两比较 置换，次数会越来越小
时间复杂度：最快：O(N) 最坏O(N^2)
稳定性：稳定 复杂性：简单

for(i=0;i<list.Count-1;i++)
{
  for（j=0;j<lisy.count-1-i;j++）
   {int temp=list[j];
    list[j]=list[i];
    list[i]=temp;
}
}

选择排序： 遍历数组，选择出最小或者最大的 将其存放在已排序的末尾
时间复杂度：最快：O(N) 最坏O(N^2)
稳定性：不稳定 复杂性：直接选择法不复杂，堆排序复杂

for(i=0;i<list.Count-1;i++)
{int min=i;
for(j=i+1,j<list.Count,j++)
{
if(list[min]>list[j]
{
min=j
}
int temp=list[j];
list[i]=list[min];
list[min]=temp;
}

插入排序： 从数组的第二个开始，让其和前一个进行比较
时间复杂度：最快：O(N) 最坏O(N^2)
稳定性：稳定 复杂性：简单

for(int i=1;i<list.Count-1;i++)
{
int nowValue=int[i];
int nowIndex=i-1;
while(nowIndex>=0&&list[nowIndex]>nowValue){
list[nowIndex+1]=list[nowindex]
nowIndex--;
}
list[nowIndex+1]=nowValue;

快速排序：取数组的中间部分，通过比较吧大小分别放在该数两边，然后两边在进行不断比较。

quicksort(list,0,list.count)
static void quicksort(list<int>,int left,int right)
{
int i=left;
int j =right;
int p=list[(left+right)/2]
while(i<r){
while(list[i]<p]){i+=1;}
while(list[r]>p){r-=1}
int temp=list[r];
list[r]=list[i];
if(list[i]==p){i+=1;}
if(list[r]==p){r-=1;}
if(i==r){i+=1;r-=1;}
if(r>left){quicksort(list,left,r);}
if(i<right){quicksort(list,i,right);}
}
}

希尔排序：通关不断的分组进行比较，分组的间隔也会不断的缩小
时间复杂度：最快：O(N) 最坏O(N^2)
稳定性：不稳定 复杂性：复杂

for(int lengh=list.Count/2,lengu>0;lengh/=2)
{
for(int i=lengh;i<lengh.Count;i++)
{
 for(int j=i-lengh;j>=0;j-=leng )
 {
 if[list[j]<list[i]]
{ int temp=list[j]
 list[j]=list[i]
 list[i]=temp;}}}}