排序总结

快排

class Solution {
    public int[] sortArray(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;

    }
 public static void quickSort(int[] arr, int low, int high) {
			if (arr == null || arr.length == 0)
				return;
	 
			if (low >= high)
				return;
	 
			// pick the pivot
			int middle = low + ((high - low) >> 1);
			int pivot = arr[middle];
	 
			// make left < pivot and right > pivot
			int i = low, j = high;
			while (i <= j) {
				while (arr[i] < pivot) {
					i++;
				}
	 
				while (arr[j] > pivot) {
					j--;
				}
	 
				if (i <= j) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
					i++;
					j--;
				}
			}
	 
			// recursively sort two sub parts
			if (low < j)
				quickSort(arr, low, j);
	 
			if (high > i)
				quickSort(arr, i, high);
		}
}

归并排序

	static void merge(int []arr,int l,int m,int r) { 
		int i,j,k;
		int n1=m-l+1;
		int n2=r-m;
		int L[]= new int[n1];
		int R[]= new int[n2];
		for( i=0;i<n1;i++)   
			L[i] = arr[l + i]; 
	    for (j = 0; j < n2; j++) 
	        R[j] = arr[m + 1+ j];
	    i=0;j=0;k=l;
	    while(i<n1&&j<n2) {
	    	if(L[i]<=R[j]) {
	    		arr[k]=L[i];
	    		i++;
	    	}
	    	else {
	    		arr[k]=R[j];
	    		j++;
	    	}
	    	k++;
	    }
	    while(i<n1) {
	    	arr[k++]=L[i++];
	    }
	    while(j<n2) {
	    	arr[k++]=R[j++];
	    }
		
}
	static int[]  mergeSort(int []arr,int start,int end) {
		int pivot;
		if(start<end) {
			pivot=(start+end)/2;
			mergeSort(arr, start, pivot);
			mergeSort(arr, pivot+1,end);
			merge(arr,start,pivot,end);
		}
		return arr;
		
	}

堆排序

//第一步先建立大顶堆；
//Second:
//从n-1d到0，分别于当前root元素交换；每一次交换后，再重新heapify；使得当前值最大；
    
public void sort(int arr[]) 
    { 
        int n = arr.length; 
  
        // Build heap (rearrange array) 
        for (int i = n / 2 - 1; i >= 0; i--) 
            heapify(arr, n, i); 
  
        // One by one extract an element from heap 
        for (int i=n-1; i>=0; i--) 
        { 
            // Move current root to end 
            int temp = arr[0]; 
            arr[0] = arr[i]; 
            arr[i] = temp; 
  
            // call max heapify on the reduced heap 
            heapify(arr, i, 0); 
        } 
    } 
  
    // To heapify a subtree rooted with node i which is 
    // an index in arr[]. n is size of heap 
    void heapify(int arr[], int n, int i) 
    { 
        int largest = i; // Initialize largest as root 
        int l = 2*i + 1; // left = 2*i + 1 
        int r = 2*i + 2; // right = 2*i + 2 
  
        // If left child is larger than root 
        if (l < n && arr[l] > arr[largest]) 
            largest = l; 
  
        // If right child is larger than largest so far 
        if (r < n && arr[r] > arr[largest]) 
            largest = r; 
  
        // If largest is not root 
        if (largest != i) 
        { 
            int swap = arr[i]; 
            arr[i] = arr[largest]; 
            arr[largest] = swap; 
  
            // Recursively heapify the affected sub-tree 
            heapify(arr, n, largest); 
        } 
    } 

插入排序

    // 选择排序：每一轮选择最小元素交换到未排定部分的开头
public static int[] inserSort(int[]arr) {
		int n=arr.length;
		for(int i=1;i<n;i++) {
			int j=i-1;
			int inserValue=arr[i];
			while(j>=0&&inserValue<arr[j]) {
				arr[j+1]=arr[j];
				j--;
			} 
			arr[j+1]=inserValue;
		}
		for(int value:arr) {
			System.out.println("inserort"+value);
		}
		return arr;
	}

选择排序

//每次选择一个最小的元素与开头元素交换；
public static void SelectionSort(int []nums) {
	
		for(int i=0;i<nums.length;i++) {
			int minIndex=i;
			for(int j=i+1;j<nums.length;j++) {
				if(nums[j]<nums[minIndex]) {
					min=Math.min(nums[j], min);
					minIndex=j;
				}
			}
				int temp=nums[minIndex];
				nums[minIndex]=nums[i];
				nums[i]=temp;

		}
	
	}

冒泡排序

	//思想是 比较得到一个最大值；像冒泡一样；
	public static int[]  buddleSort(int []arr) {
		int n=arr.length;
		for(int i=0;i<n;i++) {
			for(int j=0;j<n-i-1;j++) {
				if(arr[j+1]<arr[j]) {
					int temp=arr[j+1];
					arr[j+1]=arr[j];
					arr[j]=temp;
				}
			}
		}
		for(int value:arr) {
			System.out.println(value);
		}
		return arr;
	}

链表排序

 public ListNode sortList(ListNode head) {
        if(head == null || head.next == null)return head;
        
        ListNode slow = head;
        ListNode fast = head;
        
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        
        ListNode mid = slow.next;
        slow.next = null;
        
        return merge(sortList(head),sortList(mid));
    }
    
    public ListNode merge(ListNode left,ListNode right){
        ListNode head = new ListNode(0);
        ListNode curr = head;
        
        while(left != null && right != null){
            if(left.val <= right.val){
                curr.next = left;
                left = left.next;
            }else{
                curr.next = right;
                right = right.next;
            }
            curr = curr.next;
        }
        
        if(left != null)
            curr.next = left;
        else if(right != null)
            curr.next = right;
        
        return head.next;
    }