寒假学习日志

最新推荐文章于 2021-01-24 21:22:51 发布

glancelike

最新推荐文章于 2021-01-24 21:22:51 发布

阅读量262

点赞数 1

分类专栏：笔记

本文链接：https://blog.csdn.net/glancelike/article/details/104010407

版权

博主在寒假期间深入学习了链表操作，包括初始化、查找、插入、删除等，并在PTA上实践了链表合并题目。之后，博主巩固了链表知识，开始接触堆栈，介绍了顺序堆栈、双向堆栈及其应用。随后，博主学习了队列，探讨了队列满与空的判断，并通过洛谷OJ练习了队列应用。之后，博主通过多项式运算进一步理解链表应用，并研究了判定树和二叉树的概念及操作。最后，博主回顾了递归知识，如汉诺塔问题，以及排序算法，如快速排序和归并排序的应用。

摘要由CSDN通过智能技术生成

1月16号
简单的算法分析，学习链表的常规操作，
链表的一些常规操作
List MakeEmpty( ); 初始化一个空的链表
List FindKth(int k, List L); 找到链表中的第k个元素

List FindKth(List Ptrl,int X){
   
	int j=1;
	List P=Ptrl;
	while(j!=X&&P){
   
		j++;
		P=P->next;
	}
	if(j==X){
   
		return P;
	}
	else return 0;
}

List Find(ElementType X, List L); 查找X在L中出现的序数

List Find(List Ptrl,ElementType X){
   
	List P=Ptrl;
	while(P&&P->Date!=X){
   
		P=P->next;
	}
	return P;
}

List insert(ElementType X, int i, List L), 在位序i前插入元素X

List insert(List Ptrl,int i,int X){
   
	List p,s;
	if(i==1){
   
		s=(List)malloc(sizeof(struct LNode));
		s->Date=X;
		s->next=Ptrl; 
		return s;
	}
	p=FindKth(Ptrl,i-1);
	if(!p){
   
		cout<<"参数错误";
		return 0; 
	}
	else{
   
		s=(List)malloc(sizeof(struct LNode));
		s->Date=X;
		s->next=Ptrl->next;
		Ptrl->next=s;
		return Ptrl;
	}
}

List Delete(int i, List L); 删除i第i个元素

List Delete(List Ptrl,int i){
   
	List s,p;
	if(i==1){
   
		if(Ptrl){
   
			cout<<"链表是空的"; 
			return 0;
		}
		else{
   
			s=Ptrl;
			Ptrl=Ptrl->next;
			free(s);
		}
	}
	p=FindKth(Ptrl,1-1);
	if(!p||!p->next){
   
		cout<<"参数错误";
		return 0;
	}
	else{
   
		s=p->next;
		p->next=s->next;
		free(s);
		return Ptrl;
	}
}

int Length(List L); 返回线性表的长度

int Length(List L){
   
	int j=0;
	List P=L;
	while(P){
   
		j++;
		P=P->next;
	}
}

再附上pta上的一道题链表合并

List Merge( List L1, List L2 ){
   
    List head=(List)malloc(sizeof(PtrToNode));
    head->Next=NULL;
    List p=L1;
    List q=L2;
    List Last=head;
    p=p->Next;
    q=q->Next;
    while(p&&q){
   
        if(p->Data<q->Data){
   
            Last->Next=p;
            p=p->Next;
            Last=Last->Next;
        }
        else{
   
            Last->Next=q;
            q=q->Next;
            Last=Last->Next;
        }
    }
    if (p)
        Last->Next=p;
    else
        Last->Next=q;
    L1->Next=NULL;
    L2->Next=NULL;
    return head;
}

这道题除了头节点不用再去申请额外的空间，直接利用L1, L2的空间，最后注意让L1，L2都指向NULL

题目2，链表翻转

List reverse(List L){
   
	List Old_head,New_head=NULL;
	List Temp;
	Old_head=L;
	while(Old_head){
   
		Temp=Old_head->Next;
		Old_head->Next=New_head;
		New_head=Old_head;
		Old_head=Temp;
	}
	L=New_head;
	return L;
}

思路：先用temp记录Old_head原来的指向，将Old_head，一步一步向后移动，在过程中改变Old_head的指向
1月17号
今日份刷题
洛谷OJ铺地毯

#include<iostream>
using namespace std;
int main()
{
   
	int TotalNum,t=1,l=1,temp;
	int flags=0;
	
	cin>>TotalNum;
	temp=TotalNum; 
	int arr[4*TotalNum+1]={
   0};
	int point[2]={
   0};
	
	while(temp--){
   
		for(;t<=l*4;t++){
   
			cin>>arr[t];
		}
		l++;
	}
	t=1;
	
	cin>>point[0]>>point[1];
	
	t=4*TotalNum-3;
	while(TotalNum--){
   
		if(point[0]>=arr[t]&&point[0]<=arr[t]+arr[t+2]&&point[1]>=arr[t+1]&&point[1]<=arr[t+1]+arr[t+3]){
   
			flags=1;
			break;
		}
		t-=4;
	}
	
	if(flags){
   
		cout<<(t+3)/4;
	}
	else cout<<-1;
}

补充昨天没有提到的**List read( )**函数

//这是带头节点，不带头节点的太懒了（~~我不会~~ ）逃
List Read(){
   
	List head=NULL;
	List Last=head;
	int data;
	
	while(1){
   
		cin>>data;
		if(data==-1){
   
			break;
		}
		else{
   
			List p;
			p=(List)malloc(sizeof(LNode));
			p->Data=data;
			p->Next=NULL;
			Last->Next=p;
			Last=p;
		}
	}
	
	return head;
}

今天本来想学堆栈的但是链表还不够熟悉，再做一天链表的题（一天等于一个晚上，逃）

查找链表里的第K个元素不带头节点的

ElementType FindKth(List L,int K){
   
    if(K<=0){
   
        return ERROR;
    }
    List TempList=L;
    int k=1;
    while(k<K&&TempList){
   
        TempList=TempList->Next;
        k++;
    }
    if(TempList!=NULL){
   
        return TempList->Data;
    }
    else return ERROR;
}

pta上的不带头结点的链表操作集


Position Find( List L, ElementType X ){
   
    while(L){
   
        if(L->Data==X){
   
            return L;
        }
        L=L->Next;
    }
   return ERROR;
}
//要求insert在P之前所以要找到P之前的结点
List Insert( List L, ElementType X, Position P ){
   
    List TempList=(List)malloc(sizeof(struct LNode));
    List k=L;
    if(P==L){
   
        TempList->Data=X;
        TempList->Next=L;
        return TempList;
    }
    while(k){
   
        if(k->Next==P){
   
            TempList->Data=X;
             TempList->Next=k->Next;
             k->Next=TempList;
             return L;
        }
        k=k->Next;
    }
     printf("Wrong Position for Insertion\n");
     return ERROR;
}
//删除P结点，找到P前面的结点，才能连接好链表
List Delete( List L, Position P ){
   
    if(P==L){
   
        L=L->Next;
        free(P);
        return L;
    }
    List j=L;
    while(L){
   
        if(L->Next==P){
   
            L->Next=P->Next;
            free(P);
            return j;
        }
        L=L->Next;
    }
    printf("Wrong Position for Deletion\n");
    return ERROR;
}

今天就先这样吧，明天在再加油
1月18号
突然发现昨天写的Read函数有问题，写带头节点的函数要先让头节点指向NULL，不然如果是空链表会出现问题，逃这里再贴一下改正后的号码

List Read(){
   
	List head;
	head=(List)malloc(sizeof(struct LNode));
	head->Next=NULL; 
	List Last=head;
	int data;
	
	while(1){
   
		cin>>data;
		if(data==-1){
   
			break;
		}
		else{
   
			List p;
			p=(List)malloc(sizeof(LNode));
			p->Data=data;
			p->Next=NULL;
			Last->Next=p;
			Last=p;
		}
	}
	
	return head;
}

今天貌似没有谁到什么，就是把链表的知识巩固了一下，附上今天做的链表题链表的中位数
还有洛谷oj一道题多项式的输出

#include<iostream>
using namespace std;
int main()
{
   
	int n,flags=0;
	cin>>n;
	int arr[n+1]={
   0};
	for(int t=n;t>=0;t--){
   
		cin>>arr[t];
	}
	for(int t=n;t>=2;t--){
   
		if(arr[t]){
   
			if(arr[t]>0&&flags){
   
				cout<<'+';
				if(arr[t]!=1)
				cout<<arr[t]<<"x^"<<t;
				else cout<<"x^"<<t;
			}
			else if(arr[t]<0){
   
				if(arr[t]==-1){
   
					cout<<'-'<<"x^"<<t;
				}
				else cout<<arr[t]<<"x^"<<t;
				flags=1;
			}
			if(arr[t]>0&&!flags){
   
				if(arr[t