排序与时间空间复杂度

简单排序 T(n) = O(n^2) S(n) = O(1)
快速排序 T(n) = O(n^2) S(n) = O(logn)
堆排序 T(n) = O(nlogn) S(n) = O(1)
归并排序 T(n) = O(nlogn) S(n) = O(n)
基数排序 T(n) = O(d(n+r)) S(n) = O®

---

插入算法 T（n）= O(N^2) S(n)=O（1）

public class InsertSort {

	public int[] insertsort(int[] input) {
	
		
		for (int i = 1; i < input.length; i++) {
			
		for(int j=i;j>0;j--) {
			if(input[j]<input[j-1]) {
				input[j]=input[j]^input[j-1];
				input[j-1]=input[j]^input[j-1];
				input[j]=input[j]^input[j-1];
			}
		}
		}
		
		return input;
	}
	public static void main(String[] args) {
		InsertSort test = new InsertSort();
		int[] input= {4,3,2,1};
		int [] result =test.insertsort(input);
		for(int k : result) {
			System.out.print(k);
		}
	}
}

---

希尔排序 代码有问题

public class ShellSort {
	
	
	public int[] sort(int []input) {
		int len = input.length;
		System.out.println(len);
		int half=len/2;
		System.out.println(half);
		for(int i= half;i>=1;i/=2){
			System.out.println("i="+i);
			for(int k : input) {
				System.out.print(k+" ");
				
			}
			System.out.println("\n");
			for(int j=0;j<len-i;j++) {
				if(input[j]>input[j+i] ){
					input[j]=input[j]^input[j+i];
					input[j+i]=input[j]^input[j+i];
					input[j]=input[j]^input[j+i];
				}
				for(int k=0;k<len-i;k++){
					if(input[k]>input[k+i] ){
						input[k]=input[k]^input[k+i];
						input[k+i]=input[k]^input[k+i];
						input[k]=input[k]^input[k+i];
				}
			}
		}
		}
		
		return input;
	}

---

简单选择排序待优化

public class SimpleSelectSort {

	public static int[] sort(int[] input) {
		int len = input.length;
		for (int hpoint = 0; hpoint < len; hpoint++) {
			int min = input[hpoint];
			int index = 0;
			for (int mpoint = hpoint; mpoint < len; mpoint++) {
				if (min >= input[mpoint]) {
					min = input[mpoint];
					index = mpoint;
				}
			}
			int temp = min;
			input[index] = input[hpoint];
			input[hpoint] = temp;
			for (int k : input) {
				System.out.print(k + " ");
			}
			System.out.println("\n");
		}
		return input;
	}
	public static void main(String[] args) {
		int[] input = { 48, 62, 35, 77, 55, 14, 36, 98 };
		int[] a = SimpleSelectSort.sort(input);
		for (int k : a) {
			System.out.print(k + " ");
		}
	}
}

---

经典的冒泡排序

public class BubbleSort {

	public int[] sort(int[] input) {
		int len = input.length;
		for (int outter = 0; outter < len - 1; outter++) {
			for (int inner = 0; inner < len - 1 - outter; inner++) {
				if (input[inner] > input[inner + 1]) {
					input[inner] = input[inner] ^ input[inner + 1];
					input[inner + 1] = input[inner] ^ input[inner + 1];
					input[inner] = input[inner] ^ input[inner + 1];
				}
			}
		}
		return input;
	}
	public static void main(String[] args) {
		int[] input = { 3, 4, 5, 6, 7, 32, 11, 322, 44 };
		BubbleSort test = new BubbleSort();
		int[] result = test.sort(input);
		for (int k : result) {
			System.out.print(k + " ");
		}
	}
}

---

堆排序 我吐了 不知道对不对

public class HSort {
    
    public static void adjustHeap(int []arr,int i,int length) {//数组，调整点，长度
        int temp=arr[i];//记录调整点的值
        for(int k=2*i+1;k<length;k=k*2+1) {从左开始
            if(k+1<length&&arr[k]<arr[k+1]) {如果左小于右 就指向右
                k++;
            }
            if(arr[k]>temp) { //如果子大于调整点，就把子的值给调整点
                arr[i]=arr[k];
                i=k; //记录该子位置。
            }else {
                break;    
            }
        }
        arr[i]=temp;//将调整点的值插到最终的位置
    }
    
    public static void swap(int []arr,int a,int b) {
        int temp=arr[a];
        arr[a]=arr[b];
        arr[b]=temp;
    }
    
    public static void hSort(int []arr) {
        int i;
        //从第一个非叶子节点开始调整
        for(i=arr.length/2-1;i>=0;i--){
                adjustHeap(arr,i,arr.length);
        }
        //交换根元素和第一个元素
        for(i=arr.length-1;i>0;i--) {
            swap(arr, 0, i);
            adjustHeap(arr, 0, i);
        }
    }
    
    public static void main(String[] args) {
        int arr[]=  {6,3,5,23,2,4,5};
        hSort(arr);
        for(int a:arr) {
            System.out.print(a+" ");
        }

---