随机化算法-用数组实现有序递增链表

数组的标号作为地址信息，按照递增的顺序重新存放在link数组中，link数组存放的是下一个元素即下一个大一些的元素的地址。

也可以这样理解，link数组是一种函数映射，实现一次运算，使得原本无序的数组经过link组织后有顺序。

本算法也可以作为插入排序的一部分

书写上用嵌套的[[[....]]]代替链表中->->->.....

 

关键：注重代码过程中是怎么设置link指针的，怎么修改指针的，注意与线性链表对应

 

 

// 搜索有序表.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "targetver.h"
#include <stdio.h>
#include <tchar.h>
#include "stdafx.h"
#include"iostream"
#include<math.h>
#include<time.h>
#include<iomanip>
using namespace std;
const unsigned long maxshort=65535L;
const unsigned long multiplier=1194211693L;
const unsigned long adder=12345L;
class RandomNumber{
private:
 //当前种子
 unsigned long randSeed;
public:
 //构造函数
 RandomNumber(unsigned long s=0);
 unsigned short Random(unsigned long n);
 double fRandom();
};

RandomNumber::RandomNumber(unsigned long s)
{
 if(s==0)
  randSeed=time(0);
 else
  randSeed=s;
}

double RandomNumber::fRandom()
{
 return Random(maxshort)/double(maxshort);
}

unsigned short RandomNumber::Random(unsigned long n)
{
 randSeed=multiplier*randSeed+adder;
 return (unsigned short)((randSeed>>16)%n);
}

template<class Type>
class OrderedList
{
public:
 OrderedList(Type small,Type Large,int MaxL);//构造函数
 ~OrderedList();//析构函数
 bool Search(Type x,int &index);//搜索指定元素
 int SearchLast(void);//搜索最大元素
    void Insert(Type k);//插入指定元素
 void Delete(Type k);//删除指定元素
 void Output();//输出集合中的元素
private:
 int n;//当前集合中元素个数
 int MaxLength;//集合中最大元素个数
 Type *value;//存储集合中元素的数组
 int *link;//指针数组
 RandomNumber rnd;//随机数
 Type Small;//集合中元素下界
 Type TailKey;//集合中的元素的上界
};

template<class Type>
OrderedList<Type>::OrderedList(Type small,Type large,int MaxL)
{
 MaxLength=MaxL;
 value=new Type[MaxLength+1];
 link=new Type[MaxLength+1];
 TailKey=large;
 n=0;
 link[0]=0;
 value[0]=TailKey;
 Small=small;
}

template<class Type>
OrderedList<Type>::~OrderedList()
{
 delete value;
 delete link;
}

template<class Type>
bool OrderedList<Type>::Search(Type x,int &index)//搜索元素x
{
 index=0;
 Type max=Small;
 int m=floor(sqrt(double(n)));
    for(int i=1;i<=m;i++)
 {
  int j=rnd.Random(n)+1;
  Type y=value[j];
  if((max<y)&&(y<x))
  {
   max=y;
   index=j;
  }
  
 }
 while(value[link[index]]<x)
   index=link[index];
  return (value[link[index]]==x);
}

template<class Type>
void OrderedList<Type>::Insert(Type k)
{//插入指定元素
 if((n==MaxLength)||(k>=TailKey))
  return;
 int index;
 if(!Search(k,index))
 {
  value[++n]=k;
  link[n]=link[index];
  link[index]=n;
 }
}

template<class Type>
int OrderedList<Type>::SearchLast(void)
{
 //搜索集合中最大元素
 int index=0;
 Type x=value[n];
 Type max=Small;
 int m=floor(sqrt(double(n)));
 for(int i=1;i<=m;i++)
 {
  int j=rnd.Random(n)+1;
  Type y=value[j];
  if((max<y)&&(y<x))
  {
   max=y;
   index=j;
  }

  
 }
 while(link[index]!=n)
   index=link[index];
  return index;
}

template<class Type>
void OrderedList<Type>::Delete(Type k)
{
 //删除集合中指定元素k
 if((n==0)||(k>=TailKey))
  return ;
 int index;
 if(Search(k,index))
 {
  int p=link[index];
  if(p==n)
   link[index]=link[p];
  else
  {
   if(link[p]!=n)
   {
    int q=SearchLast();
    link[q]=p;
    link[index]=link[p];
   }
   value[p]=value[n];
   link[p]=link[n];
  }
  n--;
 }
}

template<class Type>
void OrderedList<Type>::Output(void)
{
 int index=0;
 while(index<n)
 {
  cout<<value[link[index]]<<"    ";
  index=link[index];
 }
 cout<<endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
 int Large=20;
 int Small=4;
 int MaxL=30;
 OrderedList<int> L(Small,Large,MaxL);
 L.Insert(1);
 L.Insert(2);
 L.Insert(3);
 L.Insert(5);
 L.Insert(8);
 L.Insert(13);
 L.Insert(21);
 L.Output();
 system("PAUSE");

}