DS博客作业02--线性表

0.PTA得分截图

1.本周学习总结（0-4分）

1.1 总结线性表内容

1.线性表

• 线性表定义：线性表是具有相同特性的数据元素的一个有限序列

• 线性表的抽象数据类型描述：ADT结构

2.顺序表

• 初始化InitList(结构体定义)

typedef int ElemType; 
typedef struct 
{      
     ElemType data[MaxSize];  //存放顺序表元素
      int length ;		    //存放顺序表的长度
} List;	
typedef List *SqList;
void CreateList(SqList &L,int n){
   int i;
   L=new List;
   L->length=n;
   for(i=0;i<n;i++)  cin>>L->data[i];
}

时间复杂度:O(1)

• 插入ListInsert

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
}

时间复杂度:O(n)

*删除ListDelete

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;			
}

时间复杂度:O(n)

• 其他函数：销毁DestroyList(free函数/delete函数)、判定空表ListEmpty(bool类型的应用)、

长度读取ListLength、输出数据DispList、获取指定元素GetElem、按值查找元素LocateElem等

3.链表

• 初始化(结构体定义)

typedef struct LNode{
     ElemType   data;       //数据域
     struct LNode  *next;   //指针域
}LNode,*LinkList; 
Status InitList_L(LinkList &L){ 
   L=new LNode;                    	
   L->next=NULL;　　　　　
   return OK; 
}

时间复杂度:O(1)

• 建立链表

  • 头插法(新增节点从链表头部插入)

图像表示

代码实现

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;
	}
}

• 尾插法(新增节点从链表尾部插入)

图像表示

代码实现

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;
}

• 插入节点ListInsert

图像表示

代码实现

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

• 删除节点ListDelete

图像表示

代码实现

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++;
  }
  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;
}

• 其他函数：销毁链表DestroyList、判断空表ListEmpty、读取长度ListLength、

输出数据DispList、查找节点GetElem等

4.有序表

• 定义:所有元素以递增或递减方式有序排列

• 插入数据ListInsert

有序顺序表的代码实现

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
}

有序单链表的代码实现

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;
}

• 删除数据ListDelete

有序顺序表的代码实现

int ListDelete(SqList &L,int i)
{
	if(i<=0||i>L.length) return 0;
	for(int j=i-1;j<L.length;i++)
	{
		L.elem[j]=L.elem[j+1];
	}
	L.length--;
	return 1;
}

有序单链表的代码实现

void ListDelete(LinkList &L, ElemType e) {
     LinkList p = new(LNode);
    p = L;
    if (p->next == nullptr)
         return;
    while (1) { 
         if (p != nullptr&&p->next != nullptr) {
             if (e == p->next->data) {
                 p->next = p->next->next;
                 return;
                 }
         }
         if (p == nullptr)
             break;
         p = p->next;
     }
    cout << e << "找不到！" << endl;
 }

• 二路归并UnionList

图像表示

代码实现

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;
}

5.双链表

双链表每个节点有2个指针域，一个指向后继节点，一个指向前驱节点。类型定义如下：

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

双链表有点：
• 从任一结点出发可以快速找到其前驱结点和后继结点；
• 从任一结点出发可以访问其他结点。

6.循环链表

循环链表是另一种形式的链式存储结构形式。

循环单链表：将表中尾结点的指针域改为指向表头结点，整个链表形成一个环。
由此从表中任一结点出发均可找到链表中其他结点。 

循环双链表与非循环双链表的比较

与非循环双链表相比，循环双链表：

•	链表中没有空指针域
•	p所指结点为尾结点的条件：p->next==L
•	一步操作即L->prior可以找到尾结点

1.2.谈谈你对线性表的认识及学习体会。

本学期在C++语法的基础上进行对线性表知识的代码编写，得益于C++的精短性，在代码可读性上得到了不错的提升。

在线性表的基础上拓展学习了双链表和循环链表的相关知识，使得我对链表的掌握与操纵更加熟练。

在经过本章的学习后，更加懂得了好算法的重要性，好的算法不仅能够使代码更加精炼，还能减小程序的时间与空间复杂度。

在接下来的学习中，能够对链的应用更加熟练，为后续编写程序打下良好的基础。

2.PTA实验作业（0-2分）

2.1.题目1：6-2 jmu-ds-有序表插入数据 (25分)

2.1.1代码截图

2.1.2本题PTA提交列表说明。

1.部分正确：在移动数组元素时没有考虑到数组越界的问题

2.部分正确：在插入完成后没有对数组的长度进行增加

3.答案正确

2.2 6-3 jmu-ds- 顺序表删除重复元素 (25分)

2.2.1代码截图

2.2.2本题PTA提交列表说明。

1.部分正确：在删除重复元素前移后面元素的循环时循环始条件使用错误

2.部分正确：没有考虑到当最后仅剩两个元素时依旧重复的问题

3.答案正确

2.3 6-8 jmu-ds-链表倒数第m个数 (20分)

2.3.1代码截图

2.3.2本题PTA提交列表说明。

1.运行时错误：开头定义的代运行p指针指向错误

2.部分正确：没有考虑无效位置情况下对应的返回内容

3.答案正确

3.阅读代码（0--4分）

3.1 题目及解题代码

题目：

代码：

ListNode* swapPairs(ListNode* head) {
        ListNode *dummyHead = new ListNode(-1);
        dummyHead->next = head;
        ListNode *ptr = dummyHead;
        while(ptr->next != nullptr && ptr->next->next != nullptr)
        {
            ListNode *firstNode = ptr->next;
            ListNode *secondNode = ptr->next->next;
            //交换节点
            ptr->next = secondNode;
            firstNode->next = secondNode->next;
            secondNode->next = firstNode;
            ptr = firstNode;
        }
        ListNode *retNode = dummyHead->next;
        delete dummyHead;
        return retNode;
    }

3.1.1 该题的设计思路

时间复杂度:O(n)

空间复杂度:O(1)

3.1.2 该题的伪代码

ListNode* swapPairs(ListNode* head) 
{
    声明哑结点dummyHead和指针ptr
    分别并指向头节点head和头节点head的前驱
while(链表不为空)
        {
            firstNode遍历链表中的偶数节点
            //交换节点
            secondNode遍历链表中的奇数节点，并交换节点
        }
end while
    ListNode *retNode = dummyHead->next;
    重置节点并释放空间
    返回节点
}

3.1.3 运行结果

3.1.4分析该题目解题优势及难点。

优势：

本题的递归和非递归解法其实原理类似，都是更新每两个点的链表形态完成整个链表的调整

其中递归解法还可以作为典型的递归解决思路进行讲解

难点：
递归写法要观察本级递归的解决过程，形成抽象模型，因为递归本质就是不断重复相同的事情。

而不是去思考完整的调用栈，一级又一级，无从下手。

3.2 题目及解题代码

题目：

代码：

ListNode* oddEvenList(ListNode* head) {
        if(!head || !head->next || !head->next->next)
            return head;
        //声明虚拟头结点
        ListNode dummyOdd(0);
        //dummyOdd.next = head;
        auto p = &dummyOdd;
        ListNode dummyEven(0);
        //dummyEven.next = head->next;
        auto q = &dummyEven;
        int flag = 0;
        while(head){
            flag++;
            if(flag % 2 != 0){
                p->next = head;
                p = p->next;
            }
            else{
                q->next = head;
                q = q->next;
            }
            head = head->next;
        }
        q->next = NULL;
        p->next = dummyEven.next;
        return dummyOdd.next;
    }

3.2.1 该题的设计思路

时间复杂度： O(n)

空间复杂度： O(1)

3.2.2 该题的伪代码

ListNode* oddEvenList(ListNode* head){
    if(head为NULL或一个节点或两个节点)
        return head;
    声明两个虚拟头结点：dummyOdd(0),dummyEven(0);
    while(循环遍历每个头结点){
        if(节点序号为奇数）
            插入到dummyOdd链表中（尾插法，只改变指针指向，不申请其他节点）
        else(节点序号为偶数)
            插入到dummyEven链表中（尾插法，只改变指针指向，不申请其他节点）

        将dummyEven链表尾节点置空，防止出现循环链表（如1->2->3->4->5->NULL）；
        将dummyOdd尾节点指向dummyEven头结点;

        return dummyOdd头结点的下一个节点；
    }
}

3.2.3 运行结果

3.2.4分析该题目解题优势及难点。

优势：

将奇节点放在一个链表里，偶链表放在另一个链表里，然后把偶链表接在奇链表的尾部

这个解法非常符合直觉思路也很简单

难点：

遍历整个链表至少需要一个指针作为迭代器

这里 odd 指针和 even 指针不仅仅是尾指针，也可以扮演原链表迭代器的角色

即使思路直观，但要写一个精确且没有bug的代码还是需要进行一番思索的