数据结构期末数据结构部分

1.栈栈顶在数组尾栈底在数组头

2.队列循环队列 count=maxqueue;

front=0;

rear=maxqueue-1;

利用循环队列可以很好的利用先前出队元素所剩下的空间

3.堆 extract-max O(logn)

T(n)=2(T(n/2))+O(n)

O(1)=1

insert O(h)=O(logn)

C~CN/2^(l-1)

l-1=logn

4.链表

1)node 包含结点值和指针

2)插入

中间newPtr->next=prev->next;

prev->next=newPtr;

表头newPtr->next=head;

head=newPtr;

3)删除

中间prev->next=cur->next;

delete cur;

cur=NULL;

表头head=head->next

4）查找

for(prev=NULL,cur=head;cur!=NULL;cur=cur->next)

{if(cur->value==x)

return true;}

return false;

void print(ListNode * head){
if(head!=NULL){
if(head->value==x)
cout<<head->value<<endl;
else print(head->next);
}

5.搜索

通过key找对应的Record为了知道other information

有序列表插入数据

for(position=0;position<s;position++)
{
    retrieve(position,list_data);
    if (data<list_data)
        break;
}
由此可以找到恰好比前一项大比后一项小的位置插入

找到插入位置，并将列表中所有后续数据各自后移一位。

for(int i=count-1;i>=position;i--)
{
    entry[i+1]=entry[i];
}
entry[position]=x;
count++;
item>data[middle] first=middle+1
item<data[middle] last=middle-1

递归代码
Error_code recursive_binary_2(const Ordered_list &the_list, const Key &target, int bottom, int top, int &position)
{
    Record data;
    if (bottom <= top) {
        int mid = (bottom + top)/2;
        the_list.retrieve(mid, data);
        if(data==target)
        {       position=mid;
             return success;}
      else if(data>target)
              recursive_binary_2(the_list,target,mid+1,top,position);
      else
             recursive_binary_2(the_list,target,bottom,mid-1,position);
       }
     else
         return not_present;
}
循环代码

Record data;

int bottom = 0, top = the_list.size( ) - 1;

while (bottom <= top)

{ position = (bottom + top)/2;

the_list.retrieve(position, data);

if (data == target) return success; if (data < target) bottom = position + 1;

else top = position - 1;

} return not_present;

时间复杂度O(log2n)

n/(2^k)=1

k=log2n

6排序

插入排序每一遍，排序的序列将增加一个元素。如果序列中有 n 个元素，那么最多进行n 遍即可。

折半插入排序折半插入排序只减少了比较次数移动次数不变 O(n^2)

冒泡排序每次把最大的沉到最底 O(n^2)

归并排序 O(nlogn)T[n] = 2T[n/2] + O(n)

空间复杂度 O（n)

快排左右往中间移直到ij在同一位置平均时间复杂度O(nlogn) 最坏O（n^2) 空间复杂度O(log2n)

基数排序低位基数排序

高位基数排序最高位排序再对每个桶次高位基数排序依次类推

时间复杂度高速度不一定慢因为去掉了高阶项系数也可能n不大

7哈希

开放地址法查找到为空为止

插入和不成功查找均为找到第一个不为空的是等价的

8链表leetcode&递归

https://zhuanlan.zhihu.com/p/43142694

题目选择按该专栏

题解基本均为博主自己写的C++代码

移除链表元素

 ListNode* removeElements(ListNode* head, int val) {
       if(head==NULL)return NULL; 
       ListNode * dummy=new ListNode(-1);
       dummy->next=head;
       ListNode * cur=dummy;
       while(cur->next!=NULL)
       {
          if(cur->next->val==val)
       {ListNode * p=cur->next;
       cur->next=cur->next->next;
       delete p;
       }
        else cur=cur->next;
       }
       return dummy->next;
    }

倒序输出链表的值

void find(ListNode * head)
{
{if(head->next==NULL) 
cout<<head->value<<endl;
else{find(head->next);
cout<<head->value<<endl;
}
}

https://www.cnblogs.com/kubidemanong/p/10538799.html　　

反转单链表

reverseLinkedList(ListNode * head)

{if(head==NULL||head->next==NULL) return head;

ListNode * newNode =reverseLinkedList(head->next);

ListNode * t=head->next;

t->next=head;

head->next=NULL;

return newList;}

合并有序链表

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
       if(l1==NULL)return l2;
        if(l2==NULL)return l1;
        if(l1->val>l2->val) 
        {l2->next=mergeTwoLists(l1,l2->next);
        return l2;}
       else
        {l1->next=mergeTwoLists(l1->next,l2);
        return l1;}
        }

删除链表中的重复元素

 ListNode* deleteDuplicates(ListNode* head) {
        ListNode * cur=head;
        while(cur!=NULL&&cur->next!=NULL){
          if(cur->val==cur->next->val)
        {
            ListNode * deletenode=cur->next;
        cur->next=cur->next->next;
        delete deletenode;
        }  
        else cur=cur->next;
        }
        return head;
    }

旋转单链表

 ListNode* rotateRight(ListNode* head, int k) {
       ListNode *q=new ListNode(-1);
        
        if(head==NULL||head->next==NULL)return head;
        ListNode * x=head;
        int len=1;
        while(x->next!=NULL)
        {
            len++;
            x=x->next;
           }
        int a=k%len;
        if(a==0)
        return head;
            ListNode * temp=head;
            while(temp->next->next!=NULL)
            {
                temp=temp->next;
            }
            ListNode * p=temp;
            q=temp->next;
            p->next=NULL;
            q->next=head;
            if(a>1)
            q= rotateRight(q,a-1);
        return q;
    }

删除倒数第n个节点

ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head==NULL)return NULL;
        if(head->next==NULL&&n==1)return NULL;
        if(head->next==NULL&&n==0)return head;
         ListNode * dummy=new ListNode (0);
        dummy->next=head;
        int count=1;
        ListNode * x=head;
        while(x!=NULL)
        {
            x=x->next;
            count++;
        }
        int todelete=count-n;
        ListNode * cur=dummy;
        for(int i=1;i<todelete;i++)
        {
            cur=cur->next;
        }
        cur->next=cur->next->next;
        return dummy->next;
    }

删除链表中节点参考官方题解的神奇解法orz

 void deleteNode(ListNode* node) {
        node->val=node->next->val;
        node->next=node->next->next;
    }

求链表中间节点

 ListNode* middleNode(ListNode* head) {
        if(head==NULL||head->next==NULL)return head;
        ListNode * fast=head;
        ListNode * slow=head;
        while(fast!=NULL&&fast->next!=NULL)
        {
          fast=fast->next->next;
          slow=slow->next;
        }
        return slow;
    }

判断链表是否有环

 bool hasCycle(ListNode *head) {
        if(head==NULL||head->next==NULL)return false;
        ListNode * fast=head;
        ListNode * slow=head;
        while(fast!=NULL&&fast->next!=NULL)
        {
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow)return true;
        }
        return false;
    }

相交链表https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/tu-jie-xiang-jiao-lian-biao-by-user7208t/

 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA==NULL||headB==NULL)return NULL;
        if(headA==headB)return headA;
        ListNode * p=headA;
        ListNode * q=headB;
        while(p!=q)
        {
            if(p==NULL)p=headB;
            else p=p->next;
            if(q==NULL)q=headA;
            else q=q->next;
        }
        return p;
    }

两两交换链表中的结点

ListNode* swapPairs(ListNode* head) {
if(head==NULL||head->next==NULL)
{
return head;
}

ListNode * first=head;
ListNode * second=head->next;

ListNode * p=second->next;

second->next=first;

first->next=swapPairs(p);

return second;}

posted @ 2019-12-28 10:15 柠檬味呀阅读(214) 评论(0) 编辑收藏举报

刷新页面返回顶部

柠檬味呀

数据结构期末 数据结构部分

公告

数据结构期末数据结构部分