数据结构与算法--跳表

先贴上一个跳表的实现

包括：初始化、插入、删除、搜索、整理

这是头文件

#pragma once

#include<stdlib.h>
#include<iostream>
#include <math.h>
#include<vector>//使用vector作为动态数组，便于节点的调节
using namespace std;
#define MAX_LEVEL 10 //最大层数

template<typename T>
class skiplist {
private:
	typedef struct node {
		int key;
		T data;
		vector<node*> nexts;
	}node;

	int level;//层数，0是最下面，level-1是最上面
	double num;//数据节点的数量
	node *head;

	node* createNode(int level, int key, T data) {
		node *ns = new node;
		ns->key = key;
		ns->data = data;
		for (int i = 0; i <= level; i++) {
			ns->nexts.push_back(NULL);
		}
		return ns;
	}
	node* createHead(int level, int key) {
		node *ns = new node;
		ns->key = key;
		for (int i = 0; i <= level; i++) {
			ns->nexts.push_back(NULL);
		}
		return ns;
	}
public:
	skiplist() {
		num = 0;
		level = 0;
		head = createHead(MAX_LEVEL - 1, 0);
		for (int i = 0; i < MAX_LEVEL; i++) {
			head->nexts[i] = NULL;
		}
	}
	//随机产生层数
	int randomLevel() {
		int rand_level = 1;
		while (rand() % 2) {
			rand_level++;
		}
		return (rand_level < MAX_LEVEL) ? rand_level : MAX_LEVEL;
	}

	//插入节点
	bool insert(int key, T data) {
		num++;
		node *previous[MAX_LEVEL];
		node *p, *wait_insert = NULL;
		p = head;
		int k = level;
		//从最高层往下查找需要插入的位置
		//填充previous
		for (int i = k - 1; i >= 0; i--) {
			while ((wait_insert = p->nexts[i]) && (wait_insert->key < key)) {
				p = wait_insert;
			}
			previous[i] = p;
		}
		//不能插入相同的key
		if (wait_insert&&wait_insert->key == key) {
			return false;
		}

		//产生一个随机层数K
		//新建一个待插入节点wait_insert
		//一层一层插入
		k = randomLevel();
		//更新跳表的level
		if (k > level) {
			for (int i = level; i < k; i++) {
				previous[i] = head;
			}
			level = k;
		}
		wait_insert = createNode(k, key, data);
		//逐层更新节点的指针，和普通列表插入一样
		for (int i = 0; i < k; i++) {
			wait_insert->nexts[i] = previous[i]->nexts[i];
			previous[i]->nexts[i] = wait_insert;
		}
		return true;
	}

	//搜索指定key的data
	T search(int key)const {
		node *intermediary, *target = NULL;
		intermediary = head;
		//从最高层开始搜
		int k = level;
		for (int i = k - 1; i >= 0; i--) {
			while ((target = intermediary->nexts[i]) && (target->key <= key)) {
				if (target->key == key) {
					return target->data;
				}
				intermediary = target;
			}
		}
		return NULL;
	}
	//删除指定key的节点
	bool deleteSL(int key) {
		num--;
		node *previous[MAX_LEVEL];
		node *p, *wait_del = NULL;
		p = head;
		//从最高层开始搜
		int k = level;
		for (int i = k - 1; i >= 0; i--) {
			//将p调节到需要删除的节点的前一个
			//直到wait节点的key大于等于key，之后判断若等于key则删除，大于key返回删除失败
			while ((wait_del = p->nexts[i]) && (wait_del->key < key)) {
				p = wait_del;
			}
			previous[i] = p;
		}

		//如果q是要删除的节点
		if (wait_del&&wait_del->key == key) {
			//就将q下一个节点的指针剪开，与previous里q之前的节点连接起来
			for (int i = 0; i < level; i++) {
				if (previous[i]->nexts[i] == wait_del) {
					previous[i]->nexts[i] = wait_del->nexts[i];
				}
			}
			//q没用了，删除
			free(wait_del);

			//如果删除的是最大层的节点，那么需要重新维护跳表
			for (int i = level - 1; i >= 0; i--) {
				if (head->nexts[i] == NULL) {
					level--;
				}
			}
			return true;
		}//如果不等于，则返回false
		else
			return false;
	}

	/*重载输出运算符*/
	friend ostream& operator<<(ostream& output, const skiplist<T>& sl) {
		node *temp;
		//i代表层数，该循环为层外循环
		for (int i = sl.level - 1; i >= 0; i--) {
			output << i << "层:" << endl;
			//要从头开始打印
			temp = sl.head;
			//将每一层内的元素打印出来
			while (temp) {
				output << " -> " << temp->key;
				temp = temp->nexts[i];
			}
			//一层打印结束，换行
			output << "\n";
		}
		//打印结束，换行
		output << "\n";
		return output;
	}

	/*当链表过大，种种删除插入操作可能使得跳表索引结构不合理，此时需要重新整理结构
	传入的两个指针应该是该区域两头的最高层节点*/
	bool formate() {
		node * temp = head;
		node * next;
		node * pre = head;
		while (temp) {
			node * next = temp->nexts[0];
			temp->nexts.clear();
			temp->nexts.push_back(next);
			pre = temp;
			temp = next;
		}
		for (int i = 0; i < level - 1; i++) {
			pre->nexts.push_back(NULL);
		}

		int i = 0;
		while (head->nexts[i]->nexts[i] != NULL) {

			temp = head;

			while (1) {
				if (temp == NULL) {
					break;
				}
				if (temp->nexts[i] == NULL) {
					break;
				}

				if (temp->nexts[i]->nexts[i] == NULL) {
					temp->nexts.push_back(temp->nexts[i]);
					break;
				}

				temp->nexts.push_back(temp->nexts[i]->nexts[i]);//temp拔高一层
				temp = temp->nexts[i]->nexts[i];
			}
			i++;
		}
		level = head->nexts.size();
		return true;
	}
};

这是test文件：

#include<iostream>
#include <string>
#include "skiplist.h"
using namespace std;

int main() {
	
	cout << " 测试初始化：\n";
	skiplist<string> sl;

	cout << " 测试插入：\n";
	for (int i = 1; i <= 100; i++) {
		cout <<sl.insert(i, "hhh");
	}

	cout << " \n测试输出运算符重载：\n";
	cout << endl<<sl;

	cout << " \n测试搜索功能：\n";
	cout << "键100的数据：" << sl.search(100) << endl;

	cout << " \n测试删除功能：\n";
	cout <<" 删除4号键值对：" <<sl.deleteSL(4) << endl;
	cout << sl;

	cout << " \n测试整理功能：\n";
	cout<<sl.formate();
	cout <<"\nformated:\n" <<sl;
	system("pause");
	return 0;
}