用小组数进行大量随机整数排序，如何实现？

[hiyoung]

如何只用一个大小为10的数组或列表来排序1000个随机整数?要求比较的次数尽量少,可以定义其他变量,但数组或列表之类的集合数据结构只可以用一个(大小为10的数组或列表).可以用Java或C/C++实现.请大家指点下,谢谢。

[nicky_zs]

怎么听起来好像是在叫你模拟外部排序？

[acdbxzyw]

如果不是外部排序的话
那么存放这1000个数的数据结构应该可用吧？
我的想法是用递归
把1000个数分成10份
再把每100个数分成10份
...
最后每份1个数，在a[10]数组里排好
返回一层
逐个移动a[10],这样可以把不同的份之间排好

呵呵 瞎想的
轻拍。。。

不对 。。。这用到栈了，不知还道算不算
呵呵

[effective_person]

简单一点吧，别想的太多了
用堆排序吧！
时间 nLog2（n）
空间 o（1）
挺好的。

[acdbxzyw]

空间 1000 + 1 吧?
堆排序


突然想了一下 数据在外部好像也行
每次取进来10个数排序，再放回去

[猫已经找不回了]

mark,想想

[蜥蜴枪王]

帮顶

[acdbxzyw]

[Quote=引用 6 楼 effective_person 的回复:]
C/C++ code
// 看看这个方法吧，那里再开辟空间啊

[/Quote]

不是不能在原有的数据集合结构内排序吗？
堆排序怎么也得有1000个元素空间要用吧
楼主说了 只能用 10个以下的集合 排序这1000个数

[acdbxzyw]

可能是大家理解不同
你的意思是除了这1000数的空间外只需要1个了
我的意思是总共只能用10个以下，不能在1000个数的空间内直接排序

我看楼主好像是我这意思。。。

[hiyoung]

[Quote=引用 10 楼 joanlynnlove 的回复:]
可能是大家理解不同
你的意思是除了这1000数的空间外只需要1个了
我的意思是总共只能用10个以下，不能在1000个数的空间内直接排序

我看楼主好像是我这意思。。。
[/Quote]

谢谢各位,
就是joanlynnlove的意思,原文是这样的:Use any programming language(java, c/c++, python, perl, etc) to sort 1000 integers with only one array or list which can hold only 10 integers. You can use some local/temp variables, but no more collection or list or array structures.
呵呵,还是要谢谢上面的effective_person的C++代码,让我长了不少见识呀,现在我考虑是不是得用外部排序呀~~~~~~~~

[effective_person]

#ifndef _Sort_h
#define _Sort_h
template <typename T>
class Sort                                         // 排序类
{
public:                                            // 静态方法
	static void  InsertSort(T a[], const int size);// 插入排序
	static void  ShellSort (T a[], const int size);// 希尔排序
	static void  BubbleSort(T a[], const int size);// 冒泡排序
	static void  QuickSort (T a[], const int first, const int end);
	                                               // 快速排序
	static void  SelectSort(T a[], const int size);// 选择排序
	static void  HeapSort  (T a[], const int size);// 堆排序
	static void  MergeSort (T a[], const int size);// 归并排序
private:                                           // 划分区域
	static int   Divide_Part  (T a[], int first, int end);
	                                               // 一下是归并排序的内部方法
	static void  Sift         (T a[], int k    , int m  );
	static void  MergeSort_In (T a[], T ta[],    int low,  int high);
	static void  Merge        (T a[], T ta[],    int low,  int mid,  int high);

};
template <typename T>
void Sort<T>::InsertSort(T a[],const int size)
{
	int i;
	int j;                                         // 定义局部变量
	T   temp;

	for(i=1;i<size;i++)                            // 插入排序
	{
		temp=a[i];                                 // 哨兵
		for(j=i-1;a[j]>temp&&j>=0;j--)
			a[j+1]=a[j];
		a[j+1]=temp;                               // 插入到合适的位置
	}
}
template <typename T>
void Sort<T>::ShellSort(T a[],const int size)
{
	int d;                                         // 定义局部变量
	int i;
	T   temp;
	int j;

	for(d=size/2;d>=0;d--)                         // 分组进行插入排序
	{
		for(i=d;i<size;i++)                        // 插入排序，注意步长为d
		{
			temp=a[i];
			for(j=i-d;a[j]>temp&&j>=0;j=j-d)
				a[j+d]=a[j];
			a[j+d]=temp;                           // 将元素插入合适的位置
		}
	}
}
template <typename T>
void Sort<T>::BubbleSort(T a[],const int size)
{
	int i,j;                                       // 定义局部变量
	T   temp;

	for(i=0;i<size;i++)                            // 采用冒泡排序
	{
		for(j=i+1;j<size;j++)
		{
			if(a[i]>a[j])                          // 交换元素
			{
				temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
		}
	}
}
template <typename T>
int Sort<T>::Divide_Part(T a[],int first,int end)
{
	int i=first,j=end-1;                            // 快排，采用划分区域，找到元素合适的位置
	T   temp;

	while(i<j)
	{
		while(i<j&&a[i]<a[j])                       // 右指针左移，直到小于左指针的元素
			j--;
		if(i<j)                                     // 交换元素
		{
			temp=a[i];
			a[i]=a[j];
			a[j]=temp;
			i++;                                    // 左指针右移动
		}
		while(i<j&&a[i]<a[j])                       // 左指针右移，直到大于右指针的元素
			i++;
		if(i<j)                                     // 交换元素
		{
			temp=a[i];
			a[i]=a[j];
			a[j]=temp;
			j--;                                    // 右指针左移 
		}
	}
	return i;                                       // 返回元素找到的合适的位置 
}
template <typename T>
void Sort<T>::QuickSort(T a[], const int first,const int end)
{
	int mid;

	if(first<end)                                   // 进行快速排序
	{
		mid=Divide_Part(a,first,end);               // 第一次划分区域
		QuickSort(a,first,mid-1);                   // 递归快排左区域
		QuickSort(a,mid+1,end);                     // 递归快排右区域
	}
}
template <typename T>
void Sort<T>::SelectSort(T a[],const int size)
{
	int i,j;
	T   temp;

	for(i=0;i<size;i++)                              // 每次选择最小的元素放到最前面
	{
		for(j=i;j<size;j++)
		{
			if(a[i]>a[j])
			{
				temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
		}
	}
}
template <typename T>
void Sort<T>::Sift(T a[],int k,int m)               // 建立堆 
{
	int i,j;
	T temp;

	if(k==m)                                        // 叶子不需要建立堆
		return ;
	i=k,j=2*i;                                      // 从右下开始建立堆
	while(j<=m) 
	{
		if(j<m&&a[j]<a[j+1])                        // 从左右孩子找出最小的元素
			j++;
		if(a[i]>a[j]) 
			break;
		else                                        // 实现父与子的交换
		{
			temp=a[i];
			a[i]=a[j];
			a[j]=temp;	
			i=j;                                    // 建立上一层的堆
			j=2*i;
		}	
	}
}
template <typename T>
void Sort<T>::HeapSort(T a[],int size)              // 堆排序
{ 
	T temp;
	int i=size/2;

	for(;i>=0;i--)                                  // 建立堆
		Sift(a,i,size-1);
	for(i=0;i<size;i++)                             // 交换堆的根与最末一个元素
	{
		temp=a[0];
		a[0]=a[size-i-1];
		a[size-i-1]=temp;
		Sift(a,0,size-i-2);                         // 进行下次的建立堆
	}
}
template<class T>
void Sort<T>::MergeSort(T a[], const int size)      // 归并排序
{
	T *ta;                      

    ta=new T[size];                                 // 开辟同样的空间
    MergeSort_In(a, ta, 0, size-1);                 // 堆排序
    delete []ta;                                    // 回收空间
}
template<class T>
void Sort<T>::MergeSort_In(T a[], T ta[], int low, int high)
{
	int mid;

    if (low<high)                                   // 开始归并排序
	{
        mid=(low+high)/2;                           // 取中间值
        MergeSort_In(a, ta, low, mid);              // 递归左区域
        MergeSort_In(a, ta, mid+1, high);           // 递归右区域
        Merge(a, ta, low, mid, high);               // 合并左右区域
    }
}
template<class T>
void Sort<T>::Merge(T a[], T ta[], int low, int mid, int high)
{
    int i=low, j=mid+1, k=low;

    while (i<=mid && j<=high) 
	{
        if (a[i]<=a[j]) 
            ta[k++]=a[i++];
        else
            ta[k++]=a[j++];
    }

    if (i>mid) 
	{
        while (j<=high)
            ta[k++]=a[j++];
    } 
	else 
	{
        while (i<=mid)
            ta[k++]=a[i++];
    }

    for (k=low; k<=high; ++k)
        a[k]=ta[k];
}

#endif __Sort_h

// 送给你本人的多年的积累吧，贴出了你需要的部分了

#include <iostream>
#include "Sort.h"
#include "time.h"
using namespace std;
void test_Sort();
int main()
{
	//test_linkList();
	//test_Seqstack();
	/*test_Seqlist();*/
	/*test_Linkstack();*/
	/*test_Seqqueue();*/
	//test_Linkqueue();
	/*test_Cirlist();*/
	//test_Binarytree();
	test_Sort();
}

void test_Sort()
{
	int a[1000];
	srand(NULL);
	for(int i=0;i<sizeof(a)/sizeof(*a);i++)
	{
		a[i]=rand()%1000000;
	}
	clock_t begin,end;
	begin=clock();
	Sort<int>::HeapSort(a,sizeof(a)/sizeof(*a));
	end=clock();
	//Sort<int>::SelectSort(a,sizeof(a)/sizeof(*a));
	//Sort<int>::QuickSort(a,0,sizeof(a)/sizeof(*a));
	/*Sort<int>::BubbleSort(a,sizeof(a)/sizeof(*a));*/
	/*Sort<int>::ShellSort(a,sizeof(a)/sizeof(*a));*/
	/*Sort<int>::InsertSort(a,sizeof(a)/sizeof(*a));*/
	/*Sort<int>::MergeSort(a,sizeof(a)/sizeof(*a));*/
	for(int i=0;i<sizeof(a)/sizeof(*a);i++)
		std::cout<<a[i]<<"  ";
	std::cout<<std::endl;
	cout<<end-begin<<endl;
}

[effective_person]

// 看看这个方法吧，那里再开辟空间啊

template <typename T>
void Sort<T>::Sift(T a[],int k,int m)               // 建立堆 
{
    int i,j;
    T temp;

    if(k==m)                                        // 叶子不需要建立堆
        return ;
    i=k,j=2*i;                                      // 从右下开始建立堆
    while(j<=m) 
    {
        if(j<m&&a[j]<a[j+1])                        // 从左右孩子找出最小的元素
            j++;
        if(a[i]>a[j]) 
            break;
        else                                        // 实现父与子的交换
        {
            temp=a[i];
            a[i]=a[j];
            a[j]=temp;    
            i=j;                                    // 建立上一层的堆
            j=2*i;
        }    
    }
}
template <typename T>
void Sort<T>::HeapSort(T a[],int size)              // 堆排序
{ 
    T temp;          
    int i=size/2;

    for(;i>=0;i--)                                  // 建立堆
        Sift(a,i,size-1);
    for(i=0;i<size;i++)                             // 交换堆的根与最末一个元素
    {
        temp=a[0];
        a[0]=a[size-i-1];
        a[size-i-1]=temp;
        Sift(a,0,size-i-2);                         // 进行下次的建立堆
    }
}