冒泡排序、快速排序、选择排序

1、冒泡排序

原理：临近的两个数字比较，按照从小到大或者从大到小进行排序，一共进行N趟排序（N是数组的长度）
时间复杂度：O(n^2)

@Test
    public void bubbleSort()
    {
int a[]={18,4,26,3,99,54};
int length=a.length;
for(int j=0;j<length;j++)
        {
for(int i=0;i<length-1;i++)
            {
if(a[i]>a[i+1])
                {
int temp=a[i];
                    a[i]=a[i+1];
                    a[i+1]=temp;
                }
            }
        }

for(int i=0;i<length;i++)
        {
            System.out.print(a[i]+" ");
        }
    }

冒泡排序的优化一 (标记法）

    //冒泡排序优化一
//设置一个标记来标志一趟比较是否发送交换
//如果没有发生交换证明已经排好，就跳出循环
    public void bubbleSort1(){
int temp=0;
int flag=0;
int a[] = { 1, 54, 6, 3, 78, };
int length = a.length;
for(int j=0;j<length;j++){
            flag=0;
for(int i=j;i<length-1;i++){
if(a[i]>a[i+1]){
                    flag=1;
                    temp=a[i];
                    a[i]=a[i+1];
                    a[i+1]=temp;
              }
            }
if(flag==0)
break;
        }
    }

冒泡排序的优化二 (标记法）

/* 
 * 冒泡排序优化二 
 * 用一个变量记录下最后一个发生交换的位置，后面没有发生交换的已经有序 
 * 所以可以用这个值来作为下一次比较结束的位置 
 * */  
void bubbleSort2(int arr[], int n) {  
int i = 0;  
int j = 0;  
int k = 0;  
int tmp = 0;  
int flag = n;   

for (i = 0; i < flag; ++i) {  
        k = flag;  
        flag = 0;  
for (j = 0; j < k; ++j) {  
if (arr[j] < arr[j + 1]) {  
                flag = j;  //记录最后交换的位置
                tmp = arr[j];  
                arr[j] = arr[j + 1];  
                arr[j + 1] = tmp;  
            }  
        }  
    }     
}  

---

2、快速排序

时间复杂度：O(n*log2n)

    int AdjustArray(int s[], int l, int r) //返回调整后基准数的位置 
    {  
int i = l, j = r;  
int x = s[l]; //s[l]即s[i]就是第一个坑 
while (i < j)  
        {  
// 从右向左找小于x的数来填s[i] 
while(i < j && s[j] >= x)   
                j--;    
if(i < j)   
            {  
                s[i] = s[j]; //将s[j]填到s[i]中，s[j]就形成了一个新的坑 
                i++;  
            }  

// 从左向右找大于或等于x的数来填s[j] 
while(i < j && s[i] < x)  
                i++;    
if(i < j)   
            {  
                s[j] = s[i]; //将s[i]填到s[j]中，s[i]就形成了一个新的坑 
                j--;  
            }  
        }  
//退出时，i等于j。将x填到这个坑中。 
        s[i] = x;  

return i;  
    }  

再写分治法的代码：

void quick_sort1(int s[], int l, int r)  
{  
if (l < r)  
    {  
int i = AdjustArray(s, l, r);//先成挖坑填数法调整s[] 
        quick_sort1(s, l, i - 1); // 递归调用 
        quick_sort1(s, i + 1, r);  
    }  
}  

组合：

//快速排序 
void quick_sort(int s[], int l, int r)  
{  
if (l < r)  
    {  
//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1 
int i = l, j = r, x = s[l];  
while (i < j)  
        {  
while(i < j && s[j] >= x) // 从右向左找第一个小于x的数 
                j--;    
if(i < j)   
                s[i++] = s[j];  

while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数 
                i++;    
if(i < j)   
                s[j--] = s[i];  
        }  
        s[i] = x;  
        quick_sort(s, l, i - 1); // 递归调用 
        quick_sort(s, i + 1, r);  
    }  
}  

---

3、选择排序

在未排序的的序列遍历出最小值或最大值，然后放在排序序列的起始位置
再从剩下的未排序的序列遍历出最小值，放在排序序列的末尾位置，重复直到所有元素排序完成

public class Select_Sort {

public void SelectSort(int[] a,int n)
    {
int min,temp;
for(int i=0;i<n-1;i++)
        {
            min=i;//查找最小值
for(int j=i+1;j<n;j++){
if(a[min]>a[j])
                {
                    min=j;//查找最小值的位置
                }
            }
if(min!=i)//与原最小值转换，得出新最小值
            {
                temp=a[min];
                a[min]=a[i];
                a[i]=temp;
            }
        }
    }
public static void main(String[] args) {
int a[]={23,32,88,12,29,91};
        Select_Sort ss=new Select_Sort();
int n=a.length;
        ss.SelectSort(a, n);
for(int i=0;i<n;i++)
        {
            System.out.print(a[i]+" ");
        }
    }

}