归并排序,还有非递归方式没写

#include <iostream>
using namespace std;
void Merge(int SR[],int i,int m,int n)//n表示数组中最后一个元素的下标,i表示第一个元素的下标,m表示前一个数组最后一个元素的下标
{
    int *TR=new int[n-i+1];
    int ptr1=i;
    int ptr2=m+1;
    int j=0;
    while(ptr1<=m&&ptr2<=n)//可能有一个没有完
    {
        if(SR[ptr1]<=SR[ptr2])
        {
            TR[j++]=SR[ptr1++];
        }
        else{
            TR[j++]=SR[ptr2++];
        }
    }
    while(ptr1<=m)//此处为m!!!
    {
        TR[j++]=SR[ptr1++];
    }
    while(ptr2<=n)//此处为n!!!
    {
        TR[j++]=SR[ptr2++];
    }
    //for(int j=0;j<n-i+1;j++)
    //{
    //    cout<<TR[j];//j写成i了!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    //}
    int ptr=i;
    for(int j=0;j<n-i+1;j++)//此处j<n-i+1而不是n
    {
        SR[ptr++]=TR[j];
    }

}
void MSort(int SR[],int s,int t)
{
    if(s!=t)
    {
        int m=(s+t)/2;
        MSort(SR,s,m);
        MSort(SR,m+1,t);//加一
        Merge(SR,s,m,t);
    }
}

int main()
{
    int arr[]={4,2,1,9,2,5,7,8,10,34,5436,54,3235,435,435,4,3};
    //Merge(arr,3,3,4);
    //cout<<sizeof(arr)/sizeof(arr[0]);

    MSort(arr,0,16);
    for(int i=0;i<17;i++)
    {
        cout<<" "<<arr[i];
    }

    getchar();
    return 0;
}
时间: 2024-11-05 00:11:22

归并排序,还有非递归方式没写的相关文章

归并排序 非递归 不回写

#include<iostream>using namespace std;void Merge(int a[],int b[],int first,int mid,int last)//合并两个有序数组{ int p=first,q=mid+1; int pos=first; while(p<=mid&&q<=last) { if(a[p]<a[q]) { b[pos++]=a[p++]; } else { b[pos++]=a[q++]; } } if(p

图算法 - 只需“五步” ,获取两节点间的所有路径(非递归方式)

在实现 “图” 数据结构时,会遇到 “获取两点之间是所有路径” 这个算法问题,网上的资料大多都是利用递归算法来实现(见文末的参考文章). 我们知道在 JS 中用递归算法很容易会让调用栈溢出,为了能在生产环境中使用,必须要用非递归方式的去实现. 经过一番探索,实现的思路主要来自文章 <求两点间所有路径的遍历算法> ,只是该文中并没有给出具体的实现细节,需要自己去实现:最终本文的实现结合类似<算法 - 调度场算法(Shunting Yard Algorithm)> 中所提及的双栈来完成

快速排序 归并排序的非递归版本 备忘

首先,归并排序,分治,递归解决小的范围,再合并两个有序的小范围数组,便得到整个有序的数组. 这是很适合用递归来写的,至于非递归,便是从小到大,各个击破,从而使得整个数组有序.代码如下: void merge(vector<int> &A, int left, int mid, int right) { int i=left,j=mid+1; vector<int> tmp(right-left+1,0); int k=0; while(i<=mid&&

二叉树(3)----后序遍历,递归和非递归方式

1.二叉树定义 typedef struct BTreeNodeElement_t_ { void *data; } BTreeNodeElement_t; typedef struct BTreeNode_t_ { BTreeNodeElement_t *m_pElemt; struct BTreeNode_t_ *m_pLeft; struct BTreeNode_t_ *m_pRight; } BTreeNode_t; 2.后序遍历 定义: 给定根节点,首先遍历左子树,然后遍历右子树,最后

链表反转(递归方式,非递归方式)

//非递归方式进行链表反转 public ListNode reverseList(ListNode head){ if(head==null||head.next==null){ return head; }else { ListNode pre=head; ListNode p=head.next; ListNode next=null; while (p!=null) { next=p.next; p.next=pre; pre=p; p=next; } head.next=null; r

二叉树(11)----求二叉树的镜像,递归和非递归方式

1.二叉树定义: typedef struct BTreeNodeElement_t_ { void *data; } BTreeNodeElement_t; typedef struct BTreeNode_t_ { BTreeNodeElement_t *m_pElemt; struct BTreeNode_t_ *m_pLeft; struct BTreeNode_t_ *m_pRight; } BTreeNode_t; 2.求二叉树镜像 比如: A                    

非递归方式遍历二叉树

/** * 非递归方式的先根序 * @param root */ public static void preOrder(Node root){ Stack<Node> stack = new Stack<Node>(); while (!stack.isEmpty() || root != null) { while (root != null) { System.out.println(root.data); stack.push(root); root = root.left

数据结构 递归和非递归方式实现二叉树先序、中序和后序遍历

二叉树的先序遍历顺序是根.左.右:中序遍历顺序是左.根.右:后序遍历顺序是左.右.根. 递归方式实现如下: 1 public class TreeNode { 2 private int value; 3 private TreeNode left, right; 4 5 public TreeNode(int data) { 6 value = data; 7 } 8 9 // 递归方式实现先序遍历 10 public void preorder(TreeNode treeNode) { 11

高速排序 归并排序的非递归版本号 备忘

首先,归并排序,分治.递归解决小的范围.再合并两个有序的小范围数组,便得到整个有序的数组. 这是非常适合用递归来写的.至于非递归.便是从小到大.各个击破,从而使得整个数组有序.代码例如以下: void merge(vector<int> &A, int left, int mid, int right) { int i=left,j=mid+1; vector<int> tmp(right-left+1,0); int k=0; while(i<=mid&&a