各种排序算法

一、插入排序

• 都是将待排序元素插入到前面已经有序的序列中
  1.1直接插入排序（升序结果）
  时间复杂度：最好：O(n),最坏：O(n^2), 平均:O(n^2)
  空间复杂度:O(1);
  稳定性：稳定；

 		int i,j;
        for(i=1;i<arr.length;i++){     //length函数在string.h函数头
            int temp=arr[i];
            j=i-1;
            while(j>=0 && arr[j]>temp){   **//j>=0要先判断 若是arr[j]>0先判断会出现j<0时数组访问越界情况**
                arr[j+1]=arr[j];
                j--;
            }
            arr[j+1]=temp;
        }

1.2折半插入排序 （升序结果）

		时间复杂度：O(n^2)[只改变了比较次数并未改变移动次数所以时间复杂度并未改进，适用数据量不大的排序];
		空间复杂度:O(1);
		稳定性：稳定；

		int temp,low,up,mid;
        int i,j;
        for(i=1;i<arr.length;i++){
            low=0;
            up=i-1;
            temp=arr[i];
            while(low<=up){  //注意等号
                mid=low+(up-low+1)/2;
                if(arr[mid]>temp) up=mid-1;
                else low=mid+1;
            }
            for(j=i-1;j>up;j--) arr[j+1]=arr[j];
            arr[up+1]=temp;
        }

1.2希尔排序 （升序结果）
按某个增量将数据表分成多个子表，在子表中进行直接插入排序，增量一般取为数据长度的一半；

        时间复杂度：约为O(n^1.3),最坏：O(n^2)
		空间复杂度:O(1);
		稳定性：不稳定；

二、交换排序
2.1冒泡排序

    时间复杂度:最坏:O(n^2)，平均时间复杂度:O(n^2)；
	空间复杂度:O(1)
	稳定性：稳定；

        int i,temp;
        boolean flag=false;
        while(!flag){
            flag=true;
            for(i=1;i<arr.length;i++){
                if(arr[i-1]>arr[i]){
                    temp=arr[i];
                    arr[i]=arr[i-1];
                    arr[i-1]=temp;
                    flag=false;
                }
            }
        }

2.2快速排序（升序结果）
	时间复杂度:最好O(nlogn)，最坏:O(n^2)，平均时间复杂度:O(nlogn)；
	空间复杂度:与递归层数有关，最坏是分割成0和n-1的情况，最好的nlogn，平均为nlogn；
	稳定性：不稳定；

    提高算法效率的方法：一、选择一个能均分数据的元素；二、随机选取一个元素作为枢轴元素(利用rand()函数随机产生一个数)；

   int partition(int[] A,int left,int right){
            int temp=A[left];
            while(left<right){
                while(left<right && A[right]>=temp) right--;  //等号不要忘记
                A[left]=A[right];
                while(left<right && A[left]<=temp) left++;
                A[right]=A[left];
            }
            A[left]=temp;
            return left;
        }
    void quicksort(int[] A,int left,int right){
            if(left<right){
                int pos=partition(A,left,right);    //利用pos进行分割数组
                quicksort(A,left,pos-1);
                quicksort(A,pos+1,right);
            }
        }

三、选择排序
3.1简单选择排序

        int i,j,k,temp;
        for(i=0;i<arr.length;i++){
            k=i;
            for(j=i+1;j<arr.length;j++){
                if(arr[j]<arr[k]) k=j;
            }
            if(k!=i){
                temp=arr[i];
                arr[i]=arr[k];
                arr[k]=temp;
            }
        }