【数据结构】串的块链存储表示和实现

分类：数据结构作者：佚名

数据结构 串的块链存储表示和实现

参考代码如下：

/*
	名称：串的块链存储表示和实现 
	语言：数据结构C语言版 
	编译环境：VC++ 6.0
	日期： 2014-3-27 
*/

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>

// LString.h 串的块链存储表示 
#define CHUNKSIZE 4 // 可由用户定义的块大小 

typedef struct Chunk
{
	char ch[CHUNKSIZE];	//块的数据域
	struct Chunk *next;	//块的指针域
}Chunk;

typedef struct
{
	Chunk *head,// 串的头指针 
		*tail;		// 串的尾指针 
	int curlen;		// 串的当前长度 
}LString;

char blank = '#';	// 全局变量,用于填补空余 

// 初始化(产生空串)字符串T。
void InitString(LString *T)
{
	(*T).curlen=0;
	(*T).head=NULL;
	(*T).tail=NULL;
}

// 生成一个其值等于chars的串T(要求chars中不包含填补空余的字符) 
// 成功返回1，否则返回0 
int StrAssign(LString *T,char *chars)
{
	int i,j,k,l;
	Chunk *p,*q;
	
	i=strlen(chars); // i为串的长度 
	if(!i||strchr(chars,blank)) // 串长为0或chars中包含填补空余的字符 
		return 0;
	(*T).curlen=i;
	j=i/CHUNKSIZE;	// j为块链的结点数，块的个数 
	if(i%CHUNKSIZE)	//不足一个块的，当成一个块即块数加1
		j++;
	for(k=0;k<j;k++)
	{
		p=(Chunk*)malloc(sizeof(Chunk));
		if(!p)
			return 0;
		if(k==0) // 第一个链块 
			(*T).head=q=p;
		else
		{
			q->next=p;
			q=p;
		}
		for(l=0;l<CHUNKSIZE&&*chars;l++)
			*(q->ch+l)=*chars++;
		if(!*chars) // 最后一个链块 
		{
			(*T).tail=q;
			q->next=NULL;
			for(;l<CHUNKSIZE;l++)
				// 用填补空余的字符（blank=‘#’）填满链表 
				*(q->ch+l)=blank;
		}
	}
	return 1;
}

// 由串S复制得串T(连填补空余的字符一块拷贝) 
int StrCopy(LString *T,LString S)
{
	Chunk *h=S.head,*p,*q;
	
	(*T).curlen=S.curlen;
	if(h)
	{
		p=(*T).head=(Chunk*)malloc(sizeof(Chunk));
		*p=*h; // 复制1个结点 
		h=h->next;
		while(h)	//没到队尾，继续复制块
		{
			q=p;
			p=(Chunk*)malloc(sizeof(Chunk));
			q->next=p;
			*p=*h;
			h=h->next;
		}
		p->next=NULL;
		(*T).tail=p;
		return 1;
	}
	else
		return 0;
}

// 若S为空串,则返回1,否则返回0
int StrEmpty(LString S)
{
	if(S.curlen) // 非空 
		return 0;
	else
		return 1;
}

// 若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0 
int StrCompare(LString S,LString T)
{
	int i=0; // i为当前待比较字符在S,T串中的位置 
	Chunk *ps=S.head,*pt=T.head; // ps,pt分别指向S和T的待比较块 
	int js=0,jt=0; // js,jt分别指示S和T的待比较字符在块中的位序 
	
	while(i<S.curlen&&i<T.curlen)
	{
		i++; // 分别找S和T的第i个字符 
		while(*(ps->ch+js)==blank) // 跳过填补空余的字符 
		{
			js++;
			if(js==CHUNKSIZE)
			{
				ps=ps->next;
				js=0;
			}
		}; // *(ps->ch+js)为S的第i个有效字符 
		while(*(pt->ch+jt)==blank) // 跳过填补空余的字符 
		{
			jt++;
			if(jt==CHUNKSIZE)
			{
				pt=pt->next;
				jt=0;
			}
		}; // *(pt->ch+jt)为T的第i个有效字符 
		if(*(ps->ch+js)!=*(pt->ch+jt))
			return *(ps->ch+js)-*(pt->ch+jt);
		else // 继续比较下一个字符 
		{
			js++;
			if(js==CHUNKSIZE)
			{
				ps=ps->next;
				js=0;
			}
			jt++;
			if(jt==CHUNKSIZE)
			{
				pt=pt->next;
				jt=0;
			}
		}
	}
	return S.curlen-T.curlen;
}

// 返回S的元素个数,称为串的长度
int StrLength(LString S)
{
	return S.curlen;
}

// 将S清为空串
int ClearString(LString *S)
{
	Chunk *p,*q;
	//释放空间，并置空
	p=(*S).head;
	while(p)
	{
		q=p->next;
		free(p);
		p=q;
	}
	(*S).head=NULL;
	(*S).tail=NULL;
	(*S).curlen=0;
	return 1;
}

// 用T返回由S1和S2联接而成的新串
int Concat(LString *T,LString S1,LString S2)
{
	LString a1,a2;
	InitString(&a1);
	InitString(&a2);
	StrCopy(&a1,S1);
	StrCopy(&a2,S2);
	(*T).curlen=S1.curlen+S2.curlen;
	(*T).head=a1.head;
	a1.tail->next=a2.head;
	(*T).tail=a2.tail;
	return 1;
}

// 用Sub返回串S的第pos个字符起长度为len的子串。 
int SubString(LString *Sub,LString S,int pos,int len)
{
	Chunk *p,*q;
	int i,n,flag=1;	//用来标志复制是否完成，1完成，0未完成
	
	if(pos<1||pos>S.curlen||len<0||len>S.curlen-pos+1)
		return 0;
	n=len/CHUNKSIZE; 
	if(len%CHUNKSIZE)
	n++; // n为块的个数 
	p=(Chunk*)malloc(sizeof(Chunk));
	(*Sub).head=p;	// 生成空的Sub串 
	for(i=1;i<n;i++)
	{
		q=(Chunk*)malloc(sizeof(Chunk));
		p->next=q;
		p=q;
	}
	p->next=NULL;
	(*Sub).tail=p;
	(*Sub).curlen=len;
	for(i=len%CHUNKSIZE; i<CHUNKSIZE; i++)
		*(p->ch+i)=blank; // 填充Sub尾部的多余空间 
	q=(*Sub).head; // q指向Sub串即将复制的块 
	i=0;		// i指示即将复制的字符在块中的位置 
	p=S.head;	// p指向S串的当前块 
	n=0;		// n指示当前字符在串中的序号 
	while(flag)
	{
		for(k=0; k<CHUNKSIZE; k++) // k指示当前字符在块中的位置 
		if(*(p->ch+k)!=blank)
		{
			n++;
			if(n>=pos&&n<=pos+len-1) // 复制 
			{
				if(i==CHUNKSIZE)
				{ // 到下一块 
					q=q->next;
					i=0;
				}
				*(q->ch+i)=*(p->ch+k);
				i++;
				if(n==pos+len-1) // 复制结束 
				{
					flag=0;
					break;
				}
			}
		}
		p=p->next;
	}
	return 1;
}

// T为非空串。若主串S中第pos个字符之后存在与T相等的子串,// 则返回第一个这样的子串在S中的位置,否则返回0 
int Index(LString S,LString T,int pos)
{ 
	int i,m;
	LString sub;
	
	if(pos>=1 && pos<=StrLength(S)) // pos满足条件 
	{
		n=StrLength(S); // 主串长度 
		m=StrLength(T); // T串长度 
		i=pos;     
		while(i<=n-m+1)
		{
			SubString(&sub,S,i,m); // sub为从S的第i个字符起,长度为m的子串 
			if(StrCompare(sub,T)!=0) // sub不等于T 
				++i;
			else
				return i;
		}
	}
	return 0;
}

// 压缩串(清除块中不必要的填补空余的字符)。
void Zip(LString *S)
{
	int j,n=0;
	Chunk *h=(*S).head;
	char *q;
	
	q=(char*)malloc(((*S).curlen+1)*sizeof(char));
	while(h) // 将LString类型的字符串转换为char[]类型的字符串 
	{
		for(j=0; j<CHUNKSIZE; j++)
		if(*(h->ch+j)!=blank)
		{
			*(q+n)=*(h->ch+j);
			n++;
		}
		h=h->next;	//h指向下一个块
	}
	*(q+n)=0;	// 串结束符 
	ClearString(S);	// 清空S 
	StrAssign(S,q); // 重新生成S 
}

// 在串S的第pos个字符之前插入串T 
int StrInsert(LString *S,LString T)
{
	int i,k;
	Chunk *p,*q;
	LString t;
	
	if(pos<1||pos>StrLength(*S)+1) // pos超出范围 
		return 0;
	StrCopy(&t,T); // 复制T为t 
	Zip(S); // 去掉S中多余的填补空余的字符 
	i=(pos-1)/CHUNKSIZE; // 到达插入点要移动的块数 
	j=(pos-1)%CHUNKSIZE; // 到达插入点在最后一块上要移动的字符数 
	p=(*S).head;
	if(pos==1) // 插在S串前 
	{
		t.tail->next=(*S).head;
		(*S).head=t.head;
	}
	else if(j==0) // 插在块之间 
	{
		for(k=1;k<i;k++)
			p=p->next; // p指向插入点的左块 
		q=p->next; // q指向插入点的右块 
		p->next=t.head; // 插入t 
		t.tail->next=q;
		if(q==NULL) // 插在S串后 
		(*S).tail=t.tail; // 改变尾指针 
	}
	else // 插在一块内的两个字符之间 
	{     
		for(k=1;k<=i;k++)
			p=p->next; // p指向插入点所在块 
		q=(Chunk*)malloc(sizeof(Chunk)); // 生成新块 
		for(i=0;i<j;i++)
			*(q->ch+i)=blank; // 块q的前j个字符为填补空余的字符 
		for(i=j;i<CHUNKSIZE;i++)
		{
			*(q->ch+i)=*(p->ch+i); // 复制插入点后的字符到q 
			*(p->ch+i)=blank; // p的该字符为填补空余的字符 
		}
		q->next=p->next;
		p->next=t.head;
		t.tail->next=q;
	}
	(*S).curlen+=t.curlen;
	Zip(S);	//进行压缩
	return 1;
}

// 从串S中删除第pos个字符起长度为len的子串
int StrDelete(LString *S,int len)
{
	int i=1; // 当前字符是S串的第i个字符(1～S.curlen) 
	Chunk *p=(*S).head; // p指向S的当前块 
	int j=0; // 当前字符在当前块中的位序(0～CHUNKSIZE-1) 
	if(pos<1||pos>(*S).curlen-len+1||len<0) // pos,len的值超出范围 
		return 0;
	while(i<pos) // 找第pos个字符 
	{
		while(*(p->ch+j)==blank) // 跳过填补空余的字符 
		{
			j++;
			if(j==CHUNKSIZE) // 应转向下一块 
			{
				p=p->next;
				j=0;
			}
		}
		i++; // 当前字符是S的第i个字符 
		j++;
		if(j==CHUNKSIZE) // 应转向下一块 
		{
			p=p->next;
			j=0;
		}
	}; // i=pos,*(p->ch+j)为S的第pos个有效字符 
	while(i<pos+len) // 删除从第pos个字符起到第pos+len-1个字符 
	{
		while(*(p->ch+j)==blank) // 跳过填补空余的字符 
		{
			j++;
			if(j==CHUNKSIZE) // 应转向下一块 
			{
				p=p->next;
				j=0;
			}
		}
		*(p->ch+j)=blank; // 把字符改成填补空余的字符来＂删除＂第i个字符 
		i++; // 到下一个字符 
		j++;
		if(j==CHUNKSIZE) // 应转向下一块 
		{
			p=p->next;
			j=0;
		}
	};
	(*S).curlen-=len; // 串的当前长度 
	return 1;
}

// 用V替换主串S中出现的所有与T相等的不重叠的子串
int Replace(LString *S,LString V)
{
	int i=1; // 从串S的第一个字符起查找串T 
	if(StrEmpty(T)) // T是空串 
		return 0;
	do
	{
		i=Index(*S,T,i); // 结果i为从上一个i之后找到的子串T的位置 
		if(i) // 串S中存在串T 
		{
			StrDelete(S,StrLength(T)); // 删除该串T 
			StrInsert(S,V); // 在原串T的位置插入串V 
			i+=StrLength(V); // 在插入的串V后面继续查找串T 
		}
	}while(i);
	return 1;
}

// 输出字符串T。
void StrPrint(LString T)
{
	int i=0,j;
	Chunk *h;
	h=T.head;
	while(i<T.curlen)
	{
		for(j=0;j<CHUNKSIZE;j++)
		if(*(h->ch+j)!=blank) // 不是填补空余的字符 
		{
			printf("%c",*(h->ch+j));
			i++;
		}
		h=h->next;
	}
	printf("\n");
}

void DestroyString()
{
	// 块链类型的字符串无法销毁 
}


int main()
{
	char *s1="ABCDEFGHI",*s2="12345",*s3="",*s4="asd#tr",*s5="ABCD";
	int k;
	int pos,len;
	LString t1,t2,t3,t4;
	
	InitString(&t1);
	InitString(&t2);
	
	printf("初始化串t1后，串t1空否？%d(1:空 0:否) 串长=%d\n",StrEmpty(t1),StrLength(t1));
	k=StrAssign(&t1,s3);
	if(k==1)
	{
		printf("串t1为: ");
		StrPrint(t1);
	}
	else
		printf("出错\n"); // 不能生成空串 
	k=StrAssign(&t1,s4);
	if(k==1)
	{
		printf("串t1为: ");
		StrPrint(t1);
	}
	else
		printf("出错\n"); // 不能生成含有变量blank所代表的字符的串 
	k=StrAssign(&t1,s1);
	if(k==1)
	{
		printf("串t1为: ");
		StrPrint(t1);
	}
	else
		printf("出错\n");
	printf("串t1空否？%d(1:空 0:否) 串长=%d\n",StrLength(t1));
	StrAssign(&t2,s2);
	printf("串t2为: ");
	StrPrint(t2);
	StrCopy(&t3,t1);   
	printf("由串t1拷贝得到串t3,串t3为: ");
	StrPrint(t3);
	InitString(&t4);
	StrAssign(&t4,s5);
	printf("串t4为: ");
	StrPrint(t4);
	Replace(&t3,t4,t2);
	printf("用t2取代串t3中的t4串后，串t3为: ");
	StrPrint(t3);
	ClearString(&t1);
	printf("清空串t1后，串t1空否？%d(1:空 0:否) 串长=%d\n",StrLength(t1));
	Concat(&t1,t3);
	printf("串t1(=t2+t3)为: ");
	StrPrint(t1);
	Zip(&t1);
	printf("去除不必要的占位符后，串t1为: ");
	StrPrint(t1); 
	pos=Index(t1,1);
	printf("pos=%d\n",pos);
	printf("在串t1的第pos个字符之前插入串t2，请输入pos: ");
	scanf("%d",&pos);
	k=StrInsert(&t1,pos,t2);
	if(k)
	{
		printf("插入串t2后，串t1为: ");
		StrPrint(t1);
	}
	else
	printf("插入失败！\n");
	printf("求从t1的第pos个字符起,长度为len的子串t2,请输入pos,len: ");
	scanf("%d,%d",&pos,&len);
	SubString(&t2,t1,len);
	printf("串t2为: ");
	StrPrint(t2);
	printf("StrCompare(t1,t2)=%d\n",StrCompare(t1,t2));
	printf("删除串t1中的子字符串：从第pos个字符起删除len个字符。"
		"请输入pos,len：");
	scanf("%d,&len);
	k=StrDelete(&t1,len);
	if(k)
	{
		printf("从第%d位置起删除%d个元素后串t1为:",len);
		StrPrint(t1);
	}
	
	system("pause");
	return 0;
}
/*
输出效果：

初始化串t1后，串t1空否？1(1:空 0:否) 串长=0
出错
出错
串t1为: ABCDEFGHI
串t1空否？0(1:空 0:否) 串长=9
串t2为: 12345
由串t1拷贝得到串t3,串t3为: ABCDEFGHI
串t4为: ABCD
用t2取代串t3中的t4串后，串t3为: 12345EFGHI
清空串t1后，串t1空否？1(1:空 0:否) 串长=0
串t1(=t2+t3)为: 1234512345EFGHI
去除不必要的占位符后，串t1为: 1234512345EFGHI
pos=6
在串t1的第pos个字符之前插入串t2，请输入pos: 3
插入串t2后，串t1为: 121234534512345EFGHI
求从t1的第pos个字符起,len: 2,2
串t2为: 21
StrCompare(t1,t2)=-1
删除串t1中的子字符串：从第pos个字符起删除len个字符。请输入pos,len：2,2
从第2位置起删除2个元素后串t1为:1234534512345EFGHI
请按任意键继续. . . 

*/

运行结果如下：

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

【啊哈！算法】算法3：最常用的排序——快速排序
【啊哈！算法】算法3：最常用的排序——快速排序       上一节的冒泡排序可以说是我们学习第一个真正的排序算法，并且解决了桶排序浪费空间的问题，但在算法的执行效率上却牺牲了很多，它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次，那么对1亿个数进行排序，桶排序则只需要0.1秒，而冒泡排序则需要1千万秒，达到115天之久，是不是很吓人。那有没有既不浪费空间又可以快一点的排序算法
[数据结构与算法]模式匹配与文本处理-匿名组与命名组
匿名组 这里可能用到几个不同的分组构造。通过括号内围绕的正则表达式就可以组成第一个构造。正如稍后要介绍的一样，既然也可以命名组，大家就有考虑把这个构造作为匿名组。作为一个实例，请看看下列字符串： “08/14/57 46 02/25/59 45 06/05/85 18 03/12/88 16 09/09/90 13“ 这个字符串就是由生日和年龄组成的。如果需要匹配年两而不要生日，就可以把正则
[C#]选择排序
选择排序：从数组的起始位置处开始，把第一个元素与数组中其他元素进行比较。然后，将最小的元素方式在第0个位置上，接着再从第1个位置开始再次进行排序操作。这种操作一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。 public void SelectionSort() { int min, temp;
[数据结构与算法]队列的优先级
public struct Pqitem { public int priority; public string name; } class CQueue { private ArrayList pqueue; public CQueue() { pqueue
[数据结构与算法]模式匹配-数量词
在编写正则表达式的时候，经常会向要向正则表达式添加数量型数据，诸如”精确匹配两次”或者”匹配一次或多次”。利用数量词就可以把这些数据添加到正则表达式里面了。 数量词(+):这个数量词说明正则表达式应该匹配一个或多个紧紧接其前的字符。 string[] words = new string[] { "bad", "boy", "baad", "baaad" ,"bear", "b
[数据结构与算法]白话经典算法系列之五 归并排序的实现
来自：http://blog.csdn.net/morewindows/article/details/6678165/归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列
[C#]插入排序
插入排序算法有两层循环。外层循环会啄个遍历数组元素，而内存循环则会把外层循环所选择的元素与该元素在数组内的下一个元素进行比较。如果外层循环选择的元素小于内存循环选择的元素，那么瘦元素都想右移动以便为内存循环元素留出位置。 public void InsertionSort() { int inner, temp;
[C#]二叉查找法
public int binSearch(int value) { int upperBround, lowerBound, mid; upperBround = arr.Length - 1; lowerBound = 0; while (lowerBound <= upper
[数据结构与算法]双向链表
虽然从表内第一个节点到最后一个节点的遍历操作是非常简单的，但是反向遍历链表却不是一件容易的事情。如果为Node类添加一个字段来存储指向前一个节点的连接，那么久会使得这个反向操作过程变得容易许多。当向链表插入节点的时候，为了吧数据复制给新的字段会需要执行更多的操作，但是当腰吧节点从表移除的时候就能看到他的改进效果了。 首先需要修改Node类来为累增加一个额外的链接。为了区别两个连接，这个把指
[数据结构]树及树的遍历
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂：当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图：面试的时候我们经常被考到的是一种叫“二叉树”的结构，二叉
[数据结构]队列的操作
Queue的实现： 就像Stack类的实现所做的一样，Queue类的实现用ArrayList简直是毋庸置疑的。对于这些数据结构类型而言，由于他们都是动态内置的结构，所以ArrayList是极好的实现选择。当需要往队列中插入数据项时，ArrayList会在表中把每一个保留的数据项向前移动一个元素。 class CQueue { private ArrayLis
[数据结构与算法]常用排序算法的动画效果图
来自：http://yingyingol.iteye.com/blog/13348911 快速排序介绍：快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地
[C#]Stack类的实现
Stack的实现必须采用一种基本结构来保存数据。因为再新数据项进栈的时候不需要担心调整表的大小，所以选择用arrayList.using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Collecti
[C#]冒泡排序
数组类测试环境与排序算法using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace Data_structure_and_algorithm{ class CArray { pr
[数据结构与算法]二叉树与二叉树遍历
一、构造二叉树 二叉树查找树由节点组成，所以需要有个Node类，这个类类似于链表实现中用到的Node类。首先一起来看看Node类的代码。 public class Node { public int Data; public Node Left; public Node Right; public v
【啊哈！算法】算法10：二叉树
二叉树是一种特殊的树。二叉树的特点是每个结点最多有两个儿子，左边的叫做左儿子，右边的叫做右儿子，或者说每个结点最多有两棵子树。更加严格的递归定义是：二叉树要么为空，要么由根结点、左子树和右子树组成，而左子树和右子树分别是一棵二叉树。 下面这棵树就是一棵二叉树。         二叉树的使用范围最广，一棵多叉树也可以转化为二叉树，因此我们将着重讲解二叉树。二叉树中还有连两种特殊的二叉树叫做满二叉树和
【啊哈！算法】算法4：解密QQ号——队列
上一节中我们学习了队列，它是一种先进先出的数据结构。还有一种是后进先出的数据结构它叫做栈。栈限定只能在一端进行插入和删除操作。比如说有一个小桶，小桶的直径只能放一个小球，我们现在向小桶内依次放入2号、1号、3号小球。假如你现在需要拿出2号小球，那就必须先将3号小球拿出，再拿出1号小球，最后才能将2号小球拿出来。在刚才取小球的过程中，我们最先放进去的小球最后才能拿出来，而最后放进去的小球却可以最先拿
[数据结构与算法]模式匹配与文本处理-零宽度正预测先行断言 and 零宽度正回顾后发断言
msdn中的描述如下：(?= 子表达式)（零宽度正预测先行断言。） 仅当子表达式在此位置的右侧匹配时才继续匹配。例如，w+(?=d) 与后跟数字的单词匹配，而不与该数字匹配。此构造不会回溯。(?（零宽度正回顾后发断言。） 仅当子表达式在此位置的左侧匹配时才继续匹配。例如，(?此构造不会回溯。msdn描述的比较清楚，如：w+(?=ing) 可以匹配以ing结尾的单词(匹配结果不包括ing)，(
[数据结构]线索二叉树
1.引入线索二叉树 二叉树的遍历实质上是对一个非线性结构实现线性化的过程，使每一个节点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。但在二叉链表存储结构中，只能找到一个节点的左、右孩子信息，而不能直接得到节点在任一遍历序列中的前驱和后继信息。这些信息只有在遍历的动态过程中才能得到，因此，引入线索二叉树来保存这些从动态过程中得到的信息。 2.建立线索二叉树 为了保
[数据结构与算法]超级详细解读基本排序算法不看后悔，带排序演示动画
排序与我们日常生活中息息相关，比如，我们要从电话簿中找到某个联系人首先会按照姓氏排序、买火车票会按照出发时间或者时长排序、买东西会按照销量或者好评度排序、查找文件会按照修改时间排序等等。在计算机程序设计中，排序和查找也是最基本的算法，很多其他的算法都是以排序算法为基础，在一般的数据处理或分析中，通常第一步就是进行排序，比如说二分查找，首先要对数据进行排序。在Donald Knuth 的计算机程序设
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot