数据结构-线性表

线性表

定义:

线性表示是具有相同特性数据元素的有限序列

相同特性:

把同一类事物归类,方便批量处理

有限:

表中元素个数为n,n有限大,n可以为0

序列:

表中元素排成一列,体现了一对一的逻辑特性(每个元素有则仅有一个前驱和一个后继)

顺序表

顺序表定义:

//地皮最大数量:maxSize
//房子最大数量:length
//地皮编号:0~maxSize-1
//房子编号:0~length-1
//房子实体:Sqlist[0]~Sqlist[length-1]
//房子盖满地皮:length==maxSize
int sqList[maxSize]={1,2,3,...,n};
int length=n;

顺序表理解:

连续的地皮块上盖有连续的房子

链表

链表定义:

单链表:

typedef struct LNode
{
	int data;//房子
	struct LNode *next;//用于指示下一个建筑的方向指示标;
}LNode;
LNode *head;//用于指示头个建筑的方向指示标
head=(LNode*)malloc(sizeof(LNode));//创造头个建筑

双链表:

typedef struct DLNode
{
	int data;//房子
	struct DLNode *prior;//用于指示上一个建筑的方向指示标
	struct DLNode *next;//用于指示下一个建筑的方向指示标
}DLNode;
DLNode *head;//用于指示头个建筑的方向指示标
head=(DLNode*)malloc(sizeof(DLNode));//创造头个建筑

链表理解:

分散的地皮块上盖有分散的房子,为了让这些房子联系起来,给每块地皮的边上插上方向指示标,地皮、房子、方向指示标组合而成的结构称为建筑

顺序表操作

插入操作:

int sqList[maxSize]={1,2,3,...,n};
int length=n;
int insertElem(int sqList[],int &length,int p,int x)
{
	int i;
	if(p<0||p>length||length==maxsize)
	{
		return 0;
	}
	for(i=length-1;i>=p;i--)
	{
		sqList[i+1]=sqList[i];
		sqList[p]=x;
		++length;//线性表长度+1
		return 1;
	}
}

删除操作:

int sqList[maxSize]={1,2,3,...,n};
int length=n;
int deleteElem(int sqList[],int &length,int p,int &x)
{
	int i;
	if(p<0||p>length||length==maxsize)
	{
		return 0;
	}
	x=sqList[p];
	for(i=p;i<length-1;i++)
	{
		sqList[i]=sqList[i+1];
		--length;
		return 1;
	}
}

链表操作

尾插法建立单链表:

typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode;

void createLinkedListR(LNode *&head){
	head=(LNode*)malloc(sizeof(LNode));
	head->next=NULL;
	LNode *p=NULL,*r=head;
	int n;
	std::cin>>n;
	for(int i=0;i<n;i++)
	{
		p=(LNode*)malloc(sizeof(LNode));
		p->next=NULL;
		std::cin>>p->data;
		r->next=p;
		r=r->next;	
	}
	r->next=NULL;
}

头插法建立单链表:

typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode;

void createLinkedListH(LNode *&head){
	head=(LNode*)malloc(sizeof(LNode));
	head->next=NULL;
	LNode *p=NULL;
	int n;
	std::cin>>n
	for(int i=0;i<n;i++)
	{
		p=(LNode*)malloc(sizeof(LNode));
		p->next=NULL;
		std:cin>>p->data;
		p->next=head->next;
		head->next=p;
	}
}

编程题:

键盘输入n个英文字母,输入格式为n，然后分别输入C1、C2、C3、…、Cn，其中n表示字母的个数。利用这些数据建立单链表且存入的字母互不相同.

typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode;

void createLinkNoSameElem(LNode *&head)
{
	head=(LNode*)malloc(sizeof(LNode));
	head->next=NULL;
	LNode *p;//扫描链表的指针
	int n;
	char ch;
	std::cin>>n;
	for(int i=0;i<n;i++)
	{
		std::cin>>ch;
		p=head->next;
		while(p!=NULL)
		{
			if(p->data==ch)break;
			p=p->next;
		}
		if(p==null)
		{
			p=(LNode*)malloc(sizeof(LNode));
			p->data=ch;
			p->next=head->next;
			head->next=p;
		}
	}
}

逆置

顺序表逆置:

for(int i=left,j=right;i<j;i++;j--)
{
	temp=a[i];
	a[i]=a[j];
	a[j]=temp;
}

链表逆置:

while(p->next!=q)
{
	t=t->next;
	p->next=t->next;
	t->next=q->next;
	q->next=t;
}

编程题:

1.将一长度为n的数组的前端k(k<n)个元素逆序移动到数组后端,要求原数组中数据不丢失;

void reverse(int a[],int left,int right,int k)
{
	int temp;
	for(int i=left,j=right;i<left+k&&i<j;i++;j--)
	{
		temp=a[i];
		a[i]=a[j];
		a[j]=temp;
	}
}

2.将一长度为n的数组的前端k(k<n)个元素原序移动到数组后端,要求原数组中数据不丢失;

void moveToEnd(int a[],int n,int k)
{
	reverse(a,0,k-1,k);
	reverse(a,0,n-1,k);
}

3.将数组中的元素(X0,X1,…Xn-1),经过移动后变为:(Xp,Xp+1,…Xn-1,X0,X1,…Xp-1),即循环左移p(0<p<n)个位置.

void moveP(int a[],int n,int p)
{
	reverse(a,0,p-1,p);
	reverse(a,p,n-1,n-p);
	reverse(a,0,n-1,n);
}

取最值

顺序表取最大值:

int max=a[0];
int maxIdx=0;
for(int i=0;i<n;i++)
{
	if(max<a[i])
	{
		max=a[i];
		maxIdx=i;
	}
}

链表取最大值结点:

LNode *p=head->next,*q=p;
int min=q->data;

while(p!=NULL)
{
	if(min>p->data)
	{
		min=p->data;
		q=p;
	}
	p=p->next;
}

编程题:

一双链表非空,由head指针指出,结点结构为{llink,data,rlink},请设计一个将结点数据域data值最大的结点移动到链表最前面的算法,要求不得申请新结点空间

typedef struct DLNode
{
	int data;
	struct DLNode *llink;
	struct DLNode *rlink;
}DLNode;

void maxFirst(DLNode *head)
{	
	DLNode *p=head->rlink,*q=p;
	int max=q->data;
	while(p!=NULL)
	{
		if(max<p->data)
		{
			max=p->data;
			q=p;
		}
		p=p->rlink;
	}
	DLNode *l=q->llink,*r=q->rllink;
	l->rlink=r;
	if(r!=NULL)
	{
		r->llink=l;
	}
	q->llink=head;
	q->rlink=head->rlink;
	head->rlink=q;
	q->rlink->llink=q;
}

归并

顺序表归并:

void mergeArray(int a[],int m,int b[],int n,int c[])
{
	int i=0,j=0;
	int k=0;
	while(i<m && j<n)
	{
		if(a[i]<b[j])
		{
			c[k++]=a[i++];
		}else
		{
			c[k++]=b[j++];
		}
		while(i<m)
		{
			c[k++]=a[i++];
		}
		while(j<n)
		{
			c[k++]=b[j++];
		}
	}
}

链表归并:

归并递增链表

void mergeIncrease(LNode *headA,LNode *headB,LNode *&headC)
{
	LNode *p=headA->next;
	LNode *q=headB->next;
	LNode *r;
	headC=headA;
	headC->next=NULL;
	free(headB);
	r=headC;
	while(p!=NULL&&q!=NULL)
	{
		if(p->data<q->data)
		{
			r->next=p;
			p=p->next;
			r=r->next;
		}else
		{
			r->next=q;
			q=q->next;
			r=r->next;
		}
	}
	if(p==NULL) r->next=q;
	if(q==NULL) r->next=p;
}

归并递减链表

void mergeDecrease(LNode *headA,LNode *headB,LNode *&headC)
{
	LNode p=headA->next;
	LNode q=headB->next;
	LNode *s;
	headC=headA;
	headC->next=NULL;
	free(headB);
	while(p!=NULL&&q!=NULL)
	{
		if(p->data<q->data)
		{
			s=p
			s->next=headC->next;
			headC->next=s;
			p=p->next;
		}else
		{
			s=q;
			s->next=headC->next;
			headC->next=s;
			q=q->next;
		}
	}
	if(p==NULL) 
	{
		s=q;
		s->next=headC->next;
		headC->next=s;
		q=q->next;
	}
	if(q==NULL)
	{
		s=p
		s->next=headC->next;
		headC->next=s;
		p=p->next;
	}
}

划分

void partition(int arr[],int n,int k)
{
	int temp;
	int i=0,j=n-1;
	temp=arr[0];
	arr[0]=arr[k];
	arr[k]=temp;
	temp=arr[i];
	while(i<j)
	{
		while(i<j &&arr[j]>=temp)--j; 
		if(i<j)
		{
			arr[i]=arr[j];
			++i;
		}
		while(i<j &&arr[j]<temp)++i;
		if(i<j)
		{
			arr[j]=arr[i];
			--j;
		}
	}
	arr[i]=temp;
}