0.PTA anotar Captura de pantalla

1. Este resumen de aprendizaje semana

Tabla 1.1 resume el contenido lineal

* Una tabla de secuencia:

Secuencia estructura de almacenamiento de tabla: todos los elementos en la forma lineal para el almacenamiento en el orden de la estructura de almacenamiento de tabla de secuencia se convierte.
Las ventajas y desventajas de orden de almacenamiento:

优点：
1.逻辑相邻，物理相邻
2.无须为表示表中元素之间的顺序关系增加额外的存储空间
3.可随机存取任一元素
4.存储空间使用紧凑
缺点：
1.插入、删除操作需要移动大量的元素（除操作在表尾的位置进行外）
2.预先分配空间需按最大空间分配，利用不充分 
3.表容量难以扩充

Características de la tabla de secuencia: 1 es decir, adyacente dirección física implementado elementos de datos lógicamente adyacente;
2 pueden implementarse en elementos de datos de acceso aleatorio; (almacenada en forma de una matriz)
ilustran como sigue:
La estructura es la tabla de secuencia definida:
ejemplo Pila Área:

typedef int ElemType; 
typedef struct 
{   
    ElemType data[MaxSize];     //存放顺序表元素
    int length ;                //存放顺序表的长度
} List; 
typedef List *SqList;

ejemplos Heap:

tabla básica para la operación *

:( tabla de secuencia de inicialización para crear una nueva lista)

void CreateList(SqList& L, int n)
{
    int index = 0;
//初始化顺序表
    L = new List;
    L->length = n;
    //给表中数据元素赋值
    while (n--)
        cin >> L->data[index++];
}

tabla de orden de eliminación :( tiempo complejidad de O (1))

void DeleteList(SqList* &L)
{
    delete L;
}

Determinar si la mesa vacía:

bool ListEmpty(List L)
{
    return(L->length == 0);
}

Longitud de la tabla de cálculo:

int ListLength(List L)
{
    return(L->length);
}

La secuencia de datos de salida tabla :( tiempo complejidad de O (n))

void DispList(List L)
{
    int i;
    if (L->length == 0)
    {
        cout << "NULL";
    }
    else
    {
        for (i = 0; i < L->length; i++)
            cout << L->data[i] << " ";
    }
}

Búsqueda en una tabla de datos de secuencia:
Encuentra :( i-ésimo elemento de la complejidad en tiempo de O (1))

返回L中第i个元素的值，存放在e中。1≤i≤ListLength(L)
bool GetElem(List L,int i,ElemType &e){ 
    if (i<1 || i>L->length)
        return false;
    e=L->data[i-1]; 
    return true;
}

Encuentra :( valor del elemento por la complejidad en tiempo de O (n))

将顺序表中的元素逐个和给定值 e 相比较。
int LocateElem(List L, ElemType e){
    for(int i=0; i<L->length;i++)
        if(L->data[i]==e)
            return i+1;       //返回元素的逻辑位序
    return 0;
}

tabla Inserción de secuencia de datos (la complejidad de tiempo de O (n))

Insertar datos Código:

bool ListInsert(List &L,int i,ElemType e)
{  int j;
   if (i<1 || i>L->length+1)
    return false;   //参数错误时返回false
   i--; //将顺序表逻辑序号转化为物理序号
for (j=L->length;j>i;j--)   //将data[i..n]元素后移一个位置
  L->data[j]=L->data[j-1];
L->data[i]=e;           //插入元素e
L->length++;            //顺序表长度增1
return true;            //成功插入返回true
}

Nota inserto de puntos de datos:

El número de elementos móviles:

Cuando i = n + 1, el número del móvil es 0;
i, el número de móvil n-i + 1
Cuando i = 1, el número de móvil es n, alcanza su máximo.
Se inserta un total de n + 1 en la posición, la probabilidad pi = 1 / n + 1
El número medio de elementos móviles como:
Tabla de elementos con el fin de eliminar

el código en cuestión:

bool ListDelete(List &L,int i,ElemType &e)
{  
   if (i<1 || i>L->length) //删除位置不合法
        return false;
   i--;         //将顺序表逻辑序号转化为物理序号
   e=L->data[i];
   for (int j=i;j<L->length-1;j++)         
      L->data[j]=L->data[j+1];
   L->length--;     //顺序表长度减1
   return true;         
}

Eliminación de elementos complejidad del tiempo:

Cuando i = n, el número del móvil es 0;
Cuando i = 1, los tiempos de movimiento n-1.
pi Supongamos que es la probabilidad de la supresión de la i-ésima posición sobre el elemento: 1 / n
El número medio de veces que la longitud deseada de la n-movimiento lineal elementos para eliminar un elementos de la tabla:

* Dos lista única:

Cadena es un almacenamiento de tabla de cadena lineal

Estructura:
Nodo = + Puntero Elemento de datos
1. Elemento: el almacenamiento de datos
2. Los punteros: un elemento de almacenamiento de la ubicación de almacenamiento en el nodo
se muestra en la lista es:
estructura de lista de definiciones:
Nodo puntero del plomo:

a una dirección de memoria lineal en la primera mesa como un elemento de datos de direcciones a1 forma lineal, lineal llamada lista de punteros de cabeza.
Para facilidad de tiempos de operación, antes de que el primer nodo virtual además de un "nodo de cabeza", a punto para el puntero del nodo de cabecera de la lista de punteros cabeza.

Los beneficios proporcionados primer nodo:
⒈ primer elemento facilita los nodos de procesamiento:
el nodo almacenado campo puntero de dirección primer elemento en el nodo de cabecera, la operación en la primera posición en la lista y otras ubicaciones en el mismo, sin la necesidad de tratamiento especial;
⒉ facilitar mesas vacías unitario y lista no vacía:
si la lista está vacía, el puntero de cabeza está apuntando a un puntero no nulo al nodo de cabeza, el procesamiento de no nulo tabla lista vacía también unificado.
Esto es:

una lista enlazada se determina de forma única por la cabecera, por lo que una sola lista enlazada se puede utilizar para nombrar el nombre del puntero de cabecera, el puntero de cabeza si el nombre es L, poner la lista mencionada en la Tabla L.

lista de inicialización:

typedef struct LNode{
     ElemType   data;       //数据域
     struct LNode  *next;   //指针域
}LNode,*LinkList; 
Status InitList_L(LinkList &L){ 
   L=new LNode;  此处若写为L=new LinkList 错误，L要申请LNode大小的内存空间                    
   L->next=NULL;　　　　　
   return OK; 
}

Crear una nueva lista:
cadena establecido interpolación 1. Cabeza (lista enlazada se inserta el nuevo nodo de la cabeza):

códigos para el nuevo nodo se inserta como s:
S-> Siguiente = L-> Siguiente;
L-> Siguiente = s;

* Cabeza conecte la cadena establecida del Código de Derecho:

void CreateListF(LinkList &L,ElemType a[],int n){
    int i;
           L=new LNode;
    L->next=NULL;   
          LinkList nodePtr;
    for(i=0;i<n;i++){
         nodePtr=new LNode;//每个节点都要动态申请空间
         nodePtr->data=a[i];
         nodePtr->next=L->next;
        L->next= nodePtr;
    }
}

cadena 2. cola interpolación establecido (lista enlazada el nuevo nodo se inserta desde la cola):

el nuevo nodo en la tabla de lista enlazada en la corriente de cola se debe añadir un puntero de cola r, siempre punto al nodo final de la lista actual.
puntero de cola:: por ejemplo, R & lt
R-> Siguiente = S;
R & lt = S
beneficio de la adición puntero de cola: la salida de salida de un contenido de cadena entera en lugar de un nodo, puede proteger el nodo de cabeza, la adición de un nuevo nodo no cada recorrer la lista en busca de un último nodo.

* Código de cola de interpolación:

void CreateListR(LinkList &L,ElemType a[],int n){
    int i;
    LinkList  nodePtr,tailPtr;
            L=new LNode;
    L->next=NULL;   
    tailPtr=L;//尾指针
    for(i=0;i<n;i++)  {
        nodePtr=new LNode;
        nodePtr->data=a[i];
        rearPtr->next=s;//尾部插入新结点
        rearPtr=s;  }
       nodePtr->next=NULL;
}

lista Destrucción:
la lista de la tabla de orden para la destrucción diferente, no para eliminar toda la cadena de acuerdo con la dirección de nodo de cabeza, porque la dirección de cada nodo en la cadena no son necesariamente contiguas, de modo que cada nodo que desea eliminar uno por uno.

void DestroyList(LinkList &L){
    LinkList p;
    while(L){
        p=L;
        L=L->next;
        delete p;   
    }
}

Juicio mesa vacía:

bool ListEmpty(LinkList *L)
{
　　return(L->next==NULL);
}

Longitud de la tabla de cálculo:

int ListLength(LinkList L)
{　int n=0;
　 LinkList p=L->next;   
   while (p)
   {    n++;
    p=p->next;
   }
   return(n);   //p指向尾节点,n为节点个数
}

En Salida:

void DispList(LinkList L)
{
    int flag = 1;
    LinkList p = L->next;
    while (p)
    {
        if (flag)
        {
            cout << p->data;
            flag = 0;
        }
        else
        {
            cout << " " << p->data;
        }
        p = p->next;
    }
}

Encuentra elementos de datos:
los elementos de datos de la lista no es tan lineal como la tabla de acceso aleatorio tiene que recorrer la lista

bool GetElem(LinkList L,int i,ElemType &e)
{  int j=0;
   LinkList p=L;    //p指向头节点,j置为0(即头节点的序号为0)
   while (j<i && p!=NULL)   //找第i个节点
   {    j++;
    p=p->next;
   }
   if (p==NULL) //不存在第i个数据节点,返回false
    return false;
   else     //存在第i个数据节点,返回true
   {  e=p->data;
    return true;
   }
}

Insertar elemento:

Sea P apunta a ai-1, letra e s, a continuación, inserte el código como:
S = new nueva LNode;
S> Datos = E;
S> Siguiente = p-> Siguiente;
p-> Siguiente = S;

* Los elementos de datos insertados antes de la L I E-ésimo elemento:

bool ListInsert(LinkList &L,int i,ElemType e){
  int j=0;
  LinkList p=L,s;
  while(p&&j<i-1){
    j++;p=p->next;
  }//查找第i-1个节点
  if(p==NULL) return false; //未找到第i-1个结点
  s=new LNode;
  s->data=e;
  s->next=p->next;  //插入p后面
  p->next=s;    
  return true;
}

elementos de datos Eliminar:
Eliminar el i-ésimo nodo en una única lista enlazada de operaciones básicas: encuentra la primera i-1 nodos lineal mesa, que está dirigida a la modificación posterior de punteros.

Eliminar elementos de datos nodo q:
q = p> A continuación,
p-> = Q Siguiente> Siguiente;
E = Q> Datos;
borrado q;

* Eliminar elementos de datos Código:

bool ListDelete_L(LinkList &L,int i,ElemType &e)
{
     int j=0;
  LinkList p=L,s,q;
  while(p&&j<i-1){  
    p=p->next;j++;//指针每次next前都要判断是否空指针
  }
  if(p==NULL) return false;

    q=p->next;  //第i个位置
  if(q==NULL) return false; 
      e=q->data;
      p->next=q->next;//改变指针关系，删除
      delete q;
     return true;
}

Lista de resumen:
1. El proceso de atravesar la lista es importante tener en cuenta si el puntero es NULL, en particular, p-> Siguiente o p-> p es importante considerar si los vacíos de datos antiguos
cambios 2. Lista, a menudo reconstruidos. Reconstrucción de competencia:
la p de L - => el siguiente; de L-> la siguiente = NULL;
3. Listas como borrar, prestar atención a considerar el caso de la lista estaba vacía
4. listas como el tiempo de inserción, prestar atención a saber dónde está el puntero del precursor en el punto de inserción se pueden obtener por pre> siguiente.
5. Para conservar los punteros sucesores, pueden ser diseñados nextptr = p-> siguiente, cambios intermedios p, entonces p = nextptr.
6. diseño de la cadena, llegando a comprender el estado actual del puntero.

* III. Lista ordenada

lista ordenada diferente y la lista de orden, la tabla de orden es A, es decir vecina dirección de elemento de datos físicamente adyacentes lógico. La lista ordenada es el valor del elemento de datos estaba en la forma de orden ascendente o descendente.
La relación lógica entre la forma lineal y la lista ordenada de elementos, que diferencia se implementa la operación.
Ordenó insertar datos de tabla:

El método de inserción se puede dividir en dos diferentes orden de búsqueda:
* 1: el primer turno hallazgo:

void ListInsert(SqList &L，ElemType e)
{     int i=0，j;
      while (i<L->length && L->data[i]<e)
    i++;            //查找值为e的元素
      for (j=ListLength(L);j>i;j--) //将data[i..n]后移一个位置
    L->data[j]=L->data[j-1]; 
      L->data[i]=e;
      L->length++;      //有序顺序表长度增1
}

* Método 2: en la búsqueda de cambio de borde:

void InsertSq(SqList &L,int x)
{
    for(int j = L->length; j > 0; j--)
    {
        if (x >= L->data[j-1]) //找
        {
            L->data[j] = x;
            break;
        }
        L->data[j] = L->data[j-1];//移动，边移边找
        L->data[j-1] = x;//保证第一个数据插入
    }
    L->length++;

}

Hay diferentes métodos de acuerdo con la estructura definida por 3:

void ListInsert(LinkNode &L，ElemType e)
{     LinkNode pre=L，p;

      while (pre->next!=NULL && pre->next->data<e)
    pre=pre->next;  //查找插入结点的前驱结点*pre

      p=new LinkNode;
      p->data=e;        //创建存放e的数据结点*p
      p->next=pre->next;    //在*pre结点之后插入*p结点
      pre->next=p;

}

merge lista ordenada
1. lista ordenada LA (m elementos) y LB (n elementos) en una lista ordenada LC:
Pensamiento "" 2 durante la exploración de la lista ordenada LA, LB, de comparación de elementos de LA, LB, menor es el elemento de inserción la lista LC combinado, repetir el proceso hasta que se completa un recorrido de tabla ordenada. Los restantes elementos se insertan en la tabla ordenada LC.
La complejidad de tiempo de este algoritmo es O (m + n), la complejidad espacial es O (m + n).

新建顺序表LC
i表示LA的下标，j表示LB的下标
while(i<LA.length&&j<LB.length)
{
      if (LA->data[i]<LB->data[j])   则LC中插入元素LA->data[i]，i++   
      else 插入元素LB->data[j]，j++   
      LC数组长度增1.
}     
查看LA或LB是否为扫描完毕，没扫描完的把剩余元素复制并插入LC

* Lista ordenada fusionar el código en cuestión:

void UnionList(SqList  LA，SqList  LB，SqList  &LC)
{     int i=0，j=0，k=0;//i、j分别为LA、LB的下标，k为LC中元素个数
      LC=new SqList;        //建立有序顺序表LC
      while (i<LA->length && j<LB->length)
      { if (LA->data[i]<LB->data[j])
    {     LC->data[k]=LA->data[i];
           i++;k++;
    }
    else    //LA->data[i]>LB->data[j]
    {     LC->data[k]=LB->data[j];
          j++;k++;
    }
       }   
     while (i<LA->length)       //LA尚未扫描完，将其余元素插入LC中
     {  LC->data[k]=LA->data[i];
    i++;k++;
     }
     while (j<LB->length)       //LB尚未扫描完，将其余元素插入LC中
     {  LC->data[k]=LB->data[j];
    j++;k++;
     }
     LC->length=k;
}

！！一定要注意有序表是否遍历完全的情况

2. La lista ordenada L1 y L2 se incorporan en la lista ordenada L1:

lista * todavía utilizan el espacio de almacenamiento original dos listas enlazadas, no ocupados de otro modo por otro espacio de almacenamiento.
Ideas: la lista L1 reconstrucción, p puntero L1 Guardar la lista original.
Mientras tanto Traversal L1, la lista L2, el elemento más pequeño en la lista enlazada L1. Hasta que una lista de escaneado. Sigue a insertar elementos de la lista que quedan en L1.
El código en cuestión es:

void MergeList(LinkList& L1, LinkList L2)
{
    LinkList p,q,tail,temp;
    p = L1->next;
    q = L2->next;
    L1 = new LNode;
    L1->next = NULL;
    tail=L1;
    while (p && q)
    {
        if (p->data < q->data)
        {
            temp = p;
            p = p->next;
        }
        else if (p->data > q->data)
        {
            temp = q;
            q = q->next;
        }
        else
        {
            temp = p;
            p = p->next;
            q = q->next;
        }
        tail->next=temp;
        tail=temp;
    }
    while (p)
    {
        tail->next = p;
        tail=p;
        p = p->next;
    }
    while (q)
    {
        tail->next = q;
        tail=q;
        q=q->next;
    }
    tail->next=NULL;
}

se eliminan los datos de lista ordenada:

先遍历链表找到要删除的元素e，查看它为第几个元素，假设e为第i个元素
then 找到第i-1个节点
    将第i-1个节点的后继改为第i+1个节点
    删除第i个节点

Y borrar la lista de estructura similar

* Cuatro pares de listas:

Cada nodo tiene un campo de puntero de lista de 2 doblemente enlazada, un puntero a un nodo subsiguiente, un nodo apunta al predecesor.

Tipo se define como sigue:

typedef struct DNode       //声明双链表节点类型
 {  ElemType data;
   struct DNode *prior;    //指向前驱节点
    struct DNode *next;     //指向后继节点
  } DLinkList;

El plomo nodo de la lista doblemente enlazada:
Doblemente lista de ventajas vinculado:
1. La partida puede encontrar rápidamente su precursor y sucesor nodo nodo desde cualquier nodo;
2 de cualquier un nodo puede acceder a otros nodos.
Doblemente lista enlazada inserto nodo:
por ejemplo, en después de que el nodo de la inserción de unión p s

instrucción de acción relacionado con:

 s->next = p->next
 p->next->prior = s
 s->prior = p
 p->next = s

: Doblemente nodo de lista enlazada borrar
un nodo después del nodo como la eliminación de p *

declaración de las operaciones relacionadas:

 p->next->next->prior = p
 p->next = p->next->next

El primer método de interpolación para establecer la lista doblemente enlazada:
crear la matriz primer nodo contiene n elementos de una lista doblemente enlazada L.

método de interpolación cabeza para construir la lista de código:

void CreateListF(DLinkNode *&L，ElemType a[]，int n)
{　 DLinkNode *s; int i;
       L=(DLinkNode *)malloc(sizeof(DLinkNode));    //创建头结点
       L->prior=L->next=NULL;   //前后指针域置为NULL
       for (i=0;i<n;i++)        //循环建立数据结点
       {    s=(DLinkNode *)malloc(sizeof(DLinkNode));
    s->data=a[i];       //创建数据结点*s
    s->next=L->next;    //将*s插入到头结点之后
    if (L->next!=NULL)          //若L存在数据结点，修改前驱指针
           L->next->prior=s;
    L->next=s;
    s->prior=L;
       }
}

El establecimiento de interpolación cola lista doblemente enlazada:
Crear el nodo de plomo de la matriz de una lista doblemente enlazada de n elementos que contienen L.

Código de la cola establecida interpolación de la cadena:

void CreateListR(DLinkNode *&L，ElemType a[]，int n)
{     DLinkNode *s，*r;
       int i;
       L=(DLinkNode *)malloc(sizeof(DLinkNode));    //创建头结点
       L->prior=L->next=NULL;   //前后指针域置为NULL
       r=L;         //r始终指向尾结点，开始时指向头结点
       for (i=0;i<n;i++)        //循环建立数据结点
       {      s=(DLinkNode *)malloc(sizeof(DLinkNode));
    s->data=a[i];       //创建数据结点*s
    r->next=s;     
              s->prior=r;   //将*s插入*r之后
    r=s;            //r指向尾结点
      }
      r->next=NULL;     //尾结点next域置为NULL
}

* V. lista circular

lista circular es otra forma de estructura de almacenamiento en forma de una cadena.

Circulación lista enlazada:

Difiere de la lista única:
1, desde una posición en cualquier nodo de la lista circular se pueden encontrar en todos los otros nodos, y no pueden individualmente listas enlazadas;
2. Condiciones lista circular de la cola de ciclismo no obvias:

	lista única	lista circular
En primer nodo	p-> siguiente! = NULL	p-> siguiente! = L
Sin nodo de cabecera	p! = NULL	p! = L

Circular doblemente enlazada cadena circular y única:

Acíclicos y cíclicos lista doblemente enlazada lista de diferencias doblemente enlazadas por:

1,2 metros lineales de comprensión y experiencia de aprendizaje:

Mesa lineal es una estructura lineal de la estructura lógica de datos, de acuerdo a su estructura puede ser diferente matrices de almacenamiento y lista separada de clase dos tipos, algunas operaciones aritméticas básicas de datos después de la dispensación. lista lineal es una secuencia finita de elementos de datos que tienen las mismas características.

Mesa lineal expresa generalmente como:
Lineal tabla característica es:

la experiencia de aprendizaje: la sensación de establecer la relación entre esta lista cada nodo, dependiendo de la complejidad del algoritmo será muy diferente, a veces en círculos alrededor del final no entender cuando a punto al siguiente nodo; sintiendo una gran parte del código se debe ajustar de acuerdo a la estructura de la zona de apilamiento algoritmo y el área montón, la inicialización básica y otras operaciones de rutina recordarán un simple punto.

tareas de laboratorio 2.PTA

Tabla sección lineal 2.1 -6-1-jmu DS- datos de borrado

实现在顺序表中删除某个区间数据。需要实现下述的三个函数完成该功能。
void CreateList(SqList &L,int n);//建顺序表，L表示顺序表指针，n表示输入数据个数。 
void DelNode(SqList &L,int min,int max);//删除区间元素。min,max表示删除的区间 
void DispList(SqList L); //输出顺序表内容 ，数据间空格隔开，尾部不能有空格。

2.1.1 Código de pantalla

2.1.2 El título PTA presentar una lista de instrucciones

Q1:运行超时：在建链表输入数据时将循环条件写成了n>0；导致无限循环
A1:将n>0修改为正确的n--
Q2:部分正确：在控制区间时，查找在区间的元素没有考虑相等的情况
A2:将查找条件改为L->data[index] >= min && L->data[index] <= max

2,2 ds-test-7-1 lista de secuencias de la intersección de dos ordenó

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2的交集新链表S3。
输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。
在一行中输出两个输入序列的交集序列，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。

2.2.1 Código de pantalla

2.2.2 El título PTA presentar una lista de instrucciones

! ! : La presentación se contenta tras otro y luego modificar el conjunto título equivocado, al presentar ha habido una gran cantidad de problemas.

Q1：编译错误：在将两个列表的交集存入新链表S3时，有个别表头名称弄混造成编译错误
A1：把写错的L改成了正确的S3，因为惯性就写成L了
Q2：部分正确：输出时忘记考虑表S为空表的情况
A2：在DispLinkList（）函数中添加上题干要求的if (!p)  cout << "NULL";的语句来表示S为空表的情况。

Tabla 2.3 lineal -6-3 jmu-DS- elemento de tabla de secuencia de duplicado de eliminación

设计一个算法，从顺序表中删除重复的元素，并使剩余元素间的相对次序保存不变。
输入格式: 第一行输入顺序表长度。 第二行输入顺序表数据元素。中间空格隔开。
输出格式：数据之间空格隔开，最后一项尾部不带空格。
输出删除重复元素后的顺序表。

2.3.1 Código de pantalla

2.3.2 El título PTA presentar una lista de instrucciones

Q1:部分正确：没考虑到表中元素全部重复的情况
A1:把循环条件next<L->length改为next<=L->length，如果全部重复，只留下第一个元素。
Q2:输出错误：输出空格时将flag初始成了0；造成编译错误
A2:把条件改为（flag=1）时不输出前置空格，再在循环中将后面的flag改为0，都输出前置空格；

3. código de lectura

3.1 Título y Código de resolución de problemas

tema:
La resolución de problemas Código:

class Solution {
  public ListNode rotateRight(ListNode head, int k) {
    // base cases
    if (head == null) return null;
    if (head.next == null) return head;

    // close the linked list into the ring
    ListNode old_tail = head;
    int n;
    for(n = 1; old_tail.next != null; n++)
      old_tail = old_tail.next;
    old_tail.next = head;

    // find new tail : (n - k % n - 1)th node
    // and new head : (n - k % n)th node
    ListNode new_tail = head;
    for (int i = 0; i < n - k % n - 1; i++)
      new_tail = new_tail.next;
    ListNode new_head = new_tail.next;

    // break the ring
    new_tail.next = null;

    return new_head;
  }
}

3.1.1 El problema de las ideas de diseño

complejidad Tiempo: O (n)
la complejidad de las instalaciones: O (1)

3.1.2 la cuestión pseudocódigo

Retrógrada algoritmo de lista enlazada similar:
los elementos de datos están conectados entre sí, de modo que puede definir el número de movimientos;
encontrar la posición correspondiente del bucle se desconecta, determina la cabeza de la lista y el nuevo final de la lista
para encontrar parte de cola de edad conectado a la cabeza de la lista y old_tail.next = cabeza, toda la lista como un bucle cerrado, mientras que el calculado longitud de cadena n.
Encuentra una nueva cola, el (n - k% n - 1 ) nodos, la nueva cabeza de lista es la primera (n - k% n) nodos.
Desconectar el anillo new_tail.next = Ninguno, y devuelve la nueva lista new_head cabeza.


public ListNode rotateRight(ListNode head, int k) {
    if (为空表) return NULL
    if (旋转结束) return 表头

    定义头结点
    int n;
    for (n = 1; 没走到目的节点; n++)
        当前指针后移一位
        当前指针的后继成为首节点
    end for
    ListNode new_tail = head;
    for (int i = 0; i < n - k % n - 1; i++)//旋转次数超过表中元素个数开始循环
        new_tail = new_tail.next;
    ListNode new_head = new_tail.next;

    end for
    结束循环

    return new_head;
}

3.1.3 resultados operativos

3.1.4 Análisis de las ventajas y dificultades de resolver el tema.

优势：
此做法巧妙在把链表连成了一个环，在移动节点时不用过多的去关注链表是否遍历到尾部的问题
难点：
难点在于当前指针和新首节点以及最后一个指针之间的关系转换，即old_tail和new_tail

3.2 Título y Código de resolución de problemas

tema:
código:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
        struct ListNode* partition(struct ListNode* head, int x){
    struct ListNode headLess, headGreater;
    struct ListNode *curLess, *curGreater;
    
    headLess.next = headGreater.next = NULL;
    curLess = &headLess; curGreater = &headGreater;
    
    while(head){
        if(head->val < x){
            curLess->next = head;
            curLess = curLess->next;
        }else{
            curGreater->next = head;
            curGreater = curGreater->next;
        }
        head = head->next;
    }
    curGreater->next = NULL;
    curLess->next = headGreater.next;
    
    return headLess.next;
}
}

3.2.1 El problema de las ideas de diseño

complejidad Tiempo: O (N)
complejidad espacio: O (N)

3.2.2 la cuestión pseudocódigo

/**
 * 维护两个链表，一个所有值小于x，一个所有值大于等于x，
 * 遍历原始链表，当值小于x时。curLess指向该节点，
 * 当值大于等于x时，curGreater指向该节点。
 */
struct ListNode* partition(struct ListNode* head, int x)
{
    定义两个链表，一个所有值小于x，一个所有值大于等于x：headLess, headGreater;
    struct ListNode* curLess, * curGreater;

    链表初始化
    curLess = &headLess; curGreater = &headGreater;

    while (不为空表) {
        if (表中元素小于x )  在表curLess中插入此数据
        end if
        else （表中元素大于x） 在表curGreater中插入此节点
        end else
        原表当前指针后移进行遍历
    }
    end while
    将表curGreater拼接到表curLess后

    return headLess.next;
}

3.2.3 resultados operativos

3.2.4 Análisis de las ventajas y dificultades en temas de resolución de problemas

优势：
设置两个链表来分别存储比x大和比x小的节点；
很好的保护了各个数据元素的原始位置；
用引用来保护要返回地址的头结点
难点：
链表拆分，临时节点，不能成环

Los primeros trabajos blog - Mesa lineal