八大基础排序算法思路

冒泡排序

1.将数据从第一个开始与下一个数据进行比较，如果第一个数据大，则交换两个数据位置。
2.将第二个数据再与下一个数据进行比较，如果第二个数据大，则交换两个数据位置。
3.以此类推，直到倒数第二个数据和倒数第一个数据比较，如果倒数第二个数据大，则交换两个数据位置。（至此获得最大数据交换到最后，最后一个数据不再参与比较）
4.重复1、2、3步骤

	public static void buble(int[] a){
         int[] beforesort = a;
         int temp;
         for (int i = 0;i < beforesort.length-1;i++)
         {
             for(int j =0;j<beforesort.length-1-i;j++)
             {
                 if(beforesort[j]>beforesort[j+1])
                 {
                     temp=beforesort[j];
                     beforesort[j]=beforesort[j+1];
                     beforesort[j+1]=temp;
                 }
             }
         }
         for(int w:beforesort)
            System.out.println(w);
    }

快速排序

1.取数组第一个元素（可取数组任意元素）为基准
2.将数组中数据依次与第一个数据进行比较，比它小的放在数组中它的左边，比它大的放在数组中它的右边
3.再对它左右数组中元素进行1，2操作，直到最后每个左右数组只剩下一个元素结束。

		quicksort(0,a.length-1,a);
        for(int w:a)
            System.out.println(w);
private static void quicksort(int low, int high, int[] a) {
        if(low>=high) {
            return;
        }
            int base = a[low];
            int i = low, j = high;
            while (i < j) {
                while (a[j] >= base && i < j)
                    j--;
                a[i] = a[j];
                while (a[i] <= base && i < j)
                    i++;
                a[j] = a[i];
            }
            a[i] = base;
            quicksort(low, i - 1, a);
            quicksort(i + 1, high, a);

    }

插入排序

1.将数组中第一个开始当成有序队列，从第二个元素开始与有序队列从后到前进行比较，找到比它小于等于的数插入其后。
2.重复操作到最后一个元素。

public static void insertSort(int[] a)
	{
	    int number=a.length;
	    int[] insertArray=new int[number];
	    insertArray[0]=a[0];
	    for(int i=1;i<number;i++)
	    {
	        int j=i-1;
	        while(j>=0&&a[i]<insertArray[j])
	        {
	            insertArray[j+1]=insertArray[j];
	            j--;
	        }
	        insertArray[j+1]=a[i];
	    }
	    for(int w:insertArray)
            System.out.println(w);
	}

希尔排序(增量递减插入排序)

1.将数组分为（数组长度）/2的若干组，进行插入排序。
2.在依次将数组一直除2，直到为1，分别进行插入排序。

public static void shellSort(int[] a)
    {
        int number=a.length;
        int k;
        for(int i=number/2;i>0;i=i/2)
        {
            for(int j=0;j<number;j++)
            {
                k=j-i;
                while(k>=0 && a[j]<a[k]) {
                    //swap(a[j],a[k]);
                    int temp = a[j];
                    a[j] = a[k];
                    a[k] = temp;
                    k = k - i;
                    j=j-i;
                }

            }
        }
        for(int w:a)
            System.out.println(w);
    }

选择排序

1.从数组中找到最小的，放在数组第一个位置。
2.依次找到次小的，放在上一个最小的后面。

	public static void chooseSort(int[] a)
	{
	    int temp;
	    int min;
	    int j;
	    for(int i=0;i<a.length;i++)
	    {
	        min =a[i];
	        j=i+1;
	        while(j<a.length)
	        {
	            if(a[i]>a[j])
	            {
	                temp=a[i];
	                a[i]=a[j];
	                a[j]=temp;
	            }
	            j++;
	        }
	    }
	    for(int w:a)
            System.out.println(w);
	}