《剑指offer》：线性表经典题目分析

最新推荐文章于 2022-10-09 23:54:32 发布
最新推荐文章于 2022-10-09 23:54:32 发布
阅读量311 收藏 3
点赞数 1
分类专栏： 剑指offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kobe51920/article/details/103899030
版权

1、逆置单链表

typedef struct LinkNode
{
  int val;
  LinkNode*next;
};

//单链表逆置
void Reverse(ListNode* pHead)
{
  if(pHead == NULL || pHead->next == NULL)
  {
   return;
  }

  LinkNode*Recv = NULL;
  //p指针指向头结点
  LinkNOde*pCur= head;
  while( p != NULL)
  {
   ListNode* pTemp = pCur;
   pCur = pCur->next;
   pTemp->next = Recv;
   Recv = pTemp;
  }
  return Recv;
}

初始状态：

第一次循环：

第一次循环过后，步骤①：pTemp指向Head，步骤②：pCur指向P1，步骤③：pTemp->pNext指向NULL

此时得到的pRev为：

第二次循环：

第二次循环过后，步骤①：pTemp指向P1，步骤②：pCur指向P2，步骤③：pTemp->pNext指向Head

此时得到的pRev为：

第三次循环：

第三次循环过后：步骤①：pTemp指向P2，步骤②：pCur指向P3，步骤③：pTemp->pNext指向P1。

此时得到的pRev为：

第四次循环：

第四次循环过后：步骤①：pTemp指向P3，步骤②：pCur指向NULL，步骤③：pTemp->pNext指向P2

此时得到的pRev为：

全部完成

2、反转单链表

/*
#inlucde <iostream>
using namespace std;

class LinkNode
{
  public:class LinkNode
  {
    int val;
    Linknode *next;
    LinkNode (int val)
    {
     this.val = val;
    }
  }
};
*/

//反转链表
public class Solution 
{
    public ListNode ReverseList(ListNode head)
    {
      if(head == NULL)
      return ;
     
      LinkNode pre =NULL;
      LinkNode next = NULL;

      while(head !=NULL)
      {
         next = head.next;
         head.next = pre;
         pre = head;
         head = next;
      }
    return pre;
    }
};

/*
 //反转链表
	public ListNode ReverseList1(ListNode head) {
		if (head == null) 
			return null; // head为当前节点，如果当前节点为空的话，那就什么也不做，直接返回null； 
		ListNode pre = null;
		ListNode next = null;
		// 当前节点是head，pre为当前节点的前一节点，next为当前节点的下一节点  
        // 需要pre和next的目的是让当前节点从pre->head->next1->next2变成pre<-head next1->next2  
        // 即pre让节点可以反转所指方向，但反转之后如果不用next节点保存next1节点的话，此单链表就此断开了  
        // 所以需要用到pre和next两个节点  
        // 1->2->3->4->5  
        // 1<-2<-3->4->5  
		while(head != null){ //注意这个地方的写法，如果写head.next将会丢失最后一个节点
			// 做循环，如果当前节点不为空的话，始终执行此循环，此循环的目的就是让当前节点从指向next到指向pre   
            // 如此就可以做到反转链表的效果  
            // 先用next保存head的下一个节点的信息，保证单链表不会因为失去head节点的原next节点而就此断裂
			next = head.next; //先让head.next指向的节点，即第二个节点叫next
			head.next = pre; //将head.next指向pre，也就是说断开head节点与后面的连接
			pre = head;//pre,head依次向后移动一个节点，进行下一次反转
			head = next;
		}
		// 如果head为null的时候，pre就为最后一个节点了，但是链表已经反转完毕，pre就是反转后链表的第一个节点 
		return pre;
	}
	//合并两个递增的链表并且保证最终的链表也是单调不减的。

3、合并两个有序的单链表

//递归的方式
    /*
    public ListNode Merge(ListNode list1,ListNode list2) 
     {  
            if (list1 == null) 
            {  
                return list2;  
            }  
            if (list2 == null) 
            {  
                return list1;  
            }  
            ListNode newHead = null;
       
            if (list1.val <= list2.val) 
            {  
                newHead = list1;  
                newHead.next = Merge(list1.next,list2);  
            }
            else 
            {  
                newHead = list2;  
                newHead.next = Merge(list1,list2.next);  
            }  
  
            return newHead;  
     }  
    */

 

4、判断单链表是否有环？环的入口点？环的长度？

问题1： 
首先要判断一个链表是否带环，我们可以分别考虑一下带环和不带环两种情况的区别。如果链表不带环，我们用一个指针从头遍历到尾 
指针最终会指向一个NULL 。如果链表带环指针一旦进入环就会一直循环遍历，这样就会陷入死循环永远走不到 NULL位置。 
这时我们可以考虑用两个指针去遍历整个链表，分别为fast和slow，fast一次走两步，slow一次走一步，如果链表不带换那么fast或者 
fast->next就会走到 NULL，如果链表带环，fast和slow就会在环的某一个节点相遇，这样我们就能很快判断出链表是否带环了。

代码如下（判断链表是否带环）：

ListNode* IsExitsLoop(ListNode* pHead)
{
 if(pHead == NULL || pHead->next == NULL || pHead->next->next == NULL)
 {
   return ;
 }
  
 ListNode* slow = pHead->next;//走一步
 LinkNode* fast = pHead->next->next;//走两步

 while(slow != fast)
 {
   if(fast == NULL || fast->next == NULL)
   {
     cout<<"没有环"<<endl;
     return NULL;
   }

   slow = slow->next;
   fast = fast->next;
 }
 cout<<"有环"<<endl;
 return slow;
}

问题2： 
如果该链表已经证明带环，那么环的入口地址在哪里？我们用下图来详细说明一下。上一步我们通过slow和fast相遇得出链表带环，如图所示 
假设相遇在M点，设环的入口位置为点P，链表头结点为B，从B到P我们假设长度为L，从P到M长度记为S，整个环长度为C。我们分析一下fast和slow从出发到相遇一共走了多长？ 
对于fast：因为相遇之前可能在环内循环了n圈所以总路程为 L+nC+S 
对于slow：总路程为 L+S 
由于slow每次走一步，fast每次走两步。因此就有了 L+nC+S = 2（L+S） 解方程得到：L = nC - S 。这个等式什么意义？M点现在是fast和slow相遇的位置 
我们可以记录这个位置，让一个cur从链表头B出发每次走一步，slow指针继续从相遇的点出发每次一步，当cur走了L长后到了环入口P，此时slow指针到哪里呢？ 
我们分析一下，slow之前已经从P点走了S长，从解方程的结果可以得出S = nC-L ， 此时给slow再走L长即 S+L 就神奇的到了环的入口。 
所以当cur和slow相遇的地方就是环的入口。


 

ListNode* IsExitsLoop(ListNode* pHead)
{
 if(pHead == NULL || pHead->next == NULL || pHead->next->next == NULL)
            
    return NULL;
        
  ListNode* slow = pHead->next,*fast = pHead->next->next;
        
    while(slow!=fast)
     {
         if(fast == NULL || fast->next == NULL)
            return NULL;
         slow = slow->next;
         fast = fast->next->next;
     }

   slow = pHead;
   if(slow != fast)
   {
     slow = slow->next;
     fast = fast->next;
   }
   return slow;
}

问题3:环的长度

已经知道了环的入口位置，我们让一个指针从环入口出发，当再次走到该位置时走过的长度就是环的长度了

int LoopPortLength(ListNode* pPort)
{
   ListNode *pCur = pPort;
   int length = 1;
   
   if(pCur != pPort)
   {
    pCur = pCur->next;
    length++;
   } 
   
   return length;
}

 

5、判断两个单链表是否相交？交点？

**思路：
**求第一个交点：两个指针p1 p2   先求出两个单链表的长度之差 pos ，使p1指向较长的单链表头节点，然后p1向前走pos，p2指向较短的单链表，从头开始遍历，当p1 = p2，则相交且为两个相交的单链表的第一个交点

void LinkListpoint(linklist *p1, linklist *p2)
{
  int count = 0 ;//相差的
  int count1 = 0;//p1
  int count2 = 0;//p2
  
  Linklist*Cur1 = p1;
  Linklist*Cur2 = p2;

  //p1的长度
    while (cur1 != NULL)
    {
        count1++;
        cur1 = cur1->next;
    }
  
  //p2的长度
    while (cur2 != NULL)
    {
        count2++;
        cur2 = cur2->next;
    }
 
  cur1 = p1;
  cur2 = p2;
  //p1与p2的差
  count = count1 - count2;

  if(count >= 0)
  {
    while(count--)
    {
      cur1 = cur1->next;
    }
    while(cur1 != cur2)
    {
      cur1 = cur1->next;
      cur2 = cur2->next;
    }
    
    printf("%d\n",cur1->data);
  }
  else
  {
   
     while (count--)
        {
            cur2 = cur2->next;
        }
     while (cur1 != cur2)
        {
            cur1 = cur1->next;
            cur2 = cur2->next;
        }
    printf("%d\n", cur2->data);
  }
  
}

 

6、O(1)时间删除单链表的一个节点

 

**思路：
要删除节点 i，先把 i 的下一个节点 j 的内容复制到 i，然后把 i 的指针指向节点 j 的下一个节点，此时再删除j节点，其效果刚好是把节点i删除了，如果要删除的节点位于链表的尾部，要从链表的头节点开始，顺序遍历得到该节点的前序节点，并完成删除操作如果链表中只有一个节点，并要删除链表的头节点（也是尾节点），删除后，要将链表的头节点设置为NULL

public:
ListNode deleteNode(ListNode head, ListNode deleteNode)
{
 if(head == NULL || deleteNode == NULL)
 {
    return NULL;
 }
 
 if(deleteNode -> next != NULL)
 {
   listNode * next = deleteNode->next;
   deleteNode -> val = next->val;
   deleteNode -> next = next ->next;
 }
 else
 {
   //当这个结点是尾结点
   if(deleteNode->next == NULL)
   {
     return NULL;
   }

   //删除的节点是多节点的尾节点
   else
   {
     ListNode *cur = head;
     
     while(cur->next !=deleteNode)
     {
       cur = cur->next;
     }
     cur.next = null;
   }
 }
 return head; 
}

 

7、最快时间内找到单链表倒数第K个节点？

思路：
设置两个指针p1和p2，p1向前走k-1步后，p1和p2同时向前遍历，当p1走向尾节点时，p所在位置即倒数第k个节点

Node *LastK(List plist,int k)
{
  if(plist == NULL ||k == NULL)
  {
   return NULL;
  }
  
  LinkNode *p1=plist;
  LinkNode *p2=plist;
  
  while(k-1>0)
  {
    if(p1->next != NULL)
    {
     p1 = p1->next;
     --k;
    }
    else
    {
      return NULL;
    }
  } 
  
  while(p1->next != NULL)
  {
	p1 = p1->next;
	p2 = p2->next;
  }
  return p2;

}

 

8、最快时间内删除单链表倒数第K个节点？

void DeleteLastK(List plist,int k)
{
	if(k < 0 || plist == NULL)
	{
		return ;
	}
	Node *p1 = plist;
	Node *p2 = plist;
	while(k > 0)
	{
		if(p1->next != NULL) 
		{
			p1 = p1->next;
			--k;
		}
		else
		{
			return;
		}
	}
	while(p1->next != NULL)
	{
		p1 = p1->next;
		p2 = p2->next;
	}
    Node *pDel = p2->next;
    p2->next = pDel->next;
	free(pDel);
	pDel = NULL;
}

 

9、 求两个顺序表的交集、并集和差集

1.交集：

新开辟一个顺序表存放交集，如果遍历两个顺序表，查找相同元素写入交集中，并记录长度

void Intersection(PSqlist sq1,PSqlist sq2,PSqlist sq3)
{
   int k = 0;
   for(int i = 0;i < sq1->length ;i++ )
   {
     while(j < sq2->length && sq2->elem[j] != sq1->elem[i])
     {
       j++;
     }    
   }
   if(j<sq2->length)
   {
     sq3->elem[k++] = sq2->elem[j];
   }

   sq3->length = k;
}

2.并集：

 思路(并集)：
新开辟一个顺序表存放并集，由于是并集，所以结果中至少包含了一个顺序表中的所有元素，因此首先将第一个顺序表写入并集。然后遍历第二个顺序表，每拿到一个元素都遍历一遍第一个顺序表，进行比对，第一个顺序表遍历完毕， 第二个顺序表中的该元素在第一个顺序表中依然没有找到与之相等的元素，就将第二个顺序表中的该元素就写入并集
 

void Uoion(psalmist sq1,psalmist sq2,psalmist sq4)
{
   //第一条链表的全部数据都要入新的链表中
   for(int i = 0;i < sq1->length ;i++)
   {
     sq4->elem[i] = sq1->elem[i];
   }
   sq4->length = sq1->length;
   int k = sql->length;

   //遍历第一条链表与第二条链表中数据做对比
   for(int i = 0;i < sq2->length ;i++)
   {
     int j = 0;
     while(j < sq1->length && sq1->elem[j] != sq2->elem[i] )
     {
       j++;
     }
     if(j == sq1->length)
     { 
       sq4->elem[k++] = sq2->elem[i];
     }
     
   }
  sq4->length = k;
}

3.差集：

新开辟一个顺序表存放差集，属于A而不属于B的元素的集合称为A与B的差，则遍历第一个顺序表，每拿到一个元素都遍历一遍第二个顺序表，进行比对，第二个顺序表遍历完毕，第一个顺序表中的该元素在第二个顺序表中依然没有找到与之相等的元素，就将第一个顺序表中的该元素写入差集。

void Difference_Set (PSqlist sq1,PSqlist sq2,PSqlist sq5)
{
    int k = 0;
    for (int i = 0; i < sq1->length; i++)
    {
        int j = 0;
        while(j < sq2->length && sq1->elem[i] != sq2->elem[j])
        {
            j++;
        }
        if (j == sq2->length)
        {
            sq5->elem[k++] = sq1->elem[i];
        }
    }
    sq5->length = k;
}

 

10、求两个有序单链表的交集、并集和差集

 

两个有序的无头结点的链表La，Lb，求二者的交集、并集、差集，并且把结果分别存在一个新链表中返回。

 

 1.交集：
 依次遍历两个链表，比较两个链表当前元素的大小关系
 如果两个链表当前元素相等，则找到一个相交元素
如果第一个链表元素小于第二个链表元素，则第一个链表的指针后移一位
如果第一个链表元素大于第二个链表元素，则第二个链表的指针后移一位

BNode *Intersection(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    BTlist p3 = Lc;
    
    while(p1 != NULL && p2!= NULL)
    {
      if(p1->data < p2->data)
      {
        p1 = p1->next;
      }
      else if
      {
        p2= p2->next;
      }
      else//插入新链表中
      {
        //申请空间
        BNode *pGet = (BNode *)malloc(sizeof(BNode));
        pGet->next = NULL;
        pGet->data = p2->data;
        
        if (p3 == NULL)

            {
                Lc = pGet;  // 第一个交集元素节点存入Lc
                p3 = Lc;
            }
            else
            {
                while (p3->next != NULL)
                {
                    p3 = p3->next;
                }
                p3->next = pGet;
            }
 
            //Insert_tail(&Lc,p2->data);
            p1 = p1->next;
            p2 = p2->next;

        
      }
    }
   return Lc;
}

2.并集：

依次遍历两个链表，比较两个链表当前元素的大小关系
**    如果第一个链表元素小于第二个链表元素，则第一个链表当前元素存入新链表，并后移第一个链表指针
**    如果第一个链表元素大于第二个链表元素，则第二个链表当前元素存入新链表，并后移第二个链表指针
**  如果第一个链表元素等于第二个链表元素，则第一个链表当前元素存入新链表，并后移第一个和第二个链表指针
**    如果两个链表中某个还有剩余，则将剩余元素插入新链表

BNode *Union(BTlist plist1,BTlist plist2)
{
  BTlist Lc
  Lc = NULL;
  BTlist p1= plist1;
  BTlist p2= plist2;
  PTlist p3= Lc
  
  while( p1 != NULL && p2 != NULL)
  {
    if(p1->data < p2->data)
    {
      Insert_tail(&Lc,p1->data);
      p1 = p1->next;
    }
    else if
    {
      Insert_tail(&Lc,p2->data);
      p2 =p2->next;
    }
    else
    {
      Insert_tail(&Lc,p1->data);
      p1 = p1->next;
      p2 = p2->next;
    }
  }
   while (p1 != NULL)
    {
        Insert_tail(&Lc,p1->data);
        p1 = p1->next;
    }
   
    while (p2 != NULL)
    {
        Insert_tail(&Lc,p2->data);
        p2 = p2->next;
    }
    return Lc;
}

3.差集：

依次遍历两个链表，比较两个链表当前元素的大小关系
**    如果两个链表当前元素相等，则两个链表的指针均后移一位
**    如果第一个链表元素小于第二个链表元素，则第一个链表的元素肯定是独有的，所有加入到结果链表中 
**    如果第一个链表元素大于第二个链表元素，则第二个链表的指针后移一位
 

BNode *Difference_Set(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    while(p1 != NULL && p2 != NULL)
    {
        if (p1->data < p2->data)
        {
            Insert_tail(&Lc,p1->data);
            p1 = p1->next;
        }
        else if(p1->data > p2->data)
        {
            p2 = p2->next;
        }
        else
        {
            p1 = p1->next;
            p2 = p2->next;
        }
    }
    while (p1 != NULL)
    {
        Insert_tail(&Lc,p1->data);
        p1 = p1->next;
    }
    return Lc;
}

 

 

11、求两个单链表(可以无序)的交集、并集和差集

先创建一个单链表：

bool IsPresent(BTlist plist,int elem)
{
  BTlist p = plist;
  
  while(p != NULL)
  {
    if(p->data == elem)
    {
     return true;
    }
  }
  p= p->next;
}

交集：


依次遍历第一个链表，在第二个链表中查找该元素
如果第二个链表中也有该元素，则将该元素插入到结果链表中。

BNode *Intersection_1(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    
    while(p1 != NULL)
    {
        if (IsPresent(p2,p1->data))
        {
            Insert_tail(&Lc,p1->data);
        }
        p1 = p1->next;
    }
    return Lc;
}
 

并集：

现将第一个链表全部插入结果链表中
**    然后遍历第二个链表，若第二个链表中的某元素在结果链表中不存在
**  则将该元素插入到结果链表中。

BNode *Union_1(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
    
    while(p1 != NULL)
    {
        Insert_tail(&Lc,p1->data);
        p1 = p1->next;
    }
 
    while(p2 != NULL)
    {
        if(!IsPresent(Lc,p2->data))
        {
            Insert_tail(&Lc,p2->data);
        }
        p2 = p2->next;
    }
    return Lc;
}
 

差集：

遍历第一个链表，若该元素在第二个链表中不存在，则将该元素插入到结果链表中

BNode *Difference_Set_1(BTlist plist1,BTlist plist2)
{
    BTlist Lc;
    Lc = NULL;  // 初始化无头单链表
    BTlist p1 = plist1;
    BTlist p2 = plist2;
   
    while(p1 != NULL)
    {
      if(!IsPresent(p2,p1->data))
      {
        //尾插法
        Insert_tail(&Lc,p1->data)
      }
      p1 = p1->next;
    }

    return Lc;
}

 

 

 

 

 

 

 

Kobe51920
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 线性表的应用——经典题目分析
ZY-JIMMY
12-27 1392
目录 1、逆置单链表 2、反转单链表 3、合并两个有序的单链表 4、判断单链表是否有环？环的入口点？环的长度？ 5、判断两个单链表是否相交？交点？ 6、O(1)时间删除单链表的一个节点 7、最快时间内找到单链表倒数第K个节点？ 8、最快时间内删除单链表倒数第K个节点？ 9、 求两个顺序表的交集、并集和差集 10、求两个有序单链表的交集、并集和差集 11、求两个单链表(可以无...
数据结构线性表题库
闲狗的博客
08-01 1万+
网络课课后题 1、下面关于线性表的叙述中，正确的是 A、线性表采用顺序存储，必须占用一片连续的存储单元。 B、线性表采用顺序存储，便于进行插入和删除操作。 C、线性表采用链接存储，不必占用一片连续的存储单元。 D、线性表采用链接存储，便于插入和删除操作。 解析 顺序存储是按索引值从小到大存放在一片相邻的连续区域 采用链接存储，便于插入和删除操作，如果采用顺序存储，插入和删除时需要...
链表反转理解
weixin_45755539的博客
07-21 254
对单链表反转的图解 原始链表： 反转过程： 第一步：next = head.next 将 head.next 赋值给 next 变量，即next 指向了节点2，先将节点2 保存起来。 第二步：head.next = pre （初始pre==None） 将 pre 变量赋值给 head.next，即 此时节点1 指向了 None 第三步：pre = head 将 head 赋值给了 pre，即 pre 指向节点1，将节点1 设为“上一个节点” 第四步：head = next 将 next 赋值给 head，即
算法学习-链表
weixin_48675492的博客
10-09 145
1）链表是以节点的方式来存储的2）每个节点包含data域，next域（指向下一个节点）3）链表中每个节点不一定是连续存储4）分为带头节点的链表和没有头节点的链表，根据实际需求来确定 b.考虑编号顺序添加 只能按照123，不能132【链表会断】 c.修改节点 d.删除节点 单链表的缺点：1.查找方向只能是一个方向2.不能自我删除，需要辅助节点temp找到待删除节点的前一个节点a.遍历：可以向前也可以向后b.添加【末尾】找到双向链表最后一个节点t
顺序表经典问题之一
qq_39690007的博客
07-21 841
问题： 顺序表A中有一堆整数，现试将其中的负数放在0的左侧，正数放在0的右侧（有多个或者一个0），要求在算法在时间和空间上都尽可能高效。 思想： 用for循环扫描，找正数、负数、交换位置，最后对0进行排列 采用一种高效的排序算法（比如快速排序） 三指针，一头一尾一工作（高效） 代码实现： #include<stdio.h> int Exchange(int a[11],int i...
剑指offer:5-8题
12-23
题目说明：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 程序： 栈和队列都是操作受限的线性表。 栈：限定仅在表尾进行插入或删除的线性表(先进后出)； 队列：允许在线性表的一端...
C++数据结构实验一：线性表的应用
03-29
1．熟练掌握线性表的基本运算。 2．掌握顺序表和单链表结构上的插入和删除算法。 3．了解循环链表、双(循环)链表的结构特点和在其上施加的插入、删除等操作。 4. 掌握线性表的逻辑结构特点、顺序存储结构、链式存储...
实验三：线性表的应用.doc
最新发布
11-08
3. 分析算法，要求给出具体的算法分析结果，包括时间复杂度和空间复杂度，并简要给出算法设计小结和心得。 四、实验准备 1. 掌握线性表的抽象数据类型的特点，并能在相应的应用任务中正确选用该结构。 2. 熟练掌握...
验证2：线性表子系统实验报告.doc
10-08
* 创立线性表：创建一个新的线性表。 * 插入元素：在线性表中插入新的元素。 * 删除元素：从线性表中删除指定的元素。 * 显示线性表：显示线性表中的所有元素。 * 查找元素：查找线性表中的指定元素。 * 求表长：...
剑指offer所有的题目总结
mw_nice的博客
02-18 212
https://blog.csdn.net/wszy1301/article/details/80910626 https://blog.csdn.net/c406495762/article/details/79247243   零、小结： 一、位运算 1、二进制中1的个数 2、判断二进制中0的个数 3.二进制高位连续0的个数 二、二叉树 1、二叉搜索树第k个结点 2.0 从...
有关head->next = p;和p=head->next;之间的区别
skychaofan的博客
07-09 2万+
#include #include #include typedef struct list { char *name; struct list *next; }List; int main(int argc, char *argv[]) { List *p = (List *)malloc(sizeof(List)); List *head = (Lis
关于线性表的一些很有意思的题目1
Android's Blog
11-26 1068
题目1 ：设将n个 整数存放在数组中，设计一个算法在时间复杂度上和空间复杂度上尽可能简单的算法，让数组顺序向左移动R位，让数组从(0，1，2，3，4，5，6，7)------>(3,4,5,6,7,0,1,2)解题思路：我们在线性代数中碰见过A和它的转制，这就是这个题目的思路;(A(T)B(T))(T)=BA ;(这里的A(T)是指A的转制),我们发现通过这样的转化，可以将AB的位置换一下; 我们就以可以例子为例在做一下：(向左移动3位)1.先对(0.1.2)进行转制变成(2.1.0),这
C\C++开发的经典魔塔小游戏--（1）图形库的使用
li7513499的博客
08-14 3845
最近突发奇想，想起了当年和小伙伴们一起奋斗在村里黑网吧的日子。于是乎，萌发了动手写一个下游戏的念头。这个经典的小游戏名字叫“魔塔”。大致就是你是一个骑士什么的，深入魔塔拯救大妹子的故事。 设计思路还是很简单的，具体就是一些C/C++图形库的引用，将收集好的图片素材显示在界面上各个位置，然后通过接受键盘输入控制角色移动，碰到道具之后修改角色本身各项的数值来模拟打斗场景。 加入游戏背景音乐，加入其它一...
java head head.next_牛客网刷题java之输入一个链表，反转链表后，输出新链表的表头。...
weixin_29484035的博客
02-24 517
题目：输入一个链表，反转链表后，输出新链表的表头。思路： 代码：/*public class ListNode {int val;ListNode next = null;ListNode(int val) {this.val = val;}}*/public class Solution {public ListNode ReverseList(ListNode head) {//首先判断链表是...
线性表基础：链表及经典问题（二）经典算法题刷题（链表的反转、链表的节点删除）
语雀同名：犬豪 yuque.com/qhao
03-15 280
紧接上一章 三、经典算法题 以下算法题均摘自力扣，读者可自行去力扣答题，并有详细题解，我只是简单介绍了下我的解题思路，并记录一下自己的答案，毕竟算法光看、思考是远远不够的，还需要多加练习，以下是链表相关经典算法题答题的推荐顺序：141、142、202、206、92、25、61、24、19、83、82。 3.2 链表的反转 3.2.1 LeetCode #206 反转链表 题目描述 反转一个单链表。 进阶:你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ 解题思路： 思路1：迭代反转 思.
2021网易实习生笔试题（一场计算机视觉、一场数据研发后端）
JH_Shawlin的博客
04-13 1596
计算机视觉算法岗 网易的笔试貌似是有好多题随机给四道做，看评论大家的题并不完全一样，我找到的四道题如下： 题目一 牛牛的等差数列 长度为n的数组a，找到一个最大的正整数d，使得对于所有i，a[i+1]-a[i]是d的倍数，即a[i+1]-a[i]=d×k(k≥1)。 输入： 第一行一个正整数n，2<=n<=2*10^5 第二行n个正整数a[i]，1<=a[i]<=10^18...
s->next=head; head=s;如何理解
我的目标是CEO，最近小目标是项目架构师！
10-16 4549
s->next=head; head=s;这两句中你认为head是头结点还是头指针？ 书上说的是头指针，然后这两句怎么解释？ 5 LinkNode *CreateLinkList()//头插入法无头结点建立线性表 { LinkNode *head,*p,*s; int x; int z=1,n=0; head=NULL; printf("\n\t\t建立一个线性表"); printf
线性表问题
weixin_30657541的博客
08-20 251
#include<iostream> #include<string> using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef int Status,ElemType; typedef struct { ElemType *e...
python数据结构——链表（最简单的解释）
热门推荐
来自小白的挖掘算法入门
07-22 3万+
对于链表，当初学C的时候就没有理解的很清楚，现在又重新遇到，要把这个弄明白。 数据结构是计算机科学必须掌握的一门学问，很多的教材都是用C语言实现链表，因为C有指针，可以很方便的控制内存，很方便就实现链表，其他的语言，则没那么方便，有很多都是用模拟链表，因为python是动态语言，可以直接把对象赋值给新的变量。在C/C++中，通常采用“指针+结构体”来实现链表；而在Python中，则可以采用“引用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值