Structures de données et algorithmes (III) - sous forme linéaire sur la base

                                                Base de table linéaire

2.1  Définitions et le fonctionnement de base de la forme linéaire

              Table linéaire est ordonnée et finie

              2.1.2 il existe un unique est appelé « un » élément de données;

              2.2.2 il existe un élément unique appelé données « dernier »;

              2.2.3 En plus du premier élément, chaque élément a un précurseur direct unique,

              2.2.4 En plus du dernier élément, chaque élément a un seul successeur immédiat.

              Table linéaire (Liste linéaire) : est n (n> = 0) d'éléments de données ( noeuds ) a1, a2, ..., an suite finie consistant en

              Tous les nœuds ont le même type de données

              Le nombre d'éléments de données n est appelé la longueur de la forme linéaire

              Lorsque n = 0 , la table vide appelé

              Lorsque n> 0 , la notation linéaire non nulle en tant que: (A1, A2, ..., AN)

              a1 appelé table de noeud de tête linéaire, AN appelé noeud queue

              Si le noeud est une table linéaire par la valeur ( ou sur la valeur de clé ) diminuant ( ou ascendant ) arrangement est ordonné

              Table linéaire est une structure de données très flexible qui peut augmenter ou diminuer la longueur requise

              Les éléments de données de la forme linéaire sont accessibles, des insertions et des suppressions.

       2.2 structure de données abstrait définissant la forme linéaire

             

ListLength détermine si le résultat de l'opération d'une table vide

L est un tableau vide retourne 0 , sinon sa longueur

       · Pour deux ensembles à la forme linéaire L représente, dans une nouvelle forme linéaire

              AUB = A , la table de dilatation linéaire LA, le B est présent dans le A en l'absence d'éléments insérés LA en

              étapes:

1. De la table linéaire LB afficher chaque élément getElem (LB, I) - > E
2. La valeur de la table linéaire LA accédé, il est déterminé s'il y a: LocElem (LA, E, égal ())
3. Le cas échéant, l'insertion ListeInsère (LA, n + 1, e) est inséré à la dernière position

      Fonctionnement de base :

1. Initialisation LC table vide
2. Respectivement, à partir de la LA et LB fait l'élément courant par intérim et BJ ;
3. Si ai <= bj, puis aÌ inséré dans le LC , sinon le bj inséré dans le LC moyen;
4. Répéter 2 et 3 étapes jusqu'à ce que LA ou LB est un élément fini est pris;
5. Le LA table ou LB copiés dans les éléments restants tableau LC table.

     algorithme:

void MergeList(List La , List Lb , List &.Lc)
{
	InitList(Lc);	//创建空表Lc
	int i = j = 1 ;	//链表已存在，0<=i<=ListLength(L)
	int k = 0;		 
	La_len = ListLength(La);	//获取表的长度 
	Lb_len = ListLength(Lb);	
	while((i<=La_len)&&(j<=Lb_len))		//在合法的范围内操作 
	{
		GetElem(La, i , ai);			//获取链表的每个元素 
		GetElem(Lb, j , bj);
		if(ai <= bj)					//将两个表的同一个位置的 元素对比 
			ListInsert(Lc , ++k , ai);	//在从0开始的位置开始先自增再插入 
			i++;			
		else
			ListInsert(Lc , ++k , bj);
			j++;
		while( i<= la_len) 				//如果比较的元素的个数小于表的长度
		{
			GetElem(La , i++ , ai);		//获取表的后面的元素 
			ListInsert(Lc , ++k , ai);	//在Lc表后面一个个的插入 
		}
		while( j<= lb_len)
		{
			GetElem(Lb , j++ , bj);
			ListInsert(Lc , ++k , bj);
		}
	}
 }

2.3 pour atteindre la forme linéaire

       2.3.1 Structure de stockage séquentiel

       stocker de manière séquentielle: la table de noeud linéaire stockées dans l'ordre logique d'un groupe d'emplacements de mémoire contigus dans l'adresse.

( Abréviation: table de séquence )

       · Ordre logique linéaire forme compatible avec l'ordre physique;

       · La relation entre les éléments de données sont des éléments de « l'emplacement physique adjacents » dans l'ordinateur pour réaliser      

La première forme linéaire i éléments d'emplacement de stockage est LOC (AI), de la i + 1 position est une LOC (ai + 1) = LOC (AI) + l

即LOC (ai + 1) = LOC (A1) + (i-1) * l

       2.3.2 Définition structure: structure d'accès est une description de recherche de regard de la performance temporelle dans une structure de données

              Structure de stockage au hasard: les performances se réfère à la fois dans une structure de données de recherche est O (n) , à savoir, trouver la complexité temporelle de l'élément de données est une chaîne linéaire, par rapport à l'emplacement de l'élément dans la structure

              · Liste unique est une structure d'accès séquentiel.

       matrice de stockage caractéristique ayant une table de séquence aléatoire indique également que la propriété doit avoir une longueur linéaire de la table, le type de structure pour définir le type de tableau de commande.

1. Structure statique: Une fois que la table est pleine, vous ne pouvez pas développer

/*静态顺序表的定义*/
#define MaxSize 50
typedef struct{
	ElemType data[MaxSize];		//定义顺序表的元素 
	int length;			//当前长度 
}SqList; 				//顺序表的类型 

1. Structure dynamique: peut être étendue, une donnée nouvelle taille comprenaient des membres maxSize dans

2. #define InitSize 100
   typedef struct{
   	ElemType *data;			//指示动态分配数组的指针 
   	int MaxSize, length;	//数组的最大容量和当前长度 
   }SeqList; 			//动态分配数组顺序表类型
   

   Plus précisément, les opérations de CRUD mises en œuvre:

   /*在顺序表的第i个位置插入元素*/ 
   bool ListInsert(SqList &L, int i, ElemType e)
   {	if(i<1||i>L.length+1)
   		return false;
   	if(L.length>=MaxSize)
   		return false;
   	for(int j=L.length;j>=i;j--)
   		L.data[j]=L.data[j-1];	//位置后移 
   	L.data[i-1]=e;		//在后移的第一个位置前的位置赋值 
   	L.length++;			//长度+1 
   	return true;	}
   /*删除顺序表第i个位置的元素并将被删除的元素用引用变量e返回*/
   bool ListDelete(SqList &L, int i , ElemType &e)
   {
   	if(i<1||i>L.length)
   		return false;
   	e = L.data[i-1];	//第i个位赋值e
   	for(int j = i;j<L.length;j++)	//从插入的位置开始
   	{
   		L.data[j-1] = L.data[j];	//后面所有的元素前移
   	}
   	L.length--;
   	return true;
   }
   
   /*查找线性表中值为e的元素并返回位置*/
   int LocateElem(SqList L , ElemType e)
   {
   	int i;
   	for(i=0;i<L.length;i++)	//依次遍历
   	{
   		if(L.data[i]==e)	//判断是否是e
   			return i+1;	//返回其位序
   	}
   	return 0;
   }
   /**删除顺序表中最小值，由最后的元素填补这个位置**/
   bool Del_Min(sqList &L , ElemType &value)
   {
   	if(L.length == 0)
   		return false;
   	value = L.data[0];
   	int pos = 0;
   	for(int i = 1; i<L.length; i++)
   		if(L.data[i]<value)
   		{
   			value = L.data[i];
   			pos = i;
   		}
   	L.data[pos] = L.data[L.length - 1];
   	L.length--;
   	return true; 
   }