2. 程式人生 > >資料結構與演算法學習--跳錶

資料結構與演算法學習--跳錶

阿新 • • 發佈：2018-12-02

跳錶

Skip List是一種隨機化的資料結構，基於並聯的連結串列，其效率可比擬於二叉查詢樹（對於大多數操作需要O(log n)平均時間）。基本上，跳躍列表是對有序的連結串列增加上附加的前進連結，增加是以隨機化的方式進行的，所以在列表中的查詢可以快速的跳過部分列表(因此得名)。所有操作都以對數隨機化的時間進行。Skip List可以很好解決有序連結串列查詢特定值的困難。

跳錶的定義及如何構造跳錶

構造一個有序的單鏈表，我們查詢某個元素，平均時間複雜度0（n）。
在這裡插入圖片描述

Skip List構造步驟：
為一個值有序的連結串列建立多級索引，比如每2個節點提取一個節點到上一級，我們把抽出來的那一級叫做索引或索引層。如下圖所示，其中down表示down指標，指向下一級節點。以此類推，對於節點數為n的連結串列，大約可以建立log2n-1級索引。像這種為連結串列建立多級索引的資料結構就稱為跳錶。
在這裡插入圖片描述

二、跳錶的時間複雜度？
1.計算跳錶的高度
如果連結串列有n個節點，每2個節點抽取抽出一個節點作為上一級索引的節點，那第1級索引的節點個數大約是n/2，第2級索引的節點個數大約是n/4，依次類推，第k級索引的節點個數就是n/(2k)。假設索引有h級別，最高階的索引有2個節點，則有n/(2h)=2，得出h=log2n-1，包含原始連結串列這一層，整個跳錶的高度就是log2n。
2.計算跳錶的時間複雜度
假設我們在跳錶中查詢某個資料的時候，如果每一層都遍歷m個節點，那在跳錶中查詢一個數據的時間複雜度就是O(m*logn)。那這個m是多少呢？如下圖所示，假設我們要查詢的資料是x，在第k級索引中，我們遍歷到y節點之後，發現x大於y，小於後面的節點z，所以我們通過y的down指標，從第k級下降到第k-1級索引。在第k-1級索引中，y和z之間只有3個節點（包含y和z），所以，我們在k-1級索引中最多隻需要遍歷3個節點，以此類推，每一級索引都最多隻需要遍歷3個節點。所以m=3。因此在跳錶中查詢某個資料的時間複雜度就是O(logn)。
三、跳錶的空間複雜度及如何優化？
1.計算索引的節點總數
如果連結串列有n個節點，每2個節點抽取抽出一個節點作為上一級索引的節點，那每一級索引的節點數分別為：n/2，n/4，n/8，…，8，4，2，等比數列求和n-1，所以跳錶的空間複雜度為O(n)。
2.如何優化時間複雜度
如果連結串列有n個節點，每3或5個節點抽取抽出一個節點作為上一級索引的節點，那每一級索引的節點數分別為（以3為例）：n/3，n/9，n/27，…，27，9，3，1，等比數列求和n/2，所以跳錶的空間複雜度為O(n)，和每2個節點抽取一次相比，時間複雜度要低不少呢。
四、高效的動態插入和刪除？
跳錶本質上就是連結串列，所以僅插作，插入和刪除操時間複雜度就為O(1)，但在實際情況中，要插入或刪除某個節點，需要先查詢到指定位置，而這個查詢操作比較費時，但在跳錶中這個查詢操作的時間複雜度是O(logn)，所以，跳錶的插入和刪除操作的是時間複雜度也是O(logn)。
五、跳錶索引動態更新？
當往跳錶中插入資料的時候，可以選擇同時將這個資料插入到部分索引層中，那麼如何選擇這個索引層呢？可以通過隨機函式來決定將這個節點插入到哪幾級索引中，比如隨機函式生成了值K，那就可以把這個節點新增到第1級到第K級索引中。
下面是跳錶的C程式碼的實現及簡單的除錯。
在這裡插入圖片描述

/*************************************************************************
 > File Name: skiplist.h
 > Author:  jinshaohui
 > Mail:    [email protected]
 > Time:    18-10-31
 > Desc:    
 ************************************************************************/
#ifndef __SKIP_LIST_H__
#define __SKIP_LIST_H__


typedef struct _node
{
	int key;    /*key是唯一的*/
	int value;  /*儲存的內容*/
	int max_level; /*當前節點最大層數*/
	struct _node *next[0];/*level層連結串列結構*/
}node;

typedef struct _skiplist
{
	int level;
	int count;
	node *head;
}skiplist;

/*根據當前結構體元素的地址，獲取到結構體首地址*/
#define offsetof(TYPE,MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#define container(ptr,type,member) ({\
  const typeof( ((type *)0)->member) *__mptr = (ptr);\
  (type *) ( (char *)__mptr - offsetof(type,member));})
#endif

/*************************************************************************
 > File Name: skiplist.c
 > Author:  jinshaohui
 > Mail:    
 
[email protected]
 > Time:    18-10-31
 > Desc:    
 ************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include"./skiplist.h"


/*建立node節點*/
node* skip_list_create_node(int level,int key,int value)
{
	node * tmp = NULL;

	tmp =(node *)malloc(sizeof(node) + level*sizeof(node *));
	assert(tmp != NULL);

	memset(tmp,0,sizeof(node) + level*sizeof(node*));
	tmp->key = key;
	tmp->value = value;
	tmp->max_level = level;
	
    return tmp;
}

/*建立跳錶的表頭，max_level層數*/
skiplist * skip_list_create(int max_level)
{
	int i = 0;
	skiplist * list = NULL;

	list = (skiplist *)malloc (sizeof(skiplist));
	assert(list != NULL);

	list->level = 1;
	list->count = 0;

	list->head = skip_list_create_node(max_level,0,0);
	if(list->head == NULL)
	{

		free(list);
		return NULL;
	}
	
	return list;
}

/*skiplist 銷燬*/
void skip_list_destory(skiplist * list)
{
	int i = 0;
	node * tmp = NULL;

	if((list == NULL) || (list->head == NULL))
	{
		return;
	}
	while(list->head->next[0] != NULL)
	{
        tmp = list->head->next[0];
        list->head->next[0] = tmp->next[0];
		free(tmp);
	}

    free(list->head);
	free(list);
	return;
}

/*插入元素獲得層數，是隨機產生的*/
int skip_list_level(skiplist * list)
{
	int i = 0;
	int level = 1;
	for (i = 1; i < list->head->max_level; i++)
	{
		if ((rand()%2) == 1)
		{
			level++;
		}
	}

	return level;
}
int skip_list_insert(skiplist *list,int key,int value)
{
	int i = 0;
	int level = 0;
	node **update = NULL;/*用來更新每層的指標*/
	node *tmp = NULL;
	node *prev = NULL;

	if (list == NULL)
	{
		return 1;
	}

    /*申請update空間用於儲存每層的指標*/
	update = (node **)malloc(sizeof(node *)*list->head->max_level);
	if (update == NULL)
	{
		return 2;
	}

    /*逐層查詢節點的*/
	prev = list->head;
	for (i = (list->level -1); i >= 0; i--)
	{
	    /*初始化每level層的頭指標*/
		while(((tmp = prev->next[i]) != NULL) && (tmp->key < key))
		{
			prev  = tmp;
		}
		update[i] = prev;
	}

	/*當前key已經存在，返回錯誤*/
	if ((tmp!= NULL) && (tmp->key == key))
	{
		return 3;
	}
	/*獲取插入元素的隨機層數，並更新跳錶的最大層數*/
	level = skip_list_level(list);
	/*建立當前資料節點*/
	tmp = skip_list_create_node(level,key,value);
	if (tmp == NULL)
	{
		return 4;
	}

	/*更新最大層數*/
	if (level > list->level)
	{
		for (i = list->level;i < level; i ++)
		{
			update[i] = list->head;
		}
		list->level = level;
	}

	/*逐層更新節點的指標*/
	for(i = 0; i < level; i++)
	{
        tmp->next[i] = update[i]->next[i];
		update[i]->next[i] = tmp; 
	}

    list->count++;
	return 0;
}

int skip_list_delete(skiplist * list, int key ,int *value)
{
	int i = 0;
	node **update = NULL;/*用來更新每層的指標*/
	node *tmp = NULL;
	node *prev = NULL;

	if ((list == NULL) && (value == NULL)&& (list->count == 0))
	{
		return 1;
	}
    /*申請update空間用於儲存每層的指標*/
	update = (node **)malloc(sizeof(node *)*list->level);
	if (update == NULL)
	{
		return 2;
	}
    /*逐層查詢節點的*/
	prev = list->head;
	for (i = (list->level -1); i >= 0; i--)
	{
	    /*初始化每level層的頭指標*/
		while(((tmp = prev->next[i]) != NULL) && (tmp->key < key))
		{
			prev = tmp;
		}
		update[i] = prev;
	}

	if ((tmp != NULL)
		&& (tmp->key == key))
	{
		*value = tmp->value;
	    /*逐層刪除*/
		for(i = 0; i < list->level; i++)
		{
			if(update[i]->next[i] == tmp)
			{
			     update[i]->next[i] = tmp->next[i];       
			}	
		}

		free(tmp);
		tmp = NULL;
        
		/*更新level的層數*/
		for (i = list->level - 1; i >= 0; i++)
		{
			if (list->head->next[i] == NULL )
			{
				list->level--;
			}
			else
			{
				break;
			}
		}

		list->count--;

	}
	else
	{
		return 3;/*未找到節點*/
	}

    return 0 ;
}

/*查詢當前key是否在跳錶中，如果存在返回查詢的value數值，不存在返回-1*/
int skip_list_search(skiplist *list,int key,int *value)
{
	int i = 0;
    node *prev = NULL;
	node *tmp = NULL;

	if((list == NULL) || (list->count == 0) || (value == NULL))
	{
		return 1;
	}
    prev = list->head;
	for(i = list->level - 1; i >= 0; i--)
	{
		while(((tmp = prev->next[i]) != NULL) && (tmp->key <= key))
		{
			if (tmp->key == key)
			{
		        *value = tmp->value;
		        return 0;
			}
			prev = tmp;
		}
	}

    return -1;
}

void skip_list_dump(skiplist *list)
{
	int i = 0;
    node *ptmp = NULL;
    printf("\r\n----------------------------------------------");
	printf("\r\n skip list level[%d],count[%d]",list->level,list->count);
	for(i = list->level - 1; i >= 0; i --)
	{
		ptmp = list->head->next[i];
		printf("\r\n level[%d]:",i);
		while(ptmp != NULL)
		{
			printf("%d-%d ",ptmp->key,ptmp->value);
			ptmp = ptmp->next[i];
		}
	}
    printf("\r\n----------------------------------------------");
	return;
}

int main()
{
	int res = 0;
	int key = 0;
	int value = 0;
    skiplist *list = NULL;


	list = skip_list_create(5);
	assert(list != NULL);

	while(1)
	{
		printf("\r\n 請輸入key 和 value，當key = 1000時，退出輸入：");
		scanf("%d%d",&key,&value);
		if (key == 1000)
		{
			break;
		}
		res = skip_list_insert(list,key,value);
		if (res != 0)
		{
			printf("\r\n skip list insert %d,failed,res=%d.",key,res);
		}
	}
	skip_list_dump(list);

	while(1)
	{
		printf("\r\n 通過key 查詢value的數值，當key = 1000時，退出查詢");
		scanf("%d",&key);
		if(key == 1000)
		{
			break;
		}
		res = skip_list_search(list,key,&value);
		if (res != 0)
		{
			printf("\r\n skip list search %d,failed,res=%d.",key,res);
		}
		else
		{
			printf("\r\n skip list search %d,sucessful,value=%d.",key,value);

		}
	}
	skip_list_dump(list);
	while(1)
	{
		printf("\r\n 通過key 刪除節點，當key = 1000時，退出刪除");
		scanf("%d",&key);
		if(key == 1000)
		{
			break;
		}
		res = skip_list_delete(list,key,&value);
		if (res != 0)
		{
			printf("\r\n skip list search %d,failed,res=%d.",key,res);
		}
		else
		{
			printf("\r\n skip list search %d,sucessful,value=%d.",key,value);

		}
	}

	skip_list_dump(list);
	skip_list_destory(list);

	return 0;
}

相關推薦

資料結構與演算法學習--跳錶

跳錶 Skip List是一種隨機化的資料結構，基於並聯的連結串列，其效率可比擬於二叉查詢樹（對於大多數操作需要O(log n)平均時間）。基本上，跳躍列表是對有序的連結串列增加上附加的前進連結，增加是以隨機化的方式進行的，所以在列表中的查詢可以快速的跳過部分列表(因此得名)。所有操作都

資料結構與演算法學習筆記之後進先出的“桶”

前言 棧最為一種的常用的資料結構，用“桶”來形容最合適不過；今天我們就來學習一下 正文 一、棧的定義？ 1.“後進先出，先進後出”的資料結構。 2.從操作特性來看，是一種“操作受限”的線性表，只可以在一端插入和刪除資料。   二、為什麼需要棧？  

資料結構與演算法——學習整理記錄

===注：此文由本人結合網上資源整理總結而來，僅代表個人的學習與理解，如有錯漏，歡迎指正！=== # 1. 資料結構 ## 1.1 資料結構是什麼？ 資料結構，直白地理解，就是研究資料的邏輯關係與儲存方式的一門學科。 可以簡單的分為：資料的邏輯結構（邏輯關係）和資料的儲存結構（物理結構

資料結構與演算法學習--二叉樹及二叉搜尋樹

可以看下以前對數的總結https://blog.csdn.net/sjin_1314/article/details/8507490 下面是二叉樹的遍歷，建立及銷燬的函式實現，層次遍歷依賴佇列；佇列實現可以去github上檢視https://github.com/jin13417/al

資料結構與演算法學習--雜湊

一、雜湊衝突的解放方法？ 1.常用的雜湊衝突解決方法有2類：開放定址法（open addressing）和連結串列法（chaining） 2.開放定址法（參考連結） ①核心思想：如果出現雜湊衝突，就重新探測一個空閒位置，將其插入。 ②線性探測法（Linear Probing）： 插入資料：

資料結構與演算法學習--二分查詢

二分查詢（Binary Search）演算法，也叫折半查詢演算法。二分查詢針對的時一個有序的資料集合，查詢思想有點類似於分治。每次都是通過和區間的中間元素進行比較，將待查區縮小為原來的一半，直到將元素找到或者區間縮小為0。 我們可以通過2種方式實現：遞迴和非遞迴。 /**********

#資料結構與演算法學習筆記#劍指Offer29：整數中1出現的次數 + 分段思想/按位考慮 + 測試用例（Java、C/C++）

2018.10.5 感受到開學之後工作和課業的雙重壓力，加上近段時間自己出了點小事故，因此斷更了許久。沒事，繼續。 這道題有兩種複雜度為的演算法。 方法1：遞迴（分段思想）。 所有數字出現1的個數 = 每一段數字中出現1的個數之和 1. 對於輸出的數字n，其最高位為

資料結構與演算法學習筆記 1 （2018.10.05）

演算法  計算=資訊處理          藉助某種工具，遵照一定規則，以明確而機械的形式進行 計算模型=計算機=資訊處理工具 所謂演算法，即特定計算模型下，旨在解決特定問題的指令序列         輸入      待處理的資訊（問題）         輸

#資料結構與演算法學習筆記#劍指Offer30：把陣列排成最小的數 + 自定義比較器 + 測試用例（Java、C/C++）

2018.10.6 1.求全排列最小。事實上用全排列硬剛這道題確實是最直接的辦法，因為乍一眼看上去實在不好歸納數字之間的順序關係，全排列具體實現原理可以參考上述文章。 2.自定義比較器。為什麼說

資料結構與演算法學習筆記之 複雜度分析

前言： 　 大家都知道資料結構和英語，就如同程式設計師的兩條腿一樣；只有不斷的積累，學習，擁有了健壯的“雙腿”才能越走越遠；在資料結構和演算法的領域，不得不承認自己就是一隻菜鳥；需要不斷的學習；在學習過程中，經常會有一些自己的看法，和別人獨特的見解；我都會一一做好筆記，以便進步； 正文：複雜度分析

資料結構與演算法學習筆記 2 （2018.10.06）

演算法分析 兩個主要方面：                  正確性：演算法的功能與問題要求一致？                                  數學證明？可不那麼簡單...                    成本：執行時間 + 所需儲存空間

資料結構與演算法學習筆記 4 （2018.10.08）

漸進分析：大o記號 回到原先的問題：隨著問題規模的增長，計算成本如何增長？         注意：這裡更關心足夠大的問題，注重考察成本的增長趨勢 漸進分析：在問題的規模足夠大後，計算成本如何成長？             Asymptomatic analysis ：當

資料結構與演算法學習大綱

入門篇 時間、空間複雜度分析是資料結構和演算法中非常重要的知識點，貫穿整個專欄的學習過程。但同時也是比較難掌握的，所以我用了 2 節課來講這部分內容，而且還舉了大量的例項，讓你一邊學一邊練，真正能掌握

資料結構與演算法學習筆記之 提高讀取效能的連結串列（上）

前言 　　連結串列（Linked list）比陣列稍微複雜一點，在我們生活中用到最常見的應該是快取，它是一種提高資料讀取效能的技術，常見的如cpu快取，瀏覽器快取，資料庫快取等。今天我們就來學習一下連結串列 正文 一、連結串列的定義？ 1.一種線性表（資料排成像一條線一樣的結構。每個線性表上的資料最多

資料結構與演算法學習--棧

1、順序棧的實現： /************************************************************************* > File Name: arrayStack.h > Author:

小白的資料結構與演算法學習筆記（二十六）----廣義表

 一、廣義表的概述 首先回憶一下原子型別和結構型別，簡單說來，原子型別就是不可再分的型別，結構型別就是可以再分的型別。我們前面講的線性表要求每個元素都是原子型別，而廣義表作為線性表的推廣，它的元素可以是原子型別，也可以是個表。元素是原子型別，叫原子結點；元素是表，叫表結點。

資料結構與演算法學習筆記之先進先出的佇列

前言 　　佇列是一種非常實用的資料結構，類似於生活中發排隊，可應用於生活，開發中各個方面，比如共享印表機（先請求先列印），訊息佇列。你想知道他們是怎麼工作的麼。那就來一起學習一下佇列吧 正文 一、佇列的定義？ 1.一種先進先出的線性表 2.只允許入棧 push()和出棧 pop() 在後端（稱

資料結構與演算法學習筆記之高效、簡潔的編碼技巧“遞迴”

前言 盜夢空間想象大多數人都看過：電影講述的是主人公諾蘭進入希裡安·墨菲夢境植入想法的行動。為了向希裡安·墨菲夢植入理念，影片進入四層夢境，即所謂：“夢中的夢中 夢中人的夢中”。 有一對兔子，每隔三個月會產下一對小兔子，小免子每隔三個月，也會產生新的一對免子，問36個月後，共有多少對兔子。 諸如此類：其

資料結構與演算法學習筆記之如何分析一個排序演算法？

前言 現在IT這塊找工作，不會幾個演算法都不好意思出門，排序演算法恰巧是其中最簡單的，我接觸的第一個演算法就是它，但是你知道怎麼分析一個排序演算法麼？有很多時間複雜度相同的排序演算法，在實際編碼中，那又如何選擇呢？下面我們帶著問題一起學習一下。  正文 一、常見經典的排序方法 （圖片來自於一畫素）

#資料結構與演算法學習筆記#劍指Offer34：兩個連結串列的第一個公共結點 + 等長遍歷/輔助棧 + 測試用例（Java、C/C++）

2018.10.21 這道題也是屬於效率題，實現難度不大，但是要降低複雜度還是需要思考一下。有兩個o（n）的做法： 方法一：等長連結串列法。先計算兩條連結串列的長度，然後先遍歷長連結串列直到兩條連結串列等長，最後依次按奇偶順序挨個遍歷兩條連結串列各個結點。 方法二：輔助