C++ SplayTree::insert方法代码示例

int
main()
{
  SplayTree<SplayInt, SplayInt> tree;

  MOZ_RELEASE_ASSERT(tree.empty());

  MOZ_RELEASE_ASSERT(!tree.find(SplayInt(0)));

  static const int N = mozilla::ArrayLength(gValues);

  // Insert the values, and check each one is findable just after insertion.
  for (int i = 0; i < N; i++) {
    tree.insert(new SplayInt(gValues[i]));
    MOZ_RELEASE_ASSERT(tree.find(SplayInt(gValues[i])));
    tree.checkCoherency();
  }

  // Check they're all findable after all insertions.
  for (int i = 0; i < N; i++) {
    MOZ_RELEASE_ASSERT(tree.find(SplayInt(gValues[i])));
    tree.checkCoherency();
  }

  // Check that non-inserted values cannot be found.
  MOZ_RELEASE_ASSERT(!tree.find(SplayInt(-1)));
  MOZ_RELEASE_ASSERT(!tree.find(SplayInt(N)));
  MOZ_RELEASE_ASSERT(!tree.find(SplayInt(0x7fffffff)));

  // Remove the values, and check each one is not findable just after removal.
  for (int i = 0; i < N; i++) {
    SplayInt* removed = tree.remove(SplayInt(gValues[i]));
    MOZ_RELEASE_ASSERT(removed->mValue == gValues[i]);
    MOZ_RELEASE_ASSERT(!tree.find(*removed));
    delete removed;
    tree.checkCoherency();
  }

  MOZ_RELEASE_ASSERT(tree.empty());

  // Reinsert the values, in reverse order to last time.
  for (int i = 0; i < N; i++) {
    tree.insert(new SplayInt(gValues[N - i - 1]));
    tree.checkCoherency();
  }

  // Remove the minimum value repeatedly.
  for (int i = 0; i < N; i++) {
    SplayInt* removed = tree.removeMin();
    MOZ_RELEASE_ASSERT(removed->mValue == i);
    delete removed;
    tree.checkCoherency();
  }

  MOZ_RELEASE_ASSERT(tree.empty());

  return 0;
}

void test_remove(){
	MyAllocator allocator;
	allocator.constructor(1000);
	SplayTree<int,int> a;
	a.constructor(&allocator);
	for(int k=0;k<100;k++){
		a.insert(k);
		assert(a.find(k)!=NULL);
	}
	assert(a.size()==100);

	a.remove(9);
	assert(a.size()==99);
	assert(a.find(9)==NULL);

	a.remove(50);
	assert(a.size()==98);
	assert(a.find(50)==NULL);

	a.remove(50);
	assert(a.size()==98);
	assert(a.find(50)==NULL);

	a.remove(-1);

	assert(a.size()==98);
}

int main(int argn, char *argc[])
{
  int n = 1000;
  unsigned int t = time(0);
  int value;

  if (argn > 1)
    n = atoi(argc[1]);

  if (argn > 2)
    t = atoi(argc[2]);

  srand(t);

  cout << "testSplayTree " << n << " " << t << endl;

  SplayTree<int> tree;
  SplayTree<int>::Node *node;
  int i;

  cout << "Inserting " << n << " random values in treee ...\n";

  unsigned int insCount = 0, delCount = 0;

  for (i = 0; i < n; i++)
    {
      value = 1+(int) (n*100.0*rand()/(RAND_MAX+1.0));
      node = tree.search(value);
      if (node == NULL)
	{
	  insCount++;
	  node = new SplayTree<int>::Node (value);
	  tree.insert(node);
	}
    }

  cout << insCount << " Items inserted" << endl;

  for (i = 0; i < n; i++)
    {
      value = 1+(int) (n*100.0*rand()/(RAND_MAX+1.0));
      node = tree.remove(value);
      if (node != NULL)
	{
	  delCount++;
	  delete node;
	}
    }
    
  cout << delCount << " Items removed" << endl;

  destroyRec(tree.getRoot());
  cout << "testSplayTree " << n << " " << t << endl;
}

int main(){
    SplayTree<int> tree;
    while(true){
        cout << "\n1 - dodaj wartosc\n";
        cout << "2 - znajdz wartosc\n";
        cout << "3 - usun wartosc\n";
        char c;
        cin >> c;
        if(c == '1'){
            cout << "Podaj wartosc: ";
            int i;
            cin >> i;
            tree.insert(i, i);
        }
        else if(c == '2'){

int main()
{
	SplayTree T;
	while(1)
	{
		char c;
		cin >> c;
		if(c == 'i')
		{
			int i;
			cin >> i;
			T.insert(1,i);
			//T.print(T.root);
		}
		else
		{

int main() {
    int command, id, key;
    while(scanf("%d", &command)) {
        if (!command) {
            break;
        } else if (command == 1) {
            scanf("%d%d", &id, &key);
            tree.insert(Client(id, key));
        } else if (command == 2) {
            printf("%d\n", tree.pop_max().id);
        } else if (command == 3) {
            printf("%d\n", tree.pop_min().id);
        }
    }
    return 0;
}

int main(){	
	long long int sum=0;
	int N;
	SplayTree<int> tr;
	scanf("%d",&N);
	for(int i=0;i<N;++i){
		int j;
		scanf("%d",&j);
		for(;j>0;--j){
			int n;
			scanf("%d",&n);
			tr.insert(n);
		}
		sum+=(tr.findMax()-tr.findMin());
		tr.remove(tr.findMax());
		tr.remove(tr.findMin());
	}
	cout<<sum<<endl;
}

void test_iterator(){
	MyAllocator allocator;
	allocator.constructor(1000);
	SplayTree<int,int> a;
	a.constructor(&allocator);
	SplayTreeIterator<int,int> b;
	b.constructor(&a);
	b.hasNext();
	b.hasNext();
	b.hasNext();
	b.next();
	a.insert(1);

	b.constructor(&a);
	b.hasNext();
	b.hasNext();
	b.hasNext();
	b.next();
	b.hasNext();
	b.hasNext();
}

int main(){
	MyAllocator allocator;
	allocator.constructor(1000);
	SplayTree<int,int> lol;
	lol.constructor(&allocator);
	srand(time(NULL));
	int n=10000000;
	int k=n;
	while(k--){
		lol.insert(k);
	}
	
	int i=0;
	SplayTreeIterator<int,int> iterator(&lol);
	while(iterator.hasNext()){
		SplayNode<int,int>*node=iterator.next();
		int v=node->getKey();
		i++;
	}

	lol.freeze();

	assert(i==n);
	assert(n==lol.size());
	SplayTreeIterator<int,int> iterator2(&lol);
	i=0;
	while(iterator2.hasNext()){
		SplayNode<int,int>*node=iterator2.next();
		int v=node->getKey();
		i++;
	}
	assert(i==n);
	assert(n==lol.size());

	test_remove();
	test_iterator();
	return 0;
}

int main() {
	int n, v;
	char cmd[32];
	while (scanf("%d", &n) != EOF) {
		SplayTree splay;
		for (int op = 0; op < n; ++op) {
			scanf("%s", cmd);
			if (!strcmp(cmd, "show")) {
				splay.show();
			} else if (!strcmp(cmd, "insert")) {
				scanf("%d", &v);
				splay.insert(v);
			} else if (!strcmp(cmd, "find")) {
				scanf("%d", &v);
				SplayTreeNode *ret = splay.find(v);
				printf("Find %d : %x\n", v, (unsigned)ret);
			} else if (!strcmp(cmd, "remove")) {
				scanf("%d", &v);
				splay.remove(v);
			}
		}
	}
	return 0;
}

int main() {
  SplayTree st;
  vector<int> a;
  set<int> marked;
  int n = 7;

  for (int i = 0; i < n; ++i) {
    int t = rand() % n + 1;
    // remove duplicate elements.
    if (marked.count(t)) {
      --i;
      continue;
    }
    marked.insert(t);
    a.push_back(t);
  }
  for (int i = 0; i < n; ++i) {
    st.insert(a[i], true /*print*/);
  }
  for (int i = 0; i < n; ++i) {
    st.remove(a[i], true /*print*/);
  }
  return 0;
}

int TestSplayTree_String()
{
	SplayTree<std::string, std::string> *splaytree = new SplayTree<std::string, std::string>();
	std::string strings[TREE_ITEMS], tmp;

	/* Make sure allocation worked */
	TEST_ASSERT(splaytree != NULL);

	/* Make sure the size starts at 0 */
	TEST_ASSERT(splaytree->size() == 0);

	/* Make sure the tree encapsulates keys properly */
	tmp = std::string("testkey");
	splaytree->insert(tmp, std::string("encapsulation test"));
	tmp = std::string("");
	TEST_ASSERT(splaytree->size() == 1);
	TEST_ASSERT(splaytree->exists("testkey"));
	TEST_ASSERT(splaytree->erase("testkey"));
	TEST_ASSERT(!splaytree->exists("testkey"));
	TEST_ASSERT(!splaytree->erase("testkey"));
	TEST_ASSERT(splaytree->size() == 0);

	/* Simplest sanity checks done, now create some random data */
	for (unsigned int i = 0; i < TREE_ITEMS; i++)
	{
		char buf[20];
		buf[0] = (char)0;
		TEST_ASSERT(strlen(buf) == 0);
		sprintf(buf, "%08x", i);
		strings[i] = std::string(buf);
		TEST_ASSERT(strings[i].length() > 0);
	}

	/* Fill the tree */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		TEST_ASSERT(splaytree->insert(strings[i], strings[(TREE_ITEMS - 1) - i]));
	}

	/* Verify existence of all the added data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		std::string val;
		val.clear();
		TEST_ASSERT(val.length() == 0);
		TEST_ASSERT(splaytree->exists(strings[i]));
		TEST_ASSERT((val = splaytree->find<std::string>(strings[i], "")) != std::string(""));
		TEST_ASSERT(val.length() > 0);
		TEST_ASSERT(Compare(val, strings[(TREE_ITEMS - 1) - i]) == 0);
	}

	/* Verify existence of all the added data, in a different order */
	for (size_t i = TREE_ITEMS - 1; i < TREE_ITEMS; i--)
	{
		TEST_ASSERT(splaytree->exists(strings[i]));
	}

	/* Try to remove all the data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		TEST_ASSERT(splaytree->erase(strings[i]));
		TEST_ASSERT(!splaytree->exists(strings[i]));
	}

	/* And finally, clear the tree */
	delete splaytree;

	return 0;
}

int TestSplayTree_CString()
{
	SplayTree<const char *, const char *> *splaytree = new SplayTree<const char *, const char *>();
	char *strings[TREE_ITEMS], *tmp;

	/* Make sure allocation worked */
	TEST_ASSERT(splaytree != NULL);

	/* Make sure the size starts at 0 */
	TEST_ASSERT(splaytree->size() == 0);

	memset(strings, 0, sizeof(strings));

	/* Make sure the tree encapsulates keys properly */
	tmp = cc_strdup("testkey");
	splaytree->insert(tmp, "encapsulation test");
	free(tmp); tmp = NULL;
	TEST_ASSERT(splaytree->size() == 1);
	TEST_ASSERT(splaytree->exists("testkey"));
	TEST_ASSERT(splaytree->erase("testkey"));
	TEST_ASSERT(!splaytree->exists("testkey"));
	TEST_ASSERT(!splaytree->erase("testkey"));
	TEST_ASSERT(splaytree->size() == 0);

	/* Simplest sanity checks done, now create some random data */
	for (unsigned int i = 0; i < TREE_ITEMS; i++)
	{
		TEST_ASSERT(strings[i] == NULL);
		strings[i] = new char[20];
		TEST_ASSERT(strings[i] != NULL);
		memset(strings[i], 0, 20);
		TEST_ASSERT(strlen(strings[i]) == 0);
		sprintf(strings[i], "%08x", i);
		TEST_ASSERT(strlen(strings[i]) > 0);
	}

	/* Fill the tree */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		TEST_ASSERT(splaytree->insert(strings[i], strings[(TREE_ITEMS - 1) - i]));
	}

	/* Verify existence of all the added data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		const char *val = NULL;
		TEST_ASSERT(splaytree->exists(strings[i]));
		TEST_ASSERT((val = splaytree->find(strings[i])) != NULL);
		TEST_ASSERT(Compare(val, (const char *)strings[(TREE_ITEMS - 1) - i]) == 0);
	}

	/* Verify existence of all the added data, in a different order */
	for (size_t i = TREE_ITEMS - 1; i < TREE_ITEMS; i--)
	{
		TEST_ASSERT(splaytree->exists(strings[i]));
	}

	/* Try to remove all the data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		TEST_ASSERT(splaytree->erase(strings[i]));
		TEST_ASSERT(!splaytree->exists(strings[i]));
	}

	/* Clean up the random data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		delete [] strings[i];
		strings[i] = NULL;
	}

	/* And finally, clear the tree */
	delete splaytree;

	return 0;
}

int TestSplayTree_Int()
{
	SplayTree<int, int> *splaytree = new SplayTree<int, int>();
	int data[TREE_ITEMS], tmp;

	/* Make sure allocation worked */
	TEST_ASSERT(splaytree != NULL);

	/* Make sure the size starts at 0 */
	TEST_ASSERT(splaytree->size() == 0);

	/* Make sure the tree encapsulates keys properly */
	tmp = 256;
	splaytree->insert(tmp, RandomNumber());
	tmp = 0;
	TEST_ASSERT(splaytree->size() == 1);
	TEST_ASSERT(splaytree->exists(256));
	TEST_ASSERT(splaytree->erase(256));
	TEST_ASSERT(!splaytree->exists(256));
	TEST_ASSERT(!splaytree->erase(256));
	TEST_ASSERT(splaytree->size() == 0);

	/* Simplest sanity checks done, now create some random data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		data[i] = i;
	}

	/* Fill the tree */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		TEST_ASSERT(splaytree->insert(data[i], data[TREE_ITEMS - 1 - i]));
	}

	/* Verify existence of all the added data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		int val;
		TEST_ASSERT(splaytree->exists(data[i]));
		TEST_ASSERT((val = splaytree->find(data[i], -1)) != -1);
		TEST_ASSERT(Compare(val, data[TREE_ITEMS - 1 - i]) == 0);
	}

	/* Verify existence of all the added data, in a different order */
	for (size_t i = TREE_ITEMS - 1; i < TREE_ITEMS; i--)
	{
		TEST_ASSERT(splaytree->exists(data[i]));
	}

	/* Try to remove all the data */
	for (size_t i = 0; i < TREE_ITEMS; i++)
	{
		TEST_ASSERT(splaytree->erase(data[i]));
		TEST_ASSERT(!splaytree->exists(data[i]));
	}

	/* And finally, clear the tree */
	delete splaytree;

	return 0;
}