DS блог работа 01- линейной таблицы

0.PTA оценка Скриншот

1,1 линейного резюме обучения таблицы

1. Основная концепция линейной формы

Линейный список представляет собой конечную последовательность п, имеющих те же характеристики, все элементы принадлежат к тому же типу данных. Логическая структура простой линейной формы, и облегчить работу, широкий диапазон применения. Помещение для хранения можно разделить на: таблицы последовательности и связанный список.

2. заказ столика

Данные последовательно сохраняются в непрерывном блоке физического пространства, каждая ячейка памяти адрес между узлами является непрерывным.

Структура определяется

typedef struct node{
    ElemType data[MAX];
    int length;//保存线性表的长度，或者也可以定义int型变量last用于保存线性表中最后一个数据所在的位置下标。
}Node，*NodeList；

Основные операции

• Таблица последовательности вставки : по существу , управлять мобильными траверсами массива с нуля, найти вставку в положении, массив начинает движение или при перемещении из массива стороны сравнения конечного, чтобы найти положение вставки, непосредственно вставлена;
  

  • Псевдо-код:

  void InserList(NODE & list,int x)
  {
    判断顺序表是否满了，如果满了就return
    for i=list.length to 0  //从末尾开始一个一个把数据右移，直到找到x的插入位置停止。
        if  x>list.data[i-1]  //找到插入位置，退出循环；
            break;
        else
            list.data[i]=list.data[i-1];//数据进行右移；
        end if
    end for
    list.length++;//一定要记得修改顺序表的长度！
    list.data[i]=x;//插入数据；
  }

  • Специальный код и достижение результатов:
    

• Удаление заказ столика : Мобильный массив данных, по существу , в, способ , обычно используемый реконструированный таблица последовательности.
  

  • Псевдо-код:

  void DeleteData(NODE &list, int x)
  {
   定义变量i来遍历顺序表；
   定义变量j并初始化为0；
   定义变量flag用于判断删除是否成功,初始化为0；
  
   for i=0 to list.length
      if(list.data[i]!=x)//不是删除的数据x就存入顺序表中；
          list.data[j++]=list.data[i];
      else 
          flag=1;
      end if
   end for
   list.length=j;
   判断是否删除成功。
  }

  • Специальный код и его результаты:
    

3. односвязанны список

Диспергирование данных, хранящиеся в физическом пространстве, адрес ячейки памяти между соответствующими узлами не обязательно непрерывный, который является логическим увеличивается указатель отношения дальше, устанавливая указатель цепи для сохранения данных.

Структура определяется

typedef struct node
{
    Elemtype data;
    struct node* next;
}Node,*ListNode;

Основные операции

• Первый метод интерполяции , чтобы создать единую цепь : узел противоположность порядка в логическом порядке.
  
  • Псевдо-код:

  void GreatList(ListNode&head,int n)
  {
    head=new Node;//为list申请空间；
    head->next=NULL;
    定义结构体指针ptr来保存每一个结点；
  
    for i=0 to n
        ptr=new Node;//为ptr申请空间；  
        输入数据赋给ptr->data;
        ptr->next保存头结点head的下一个结点；
        head->next保存ptr；
    end for
  }

  • Специальный код и достижение результатов:
    

• Интерполяция хвост устанавливается цепь : Последовательность перехода и та же последовательность в качестве логического связанного списка.
  

  • Псевдо-код:

  void GreatList(ListNode& head,int n)//尾插法
  {
   定义结构体指针ptr保存每个结点；
   定义结构体指针tail指向链表尾部；
   /*初始化链表*/
   head=new Node;
   head->next=NULL;
   tail=head;//尾指针先指向头结点；
  
   for i=0 to n
      ptr = new Node;
      输入数据赋给ptr->data;
      ptr->next=NULL;
      tail->next=ptr;//先连接；
      tail=ptr;//再移动tail；
    end for
  }

  • Специальный код и достижение результатов:
    

• Цепь вставляется
  при вставке данных, когда мы находим позицию вставки, нам нужно изменить предшественник и преемник указатели положения указателя, то нужно определить предшественник предшественника провести предварительный указатель вставляя позицию, мы модифицировали так удобно
  

  • Псевдо-код:

  void InserData(ListNode& list)
  {
   定义结构体指针pre用来保存前驱指针；
   定义结构体指针ptr保存插入的数据；
   初始化ptr；
  
   输入数据赋给ptr；
   while(pre->next && 未满足插入条件)
         pre = pre->next;
   end while
   ptr->next=pre->next;//先保存后继指针；
   pre->next=ptr;//再修改前驱指针；
  }

  • Специальный код и достижение результатов:
    
• Список удаление
  и вставка в виде связанного списка, также необходимо изменить предшественника и преемника удаления позиции, он также установить предвестником здесь , относится к предварительно положительный предшественник для сохранения.
  
  • Псевдо-код:

  void DeletData(ListNode& list)
  {
   定义结构体指针pre保存删除位置的前驱；
   定义结构体指针ptr保存删除的结点；
   输入需要删除的数据赋给x；
  
   while(pre->next && 未找到删除的数据)
      pre=pre->next;
   end while
   if  pre->next == NULL //说明没有找到删除的数据
      输出删除失败；
   else //找到了删除的数据；
      ptr=pre->next;//ptr保存需要删除的结点；
      pre->next=ptr->next;//连接删除结点的前驱和后继；
   end if       
  }

  • Специальный код и достижение результатов:
    
• разворот одноцепочечного
  приведет реверсирование один список узлов, по существу, является использование первого метода интерполяции, может быть изменено непосредственно на оригинальный одного связанный список, где нужно хранить указатель правопреемника последних обратно немодифицированные данные;
  
  • Псевдо-код:

void ReverseList(ListNode& L)
{
   定义结构体指针ptr保存当前结点；
   定义结构体指针latter保存原链表中ptr的后继结点；
   latter=L->next;
   L->next=NULL;//重构链表；
   while(latter!=NULL)//遍历原链表；
        ptr=latter;
        latter=latter->next;//保存ptr的后继结点；
        /*头插法*/
        ptr->next=L->next;
        L->next=ptr;
   end while   
}

• Специальный код и достижение результатов:
  

• Список сегментация : сущность является приложением для удаления узлов и интерполяции головы.
  

  • Псевдо-код:

  void SplitList(ListNode& L, ListNode& L1, ListNode& L2)
  {
   定义结构体指针ptr1来遍历链表L1；
   定义结构体指针ptr2来保存属于链表L2的结点；
   /*初始化链表L2*/
   L2-next=NULL;
   L1=L;//L1和L共享结点；
   ptr1=L1->next;
  
   while(ptr1!=NULL && ptr1->next!=NULL)//判断是否遍历结束
        ptr2=ptr1->next;//ptr2保存要插入L2的结点；
        /*L1做删除结点操作*/
        ptr1->next=ptr2->next;
        ptr1=ptr2->next;
        /*ptr2保存的结点用头插法编入L2中*/
        ptr2->next=L2->next;
        L2->next=ptr2;
    end while
  }

  • Конкретные операции и достижение результатов:
    

4. упорядоченный список

Это специальная линейная таблица, все элементы в порядке возрастания или убывания прописал.
Основные операции

• Создание упорядоченного списка : Указатель структуры PTR для сохранения номера , введенного пользователем, а затем траверса списка , чтобы найти подключаемую позицию.
  • Псевдо-код:

  void SortList(ListNode& list,int n)
  {
    定义结构体指针ptr保存新结点；
    定义结构体指针listPtr遍历链表list；
    /*初始化链表list*/
    list = new Node;
    list->next=NULL;
  
     for i=0 to n
          ptr=new Node;
          输入数据赋给ptr->data;
          listPtr=list;//开始遍历链表list；
          while(listPtr->next && 未找到插入位置)
               listPtr = listPtr->next;
          end while
      ptr->next=list->next;//开始进行插入；
      listPtr->next=ptr;
      end for
  }

  • Специальный код и достижение результатов:
    
• Упорядоченная вставка одной цепи : смотрите выше вставляются в один список
• Заказал один список для удаления данных - Удалить данные интервала
  6-3 JMU-ds- список раздел удален
  • Псевдо-код:

  void DelList(ListNode& L, int min, int max)
  {
  定义结构体指针pre，用pre->next来遍历链表;
  pre=L;
  while(pre->next!=NULL)
      if(pre->next->data <= max && pre->next->data >= min)
            p = pre->next;
            pre->next = p->next;//改变pre的后继结点；   
            delete p;
      else if(pre->next->data>max)//因为是有序链表，所以如果数据大于删除区间的最大值就已经完成了删除。
            break;
      else //pre->next->data < min的情景。
            pre=pre->next;//要继续往下遍历；
      end if
   end while  
  }

  • Специальный код и достижение результатов:
    

• В сочетании сортируются связанный список : каждый L2 , по существу , узел вставляется в положении , соответствующем L1, L1 , вставляется в результате чего остатки данных заказанной;
  

  • Псевдо-код:

void MergeList(ListNode& L1, ListNode L2)//合并链表，使结果呈递增排序
{
   定义结构体指针ptr1和ptr2分别用来遍历L1和L2；
   定义结构体指针temp；
   ptr1=L1;
   ptr2=L2->next;
   
   while(ptr2!=NULL)
        if (ptr1->next->data > ptr2->data)//找到L1中可插入的位置
              temp = ptr2；//用于保存L2中需要插入的结点；
              ptr2 = ptr2->next;//继续遍历L2；
              /*把temp插入L1中*/
              temp->next=ptr1->next;
              ptr1->next=temp;
        else if （ptr1->next->data==ptr->data）//用于删除重复的数据
               ptr2=ptr2->next;//跳过重复数据；
        end if
        ptr1=ptr1->next;
        if(ptr1->next==NULL && ptr2!=NULL)//链表L1遍历完毕L2没有遍历完
               ptr1->next=ptr2;//直接L2中剩余的结点连接到当前ptr1指向结点的后面   
               break；
        end if
}

• Специальный код и достижение результатов:
  

Дважды связанный список

Структура определяется

struct Node
{
    ElemType data;
    struct Node *prior;//指向前驱结点；
    struct Node *next;//指向后继结点；
};

особенность

• Начиная с любого одного узла может найти предшественник и преемник узел узла;
• Независимо от начальной точки, с которой узел, вы можете получить доступ к другим узлам, узлы могут получить доступ только один список позади узла.
• При выполнении операции вставки и удаления не нужно определить предшественник указателя, предшественник двойной связанный указатель списка в списке могут быть вставлены и удалены;

6. циклический список

• Одно петля цепи: тип узла и одной цепи ациклической же, за исключением того, что одноцепочечный указатель круглого стола в домене конечного узла, направленном в узел заголовка, весь список, чтобы образовать кольцо. Таким образом, любой один узел в списке можно найти, начиная с любой точки.
• Круговая дважды связанный список: тип узла и некруглое дважды связанный список, за исключением того, что круговой дважды связанный список в таблице указателей правопреемником хвостовой узел в точки заголовка Предшественник указатель, указатель заголовка предшественника указывает на последующий указатель на конечный узел.

1.2 пары линейной формы понимания и опыта обучения

Точка линейный список много знаний, и очень гибкий. Начинают узнать немного рывками, он не будет использовать. После двух недель обучения линейной таблицы уже есть в общих чертах. Но когда субъект еще обычно делают пропустить некоторые детали, в результате чего программа пойдет не так. Например, при создании списка, я часто забываю получить свой хвост точку перехода к NULL, в результате чего программы к сбою в выходную бесконечную петле. Даже тогда, когда я понял, или там будет много мелких деталей могут отсутствовать, я думаю, что это должно быть, я не достаточно опытный, или не хватает кода кисти, кисти рядом с кодом, и более Подводя итог резюме опыта проблемы и решения. Узнав о линейной форме только начался, мало контактов со следующей главой стеки школьного чувства теперь, кажется, только поцарапали поверхность линейной формы (возможно, даже мех не очень), есть много будущего нам нужно много мы можем узнать много много.

2.PTA лабораторные задания

Укажите количество взаимных 2.1 м

2.1.1 Код Скриншот

Первый метод:

Второй метод:

2.1.2 Название PTA представляет список инструкций

Этот вопрос я попытался выше двух методов, различные ошибки , возникающие при различных методах испытаний.
Метод один:

Q：运行时错误
A：起初不知道运行时错误是什么意思，以为是网页有问题于是就多试了几下。后来发现是因为我没有让链表的尾结点指向NULL，因为在自己写代码的时候没有实现销毁链表这一函数，所以我的程序能运行成功并输出正确的答案。但是在过测试的时候，由于需要执行销毁链表，找不到尾结点，程序就无法结束导致运行错误；

Способ второй:

Q：部分正确
A：刚开移动q时，用的是for循环，循环变量i是从1开始，当q指向第m个数退出循环时，i等于m+1，不等于m，而我下面用i==m时来判定位置合法，i!=m时位置无效，显然无论我输入的m是否合法，其结果都是无效；
Q：部分错误
A：我没有发现上面那个错误，修改了判断位置是否有效的条件，导致原本位置应该无效的变成有效的，最后对空指针进行取值导致位置无效的测试点段错误。
Q:部分错误
A：判断位置是否有效的条件少了一个等号；
Q:编译错误
A：复制代码时没有把最后的大括号复制进来；

2.2 одномерные полиномиальные операции умножения и сложения

2.2.1 Код Screenshot

2.2.2 Название PTA представляет список инструкций

Q:部分错误
A：没有考虑到同项需要再进行相加减；
Q：部分错误
A：同项相消时为0，输出时，要舍去不输出，我全部都输出了。
Q:部分错误
A：当结果为零多项式时，我没有输出，因为为0的全部都跳过输出了。于是我设置了变量flag，只要有输出就改变flag的值，如果flag的值没有改变，则表结果为零多项式，需要输出0 0

2.3 Таблица Последовательность действий

2.3.1 Код Скриншот

2.3.2 Название PTA представляет список инструкций

Q：编译错误
A：我编程时用的是C++的语法，而题目规定用c语言
Q：答案错误
A：题目理解错误，我以为读顺序表的插入只能插入数组的最后一位数后面。
Q：答案错误
A：删除数据的函数中，判断位置是否合法的条件错误，非法的应该是小于0或者大于last，我写的是大于MaxSize或者小于last。
Q：部分错误
A：不小心将自己为了方便在vs中调试而设置的输出代码一起复制进来。

3. считывание кода

3.1 добавляет два номера

• титульный
  
• код

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode sum = l1;
        while(l1.next!=null&&l2.next!=null){
            l1.val += l2.val;
            l1 = l1.next;
            l2 = l2.next;
        }
        l1.val += l2.val;
        if(l1.next==null&&l2.next!=null){
            l1.next = l2.next;
        }
        l1 = sum;
        while(l1.next!=null){
            if(l1.val>9){
                l1.val -= 10;
                l1.next.val++;
            }
            l1 = l1.next;
        }
        if(l1.val>9){
            l1.val -= 10;
            l1.next = new ListNode(1);
        }
        return sum;
    }
}

作者：lhpyxjn75x
链接：https://leetcode-cn.com/problems/add-two-numbers/solution/2liang-shu-xiang-jia-jian-dan-bao-li-2ms-by-lhpyxj/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3.1.1 идеи дизайна

С первого запуска , добавив два списка, результаты сохраняются непосредственно всем l1, а затем начал рассматривать вопрос переноса , чтобы отметить здесь , когда число последнего номера в списке l1 и l2 список потребностей путем добавления переноса, l1 Нам необходимо разработать новое пространство , чтобы сохранить новый номер.

Предоставленные м биты сохраняются l1, l2 п бит сохраняется.

• Временная сложность O (M + N): первый из цикла в то время как Траверсы мин (м, п) раз, в то время как вторая петля через макс (M, N) раз, временная сложность O (т + п ).
• Космическая сложность O (1): Потому что, когда суммируются, сумма каждой цифры результатов сохраняются l1, только последнюю цифру необходимости сумма Карри, чтобы открыть пространство для сохранения, поэтому пространство сложность O ( 1).

3.1.2 псевдокод

定义一个结构体指针sum来保存l1的头指针；
while(l1->next!=NULL && l2->next!=NULL)//把两个数每一位都先进行相加；
     l1->val += l2->val;
     l1 = l1->next;
     l2 = l2->next;
end while
l1->val += l2.val;//循环遍历到l1和l2中有一个后继结点为NULL时停止，退出循环时当前的位上的数还未相加
if(l1->next == NULL && l2->next!=NULL)//l2的位数比l1多直接把l2后面的数连接到l1后面
     l1->next=l2->next;//直接把l2后面的数连接到l1后面  
end if
l1=sum;//指向头指针；
while (l1->next!=NULL)//开始处理进位问题；
     if(l1->val>9)
         l1->val-=10;
         l1->next->val++; 
     end if
     l1=l1->next;
end while
if(l1->val>9)//遍历到最后一位数时，如果需要进位，必须要开辟新的空间
     l1->val-=10;
     l1->next=new ListNode(1);
end if
return sum；

3.1.3 Операционные результаты

3.1.4 Анализ преимуществ и трудностей в темах решения проблем

Преимущества: Этот вопрос требует , чтобы мы нашли два числа, вычисляется из минимального числа два положения , в соответствии с нашим обычным мышлением, вопросы были очень дружелюбен вводом данных в обратный порядок, и существенно сократить запись бремени кода, нам нужно только объединить знания в соответствии с завершением основного кода школы на нем.
Сложность: Для нас используется для списка , содержащего головной узел, код тестовой записи , когда вам нужно немного мысли, а не в соответствии с формулировкой оригинала имеет головной узел для создания списков или , чтобы определить , является ли выходом из цикла. И вы можете видеть от автора кода, которые появляются в два места объединены в оборот внутри кода, но все же можно выделить для исполнения, обратить особое внимание на эти два места, если все слияния в обращении, он будет делать l1 указатель указывает на значение нуль и неправильная работа указателя нуль.

Узел связанного список 3.2 двадцать два переключения

• тема:
  
• Код:

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;
        return next;
    }
}

作者：guanpengchn
链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs/solution/hua-jie-suan-fa-24-liang-liang-jiao-huan-lian-biao/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3.2.1 идеи дизайна

С самого начала к первой цепи два два узла в целом, каждый из двух узлов обменивается во всей полноте, первоначально первый узел всегда подключен к следующему всему второму узлу (обмен после изменений в целом в первом узле), мы обеспечили рекурсивный алгоритм, первый прогрессивный или последние два числа ряда, последний начинает обмен данными, возврат после обмена завершен к одному. Первый узел текущего соединения во всей спине после данных был произведен обмен, то весь ток движется узла во второй перед первым узлом.

Предоставленный список есть п узлов:

• Временная сложность O (N): число раз рекурсивная п / 2, число рекурсии необходимости работать каждый раз, когда была в 4 раза, то время сложность Т (N) = 4 * (N / 2) + 1 = O (N );
• Пространство сложность O (N): число раз рекурсивная п / 2, каждый рекурсия занимает занимает пространство, сложность пространства Т (N) = N / 2 = O (N);

3.2.2 псевдокод

if head == NULL || head->next==NULL //结束标志，不管head为NULL还是为最后一个节点，都不影响，一位递归回去的指针总是当前整体中的第一个结点；
      return head;
end if
ListNode next=head->next;//next指向当前整体中的第二个结点；
head->next = swapPairs(next->next);//当前整体中的第一个结点先连接上已经交换过结点后的下一个整体中的第一个结点(就是原来该整体的第二个结点)
next->next=head;//将该整体的第一个结点移动到第二个结点后面；
return next;//原本的第二个结点现在变成这个整体中的第一个结点，返回到上一级函数。 

3.2.3 Операционные результаты

3.2.4 Анализ преимуществ и трудностей в темах решения проблем

Преимущества: Этот вопрос не является рекурсивным алгоритмом не является проблемой, например, открыть новый список для обмена данных , хранимого, идея относительно проста, рекурсивный алгоритм трудоемкость и то же, но сложность пространства 0 (1) , чем рекурсивная алгоритм , чтобы быть маленьким, даже не может придумать рекурсивный алгоритм, использование не-рекурсивного алгоритм также относительно легко реализовать,
трудность: Я думаю , что трудность этого вопроса является использование рекурсивного алгоритма , когда код , когда я увидел это , когда я не знал (Магический ). Весь алгоритм мышления рекурсивного очень умный и гибкий, просто понять этот код , который я провел в ночное время. Рекурсивный алгоритм все равно придется сделать, неграмотным действительно видеть , что видеть (темные круги предупреждения!).