算法练习

//快排
	int partition(int arr[], int left, int right)
	{
		int p_left;
		p_left = left + 1;
		int p_right;
		p_right = right;
		while (p_left <= p_right)
		{
			while (arr[p_left] < arr[left]) p_left++;
			while (arr[p_right] > arr[left]) p_right--;
			if (p_left < p_right)
			{
				swap_Leon(arr, p_left, p_right);
				p_left++;
				p_right--;
			}
			else
			{
				p_left++;
			}

		}
		swap_Leon(arr, p_right, left);
		return p_right;
	}
	void qsort(int arr[], int left, int right)
	{
		if (left > right) return;
		int mid;
		mid = partition(arr, left, right);
		qsort(arr, left, mid - 1);
		qsort(arr, mid + 1, right);
	}
//冒泡排序
void maopao(int arr[],int begin,int end)
{
    for(int i=0;i<=end;i++)
    {
        for(int j=0;j<end-i;j++)
        {
              if(a[j]<a[j+1])
                {
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }        
        }
    }
}
//插入排序
void insert(int arr[],int size)
{
    for(int i=1,i<size;i++)
    {
        int temp=arr[i]//第一个无序的数为arr[1]
        for(int j=0;j<i;j++)
        {
            if(temp<a[j])
            {
                for(int k=i;k>j;k--)
                {
                    a[k]=a[k-1];
                }   
                a[j]=temp;    
                break;         
            }
        }
    }
}
//选择排序
void(int arr[],int size)
{
    for(int i=0;i<size;i++)
    {
        int small=a[i];
        int pos=i;
        for(int j=i;j<size;j++)
        {
            if(arr[j]<small)
            {
                small=arr[j];
                pos=j;
            }
            swap(arr,i,j);
        }
    }
}
//归并排序
void merge(int arr[];int l,int m,int r)
{
    int b[r-l+1];
    int p_l=l;
    int p_b=0;
    int p_r=m+1;
    while(p_l<m&&p_r<r)
    {
        if(arr[p_l]<=arr[p_r])
        {
            b[p_b]=arr[p_1];
            p_b++;
            p_l++;
        }
        else
        {
            b[p_b]=arr[p_r];
            p_b++;
            p_r++;
        }
    }
    while(p_l<=m){b[p_b]=arr[p_l];p_l++;p_b++};
    while(p_r<=r){b[p_b]=arr[p_r];p_r++;p_b++};
    int p_b=0;
    for(int i=l;j<=r;i++)
    {
        a[i]=b[p_b];
        p_b++;
    }
}

void mergesort(int arr[],int l,int r)
{
    int mid;
    if(r>l)
    {    
        mid=(l+r)/2;
        mergesort(arr,l,mid);
        mergesort(arr,mid+1;r);
        merge(l,m,r);

    }
}

//最大堆排序
//TODO

//桶排序
//TODO

//二叉树的非递归排序
//前序遍历
void pre_travel(TreeNode* root)
{
    if(!root) return;
    stack<TreeNode*> data;
    data.push_back(root);
    travel(root);
    TreeNode* p_Last=nullptr;
    while(data.empty)
    {
        TreeNode* p_Cur=s.top();
        if(p_Cur->left&&p_Cur->left!=p_Last&&p_Cur->right!=p_Last)
        {
            data.push_back(p_Cur->left);
            travel(p_Cur->left);
        }
        else if(p->Cur->right&&p_Cur->right!=p_Last&&(!p_Cur->left||p_Cur->left==p_Last))
        {
            data.push_back(p_Cur->right);
            travel(p_Cur->right);
        }
        else
        {
            p_Last=data.top();
            data.pop();
        }
)
    }
}
//中序遍历
void pre_travel(TreeNode* root)
{
    if(!root) return;
    stack<TreeNode*> data;
    data.push_back(root);
    travel(root);
    TreeNode* p_Last=nullptr;
    while(data.empty)
    {
        TreeNode* p_Cur=s.top();
        if(p_Cur->left&&p_Cur->left!=p_Last&&p_Cur->right!=p_Last)
        {
            data.push_back(p_Cur->left);
        }
        else if(p->Cur->right&&p_Cur->right!=p_Last&&(!p_Cur->left||p_Cur->left==p_Last))
        {
            data.push_back(p_Cur->right);
            travel(p_Cur);     
        travel(p_Cur);
        }
        else
        {
            p_Last=data.top();
            if(!p_Cur->right)
            {
                travel(data.top());
            }
            data.pop();
            
        }
)
    }
}

//后序遍历
void pre_travel(TreeNode* root)
{
    if(!root) return;
    stack<TreeNode*> data;
    data.push_back(root);
    travel(root);
    TreeNode* p_Last=nullptr;
    while(data.empty)
    {
        TreeNode* p_Cur=s.top();
        if(p_Cur->left&&p_Cur->left!=p_Last&&p_Cur->right!=p_Last)
        {
            data.push_back(p_Cur->left);
        }
        else if(p->Cur->right&&p_Cur->right!=p_Last&&(!p_Cur->left||p_Cur->left==p_Last))
        {
            data.push_back(p_Cur->right);  
        }
        else
        {
            p_Last=data.top();
            travel(data.top());
            data.pop();
            
        }
)
    }
}

//递归实现
//先序遍历
void pre_traverse(BTree pTree)
{
	if(pTree)
	{
		travel(pTree->data);
		if(pTree->pLchild)
			pre_traverse(pTree->pLchild);
		if(pTree->pRchild)
			pre_traverse(pTree->pRchild);	
	}
}
//中序遍历
void in_traverse(BTree pTree)
{
	if(pTree)
	{
		if(pTree->pLchild)
                    in_traverse(pTree->pLchild);
                travel(pTree);
		if(pTree->pRchild)
                    in_traverse(pTree->-RChild);
	}
}
//后序遍历
void beh_traverse(BTree pTree)
{
	if(pTree)
	{
		if(pTree->pLchild)
                    beh_traverse(pTree->pLchild);
		if(pTree->pRchild)
                    beh_traverse(pTree->pRchild);
                travel(pTree);
	}
}