常用排序算法&二叉树的遍历

目录

摘要：

快速排序

第一种解法：

第二种解法:

归并排序

二叉树的遍历

---

摘要

介绍常见排序算法&二叉树遍历的代码，标注常见的误区

快速排序

时间复杂度为O(nlogn),排序不是稳定的

第一种解法：

public static void sort(int array[],int start,int end)
	{
		if(start<end)
		{
			int mid=partition(array,start,end);
			sort(array,start,mid-1);
			sort(array,mid+1,end);
		}
	}
	public static int partition(int array[],int start,int end)
	{
		int low=start;
		int heigh=end;
		int tem=array[low];
		 System.out.println(array[low]);
		
		while(low<heigh)
		{	
			while(low<heigh&&array[heigh]>=tem)
			{
				heigh--;
			}
			array[low]=array[heigh];
			while(low<heigh&&array[low]<tem)
			{
				low++;
			}
			array[heigh]=array[low];
		}
	  array[low]=tem;
	  return low;
	}

第二种解法:

public static void sort1(int[] nums,int start, int end){
        int low = start;
        int heigh = end;
        if(start>=end){
            return;
        }
        int tem = nums[low];
        while(low < heigh){
            while(low < heigh && nums[heigh] > tem){
                heigh --;
            }
            nums[low] = nums[heigh];
            // "<="不能换成"<",否则会出现死循环
            // "<="在两个while循环中必须出现至少一次
            while(low < heigh && nums[low] <= tem){
                low ++;
            }
            nums[heigh] = nums[low];
            // System.out.println(Arrays.toString(nums));
        }
        nums[low] = tem;
        sort1(nums,start,low-1);
        sort1(nums,low+1,end);
    }

归并排序

时间复杂度为O(nlogn),最坏和平均复杂度都为O(nlogn)，空间复杂度为O(n+logn)，是排序稳定的

package sortAndFind;

public class MergeSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] data = new int[] { 5, 3, 6, 2, 9, 1,8, 4  };  
		int tem[]=new int[data.length];
		sort(data,0,data.length-1,tem);
		print(data);
	}
	public static void sort(int a[],int left,int right,int tem[])
	{
		if(left>=right)
			return;
		int center=(right-left)/2+left;
		sort(a,left,center,tem);
		sort(a,center+1,right,tem);
		merge(a,left,center,right,tem);
		print(a);
	}
	public static  void merge(int a[],int left,int center,int right,int tem[])
	{		
		int mid=center+1;
		int third=left;
		int k=left;
		while(left<=center&&mid<=right)
		{
			if(a[left]<a[mid])
			{
				tem[third++]=a[left++];				
			}
			else
				tem[third++]=a[mid++];
		}
		while(left<=center)
		{
			tem[third++]=a[left++];	
		}
		while(mid<=right)
		{
			tem[third++]=a[mid++];
		}		
		while(k<=right)
		{
			a[k]=tem[k++];
		}
	}
	 public static void print(int[] data) {  
	        for (int i = 0; i < data.length; i++) {  
	            System.out.print(data[i] + "\t");  
	        }  
	        System.out.println();  
	    }  
}

二叉树的遍历

public class TreeNode{
   int val;
   TreeNode left;
   TreeNOde right;

 public TreeNode(int val){
    this.val=val;
  }
}

public class Solution{
//前序递归
  public void preOrder(TreeNode root){
    
    if(root==null)
       return;
    System.out.println(root.val);
    preOrder(root.left);
    preOrder(root.right);

 }
//前序非递归

 public void preOrderNo(TreeNode root){
  
   if(root==null)
    return;
  Stack<TreeNode> stack =new Stak<TreeNode>();
  stack.push(root);
   while(!stack.isEmpty()){
        TreeNode p=stack.pop();
        System.out.println(p.val);
        if(p.right!=null)
          stack.push(p.right);
        if(p.left!=null)
          stack.push(p.left);

  }

//中序序递归
  public void inOrder(TreeNode root){
    
    if(root==null)
       return;
   
    inOrder(root.left);
   System.out.println(root.val);
    inOrder(root.right);

 }
//中序非递归

 public void preOrderNo(TreeNode root){
  
   if(root==null)
    return;
  Stack<TreeNode> stack =new Stak<TreeNode>();
  
  TreeNode p=root;
   while(p!=null||!stack.isEmpty()){

       while(p!=null){
        stack.push(p);
        p=p.left;
     }
      if(!stack.isEmpty()){
        TreeNode p=stack.pop();
        System.out.println(p.val);
        p=p.right;     
    }

  }

 }


//后序递归
  public void postOrder(TreeNode root){
    
    if(root==null)
       return;
   
    postOrder(root.left);
    postOrder(root.right);
   System.out.println(root.val);

 }
//后序非递归

 public void preOrderNo(TreeNode root){
  
   if(root==null)
    return;
  Stack<TreeNode> stack =new Stak<TreeNode>();
  
  TreeNode p=root;
   while(p!=null||!stack.isEmpty()){

       while(p!=null){
        stack.push(p);
        p=p.left;
     }
      if(!stack.isEmpty()){
        TreeNode p=stack.pop();
        System.out.println(p.val);
        p=p.right;     
    }

  }

 }

}