0.PTA得分截图
1.本周学习总结
1.1 总结线性表内容
- 顺序表结构体定义
typedef int ElemType;
typedef struct
{
ElemType data[MaxSize]; //存放顺序表元素
int length ; //存放顺序表的长度
} List;
- 构建顺序表
void CreateList(SqList& L, int n) //构建顺序表函数 ，n为顺序表长度
{
L = new List;
L->length = n;
for (int i = 0; i < n; i++)
{
cin >> L->data[i];
}
}
- 顺序表插入
void InsertSq(SqList& L, int x) //顺序表插入函数，x为要插入的数据
{
int i, j;
if (L->data[0] > x) //要插入的数据比顺序表第一项元素还小
{
for (j = L->length; j > 0; j--)
{
L->data[j] = L->data[j - 1];
}
L->length++;
L->data[0] = x;
}
for (i = 0; i < L->length - 1; i++) //要插入的数据在顺序表第一项元素和最后一项元素之间
{
if (L->data[i] < x && L->data[i + 1] > x)
{
for (j = L->length; j > i+1;j--)
{
L->data[j] = L->data[j - 1];
}
L->length++;
L->data[i + 1] = x;
return;
}
}
if (L->data[L->length - 1] < x) //要插入的数据比顺序表最后一项元素还大
{
L->data[L->length] = x;
L->length++;
return;
}
}
- 顺序表删除
for (i = 0; i < L->length; i++)
{
if (L->data[i] >= min && L->data[i] <= max)
{
for (j = i; j < L->length - 1; j++)
{
L->data[j] = L->data[j + 1];
}
L->length--;
i--; //避免删除一项元素后，此元素的后一项元素会被跳过
}
}
- 链表结构体定义
typedef struct LNode //定义单链表结点类型
{
ElemType data;
struct LNode *next; //指向后继结点
} LNode,*LinkList;
- 头插法建链表
void CreateListF(LinkList& L, int n)
{
LinkList pre;
L = new LNode;
L->next = NULL;
ElemType i;
for ( i = 0; i < n; i++)
{
pre = new LNode;
cin >> pre->data;
pre->next = L->next;
L->next = pre;
}
}
- 尾插法建链表
void CreateListR(LinkList& L, int n)
{
LinkList tail, p;
L = new LNode;
tail = L;
L->next=NULL;
for (int i = 0; i < n; i++)
{
p = new LNode;
cin >> p->data;
p->next = NULL;
tail->next = p;
tail = p;
}
}
- 有序单链表数据插入
void ListInsert(LinkList& L, ElemType e)
{
LinkList ptr, p;
p = L->next;
while (p->next)
{
if (p->data <= e && p->next->data >= e)
{
ptr = new LNode;
ptr->next = NULL;
ptr->data = e;
ptr->next = p->next; //头插法插入数据
p->next = ptr;
return;
}
p = p->next;
}
if (p->data <= e) //数据插入到尾结点后
{
ptr = new LNode;
ptr->next = NULL;
ptr->data = e;
p->next = ptr;
}
- 有序单链表数据删除
void ListDelete(LinkList& L, ElemType e)
{
LinkList ptr, p;
p = L;
int flag = 0;
if (p->next == NULL||p==NULL) //判断空链表
{
return;
}
while (p->next)
{
if (p->next->data == e)
{
ptr = p->next;
p->next = p->next->next;
delete ptr;
flag = 1;
}
p = p->next;
if (p == NULL)
{
break;
}
}
if (flag == 0)
{
cout << e << "找不到！" << endl;
}
}
- 有序链表合并
void MergeList(LinkList& L1, LinkList L2)
{
LinkList ptr = L1,p; //合并的链表头结点为L1的头结点
while (ptr->next && L2->next)
{
if (ptr->next->data > L2->next->data)
{
p = new LNode;
p->data = L2->next->data;
p->next = ptr->next;
ptr->next = p;
L2 = L2->next;
}
else if (ptr->next->data == L2->next->data)
{
L2 = L2->next;
}
ptr=ptr->next;
}
if (ptr->next == NULL )
{
ptr->next = L2->next;
}
}
- 循环链表
- 定义：循环链表中最后一个结点的指针域指向头结点，整个链表形成一个环 。判断循环链表为空链表的条件是：头指针L->next==L。
- 循环单链表图片：
- 双链表
- 定义：双向链表也叫双链表，其每个数据结点都有两个指针，分别指向直接前驱结点和直接后继结点。从双链表中的任意一个结点开始，都可以访问其前驱结点和后继结点。
- 双链表图片：
1.2 对线性表的认识及学习体会：
- 自我感觉线性表中顺序表比链表更简单，因为里面有很多数组的知识，至于链表方面一定要弄清楚节点间的关系，单链表中尤其注意指针next的用法。先把基础打牢，如先学会尾插法，头插法建链表，再循序渐进，如学会有序链表的插入，删除，合并等。我最开始做题时就常常出现指针为空指针，非法访问地址，尾节点数据重复输出等问题。
2.PTA实验作业
2.1 题目1：7-1 两个有序序列的中位数
2.1.1代码截图
2.1.2本题PTA提交列表说明
- 部分正确（6）：新建顺序表L3时直接用赋值表达式，没法把顺序表L1的每项元素赋给L3。解决办法：运用一个循环，分别把顺序表L1的每项元素赋给顺序表L3。
- 部分正确（17）：
-->用C语言知识构造数组时，对数组L3中的元素排序时这种情况有问题。解决办法：每次在选择排序时内层循环之前都把变量i的值赋给变量k。 - 编译错误：
-->定义变量时大小写错误 - 部分正确（21）：
2.2 题目2：6-3 jmu-ds- 顺序表删除重复元素
2.2.1代码截图
2.2.2本题PTA提交列表说明
- 部分正确：
-->题目并未说出顺序表长度为零时该输出什么，直接return 回去就行。
2.3 题目3：6-9 jmu-ds-有序链表合并
2.3.1代码截图
2.3.2本题PTA提交列表说明
- 部分正确：
-->合并的链表头指针为链表L1的头指针，但在循环中缺少指针移动的语句，即此指针无法指向链表L1的下一节点。
3.阅读代码
3.1 21. 合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
- 解题代码：
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
if (l1 == NULL) return l2;
if (l2 == NULL) return l1;
struct ListNode *l3,*head ;
head = (struct ListNode*)malloc(sizeof(struct ListNode));
l3 = head;
while(l1&&l2)
{
if (l1 -> val < l2 -> val)
{
l3 -> next =l1;
l1 = l1 -> next;
l3 = l3 -> next;
}
else
{
l3 -> next = l2;
l2 = l2 -> next;
l3 = l3 -> next;
}
}
l3 -> next = l1 ? l1 : l2;
return head -> next;
}
3.1.1 该题的设计思路
如果链表l1为空链表，合并的链表就为l2,返回链表l2。反之亦然。 
两链表l1,l2的长度都为n,算法的时间复杂度T(n)=O(n),算法的空间复杂度S(n)=O(1)
3.1.2 该题的伪代码
定义新链表l3的头指针head
while(l1&&l2)
{
if(链表l1节点的数据更小）
{
l1节点作为l3的后继节点
l1,l3同时移动到下一节点
}
else
{
l2节点作为l3的后继节点
l2,l3同时移动到下一节点
}
}
end while
把l1,l2两条链表中未走完的那条接到链表l3的后面
返回头指针head
3.1.3 运行结果
这段代码中最后应为return head,即返回头指针，不然最后输出时会少掉头节点中的元素。修改代码后运行如下： 
3.1.4 该解法解题优势及难点
- 该解法构建了一条新的链表，在不断移动两条链表l1和l2的过程中对比节点数据的大小，并把具有较小数据的节点作为新链l3的后继节点，若一条链先结束，则将另一条链的其余节点接到新链的后面，最后返回新链l3的头指针。但要注意返回的应是头指针，而不是头节点。且在链表l1,l2移动之前应先把新链l3的头指针赋给一个指针变量，接下来让此变量代替头指针head移动。
3.2 83. 删除排序链表中的重复元素
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2 输出: 1->2 示例 2:
输入: 1->1->2->3->3 输出: 1->2->3
- 解题代码
ListNode* deleteDuplicates(ListNode* head)
{
if(!head)
return head;
ListNode*first = head,*second = first->next;
while(first&&second)
{
if(first->val!=second->val)
{
first->next=second;
first=second;
}
second=second->next;
}
first->next=second;
return head;
}
3.2.1 该题的设计思路
链表长度为n,算法的时间复杂度T(n)=O(n),空间复杂度S(n)=O(1)
3.2.2 该题的伪代码
判断链表是否为空
while(头节点first和下一节点second）
{
若两节点数据不同，移动头节点first
移动节点second
}
end while
链表尾部置空，返回头节点
3.2.3 运行结果
3.2.4 该解法解题优势及难点
- 该解法把头节点head赋给了指针变量first,并用指针变量second表示链表的下一节点，之后便不断移动指针second,并分别把相应节点的数据与指针first对应节点的数据进行对比，若不等，则把指针second对应的节点作为指针first对应节点的后继节点。最后把链表尾部置空并返回头节点，此解法在循环过程中通过指针second的移动来处理两节点数据相等的情况。