一些小随笔

最新推荐文章于 2022-04-10 19:16:27 发布
最新推荐文章于 2022-04-10 19:16:27 发布
阅读量274 收藏
点赞数 1
分类专栏： 笔记 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50382279/article/details/120394962
版权

1.逆转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {//定义:反转该链表并输出反转后链表的头节点。
      if(head==NULL) return NULL;
      if(head->next==NULL) return head;
       ListNode * root=reverseList(head->next);
       ListNode *   ans=root;
       while(root->next!=NULL){
           root=root->next;
       }
       root->next=head;
       head->next=NULL;
       
       return ans;
    }
};

2.给定max,min删除链表里那些在(min,max)的元素

```cpp
#include<iostream>
using namespace std;
struct ListNode {
 int data;
 ListNode* next;
 ListNode(int x)  {
  data = x;
  next = NULL;
 }
};//找到第一个比min大的,开始删除,看下一个节点和max的关系
ListNode* build() {
 int a=0;//输入的元素
 ListNode* head,*ans;//尾插法
 head = new ListNode(0);
 ans = head;
 while (a != -1) {
  cin >> a;
  if (a == -1) return ans;
  head->next = new ListNode(a);
  head = head->next;
 }
 head->next = NULL;
 return ans;
}
ListNode* delete_element(ListNode* head,int min,int max){
 ListNode* res = head;
 int flag = 1;
 ListNode* first = NULL, * end = NULL, * deletes = NULL;
 while (head->next != NULL) {
  int a = head->next->data;
  
  if (a > min && a<max && flag) {//记录第一个等下直接桥连
   first = head;
   flag = 0;
   }
  //已经记录了上面的first
  if (!flag) {
   if (a >= max) {//说明当前节点的下一个已经超出了范围了,当前节点应该被删掉
    end = head->next;
    break;
     }
  }
  head = head->next;
    }
 if (first == NULL) return res;//这个左数太小了
 if (end == NULL) {
  first->next = NULL;
  return res;
 }
 deletes = first->next;
 cout << "first->data" << first->data << endl;
 cout << "end->data" << end->data << endl;
 first->next = end;
 while (deletes!=end) {
  ListNode* net = deletes->next;
  free(deletes);
  deletes = net;
   }
 return res;
}
void show(ListNode* head) {
 head = head->next;
 while (head != NULL) {
  cout << head->data << endl;
  head = head->next;
 }
}
int main() {
 ListNode* head = build();
 show(head);
 int min, max;
 cin >> min >> max;
 head = delete_element(head, min, max);
 show(head);

}

3.双向链表根据访问频次,动态的非递增排序链表

```cpp
#include<iostream>
using namespace std;
struct ListNode {
 int data;
 int freq;
 ListNode* next;
 ListNode* prior;
 ListNode(int x)  {
  data = x;
  next = NULL;
  prior = NULL;
  freq = 0;

 }
};//找到第一个比min大的,开始删除,看下一个节点和max的关系
ListNode* build() {
 int a=0;//输入的元素
 ListNode* head,*ans;//尾插法
 head = new ListNode(-100);//dummy头
 ans = head;
 while (a != -1) {
  cin >> a;
  if (a == -1) return ans;
  ListNode*cur= new ListNode(a);
  head->next = cur;
  cur->prior = head;
  head = head->next;
 }
 head->next = NULL;
 return ans;
}
ListNode* Locate(ListNode* head, int x) {//访问并调整位置,如何利用双向链表(删方便)
 ListNode* root = head;
 ListNode* chang = head;
 //在中间处断开
 while (root!=NULL) {
  if (root->data == x) {
   root->freq++;
   //断开位置在最后
   if (root->next == NULL) {
    chang = root;
    root->prior->next = NULL;
    break;
    }
   //断开
   chang = root;
   root->prior->next = root->next;
   root->next->prior = root->prior;
   break;
   }
  root = root->next;
 }
 if (root == NULL) {
  printf("查无此数\n");
  return head;
 }
 //找位置插入
 root = head;
 while (root->next!=NULL) {
  if (root->next->freq  <   chang->freq) {//将chang插入//如果进不去呢
   chang->next = root->next;
   root->next->prior = chang;
   root->next = chang;
   chang->prior = root;
   return head;
  }
  root = root->next;
 }
 //插入位置在最后(freq更新后还是太小了)
 root->next = chang;
 chang->prior = root;
 chang->next = NULL;
}

void show(ListNode* head) {
 head = head->next;
 while (head != NULL) {
  cout << head->data << "fre=="<<head->freq<<endl;
  head = head->next;
 }
}
int main() {
 ListNode* head = build();
 show(head);
 int a = 0;
 while (a!=-1) {
  printf("请输入接下来要查找的数x\n");
  cin >> a;
  Locate(head, a);
  show(head);
 }
 

}

4.链表实现约瑟夫

#include<iostream>
using namespace std;
struct ListNode {
 int data;
 int exist;
 ListNode* next;
 ListNode* prior;
 ListNode(int x)  {
  data = x;
  next = NULL;
  prior = NULL;
  exist = 1;

 }
};//找到第一个比min大的,开始删除,看下一个节点和max的关系
ListNode* build(int x) {
 int a=0;//输入的元素
 ListNode* head,*ans;//尾插法
 head = new ListNode(-100);//dummy头,尾部节点连dummy的下一个,然后维护一个int记录
 //链表的大小
 ans = head;
 while (x>0) {
  x--;
  cin >> a;
  ListNode* cur = new ListNode(a);
  head->next = cur;
  head = head->next;
 }
 //成环
 head->next = ans->next;
 return ans;
}

void delete_say(int m,int n,ListNode*head) {
 int cnt = 0;
 int size = m;
 ListNode* root = head->next;
 int move = n%size;
 while (size>0) {//还有节点在
  
  if (root->exist == 1) cnt++;
  if (cnt == move) {
   cout << root->data << endl;
   root->exist = 0;
   size--;
   cnt = 0;
  }
  root = root->next;
  }
 }

void show(ListNode* head) {
 ListNode* ans = head->next;
 head = head->next;
 int t = 0;
 while (t<10) {
  t++;
  cout << head->data<<endl;
  head = head->next;
 }
}
int main() {
 int a = 0,b=0; 
 printf("请输入人数\n");
 cin >> a;
 printf("请输入循环次数\n");
 cin >> b;
 ListNode* head = build(a);
 delete_say(a,b,head);
 return 0;
 }

5.单链表的数据的绝对值<m,删除绝对值一样的重复节点只保留第一个节点(用visit[]辅助数组)

#include<iostream>
#include<vector>
using namespace std;
vector<int>exist;
struct ListNode {
 int data;
 ListNode* next;
 ListNode(int x)  {
  data = x;
  next = NULL;
 }
};
ListNode* build(int x) {
 int a=0;//输入的元素
 ListNode* head,*ans;//尾插法
 head = new ListNode(-100);//dummy头,尾部节点连dummy的下一个,然后维护一个int记录
 //链表的大小
 ans = head;
 while (x>0) {
  x--;
  cin >> a;
  ListNode* cur = new ListNode(a);
  head->next = cur;
  head = head->next;
 }

 head->next = NULL;
 return ans;
}



void show(ListNode* head) {
 
 head = head->next;
 
 while (head!=NULL) {
  cout << head->data<<endl;
  head = head->next;
 }
}
ListNode* deletes(ListNode* head) {
 ListNode *ans = head;
 while (head->next!= NULL) {
  int a = abs(head->next->data);
  if (exist[a]) {
   head->next = head->next->next;
  // exist[a]--;
  }
  else {
   exist[a]=1;
   head = head->next;
  }
 
  }

 return ans;
 
}
int main() {
 int n,m;
 cout << "请输入链表的个数"<<endl;
 cin >> n;
 cout << "请输入链表的data最大值" << endl;
 cin >> m;
 exist.resize(m,0);
 //for(int i=0;i<exist.size();i++)
 //cout <<exist[i]<<endl;
 ListNode* head = build(n);
 show(head);
 head = deletes(head);
 cout << "调用deletes(head)之后" << endl;
 show(head);
 return 0;
 }

6.环状队列

#include<iostream>
#include<vector>
using namespace std;

int size_queue;
class queue {
  public:
 queue(int a) {
  exist.resize(a + 1, 0);
  front = 1;
  rear = 1;
  num = 0;
 }
 
 
 void push(int x) {
  if (num == size_queue) {
   cout << "队列满";
   return;
  }
  num++;
  exist[rear] = x;
  rear++;
  if (rear > size_queue)//保证求余后直接从1开始
   rear %= size_queue;
 }
 void delete_element() {
  if (num == 0) cout << "已经队空" << endl;
  exist[front] = 0;
  front++;
  if(front>size_queue)//保证求余后直接从1开始
  front %= size_queue;
  num--;
 }
 void shuchu() {
  for (int i = 0;i <= size_queue; i++) {
   cout << exist[i] << " ";
  }
  cout << endl;
 }
private:
 vector<int>exist;
 int front,rear,num;
};

int main() {
 
 cout << "请输入数组的大小"<<endl;
 cin >> size_queue;
 queue q(size_queue);
 int a;
 cout << "输入1 push,输入2 pop,输入-1 end"<<endl;
 cin >> a;
 while (a!=-1) {
  if (a == 1) {
   int x;
   cout << "输入要压进去的数";
   cin >> x;
   q.push(x);
  }
  else if (a == 2) {
   q.delete_element();
    }
  q.shuchu();
  cout << "输入1 push,输入2 pop,输入-1 end" << endl;
  cin >> a;
 }
  

 



 }

7.双端队列

#include<iostream>
#include<vector>
using namespace std;
int item;
int size_queue;
class queue {
  public:
 queue(int a) {
  exist.resize(a + 1, 0);
  front = 1;
  rear = 1;
  num = 0;
 }
 void inject(int x) {
  if (num == size_queue) {
   cout << "队列满";
   return;
  }
  num++;
  exist[front] = x;
  front++;
  if (front > size_queue)//保证求余后直接从1开始
   rear %= size_queue;
 }
 
 void push(int x) {
  if (num == size_queue) {
   cout << "队列满";
   return;
  }
  num++;
  exist[rear] = x;
  rear++;
  if (rear > size_queue)//保证求余后直接从1开始
   rear %= size_queue;
 }
 void pop() {
  if (num == 0) cout << "已经队空" << endl;
  item = exist[front];
  exist[front] = 0;
  front++;
  if(front>size_queue)//保证求余后直接从1开始
  front %= size_queue;
  num--;
 }
 void eject() {
  if (num == 0) cout << "已经队空" << endl;
  item = exist[rear];
  exist[rear] = 0;
     rear++;
  if (rear > size_queue)//保证求余后直接从1开始
   rear %= size_queue;
  num--;
 }
 void shuchu() {
  for (int i = 0;i <= size_queue; i++) {
   cout << exist[i] << " ";
  }
  cout << endl;
 }
private:
 vector<int>exist;
 int front,rear,num;
};

int main() {
 
 cout << "请输入数组的大小"<<endl;
 cin >> size_queue;
 queue q(size_queue);
 int a;
 cout << "输入1 push,输入2 pop,输入-1 end"<<endl;
 cin >> a;
 while (a!=-1) {
  if (a == 1) {
   int x;
   cout << "输入要压进去的数";
   cin >> x;
   q.push(x);
  }
  else if (a == 2) {
   q.delete_element();
    }
  q.shuchu();
  cout << "输入1 push,输入2 pop,输入-1 end" << endl;
  cin >> a;
 }
  

 



 }

8.一数组,双栈迎面法

#include<iostream>
#include<vector>
using namespace std;
class stack {
  public:
 stack(int a) {
  exist.resize(a, 0);
  left = 0;
  right = a - 1;
 }
 bool check() {
  if (left == 0 && right == a - 1) return true;
  return false;
 }
 void push1(int x) {
  if (left < right) {
   exist[left] = x;
   left++;
  }
  else {
   cout << "空间满啦";
  }
 }
 void push2(int x) {
  if (left < right) {
   exist[right] = x;
   right--;
  }
  else {
   cout << "空间满啦";
  }
  
 }
 void shuchu() {
  for (int i = 0;i <exist.size(); i++) {
   cout << exist[i] << " ";
  }
  cout << endl;
 }
private:
 vector<int>exist;
 int left,right;
};

int main() {
 
 }

9.用2栈实现队列

第九题在这:class MyQueue {
public:
  stack<int>a1;//入队栈
  stack<int>a2;//出队栈
    /** Initialize your data structure here. */
    MyQueue() {
       
    }
    
    /** Push element x to the back of queue. */
    void push(int x) {
         a1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        if(!a2.empty()) {
             int a=a2.top();
              a2.pop();
             return a;
        }
           while(!a1.empty()){//把a1的元素都变过去a2
              int a=a1.top();
              a1.pop();
              a2.push(a);
           }
            if(!a2.empty()) {
             int a=a2.top();
              a2.pop();
             return a;
        }
         return 0;
    }
    
    /** Get the front element. */
    int peek() {
        if(!a2.empty()) return a2.top();
           while(!a1.empty()){//把a1的元素都变过去a2
              int a=a1.top();
              a1.pop();
              a2.push(a);
           }
            if(!a2.empty()) return a2.top();
           return 0;
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
      return a2.size()==0 && a1.size()==0;
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

11删除数组里的特定元素
`#include
#include
using namespace std;
//11题 双指针(赋值与探路指针法)(O(n))
int main() {
int n = 0;
cout << “请输入一下大小”;
cin >> n;
vectora(n, 0);
for (int i = 0; i <n ; i++) {
cin >> a[i];
}
int item;
cout << “请输入删除的元素”;
cin >> item;
int slow = 0, fast = 0;
while (fast < n) {
if (a[fast] == item) {
fast++;
}
else {
a[slow] = a[fast];
fast++;
slow++;
}
}
for (int i = 0; i <slow; i++) {
cout << a[i] << endl;
}
}
12:编写算法Reverse，将顺序存储的线性表A=( a1, a2, …, an )转换为A=( an,…, a2, a1)，要求转换过程中用尽可能少的辅助空间。
算法:原地修改法

#include<iostream>
using namespace std;
int main() {
	int b;
	int a[100];
	cin >> b;
	for (int i = 0; i < b; i++) {
		cin >> a[i];
	}
	int left = 0, right = b - 1;
	while (left < right) {
		int temp = a[left];
		a[left] = a[right];
		a[right] = temp;
		left++;
		right--;
	}
	for (int i = 0; i < b; i++) {
		cout << a[i] << endl;
	}
}

对于顺序栈和链式栈s，分别编写算法SelectItem，要求在堆栈中查找元素n在栈中第一次出现的位置，并将该位置元素移至栈顶，同时其他元素次序不变。

在这里插入代码片
数据结构学习——顺序栈和链式栈的简单实现和解析（C语言版）
正弦定理的博客
11-26 1296
数据结构——栈的简单解析和实现一、概念二、入栈（push）三、出栈（pop）四、顺序栈简单实现（1）进栈操作（2）出栈操作 一、概念 本篇所讲解的栈和队列属于逻辑结构上的划分。逻辑结构分为线性结构、非线性结构 线性结构：有且仅有一个开始节点和一个终端节点，每个节点最多只有一个直接前驱和一个直接后继。代表结构：栈、队列 非线性结构：一个节点可能有多个直接前驱和多个直接后继。代表结构：树、图 堆栈（英语：stack）又称为栈或堆叠，是计算机科学中的一种抽象数据类型，只允许在有序的线性数据集合的一端（称
数据结构笔试题的笔记
jacksonary的博客
08-01 3968
1.存储密度的概念 存储密度=单链表数据项所占空间/结点所占空间；一般情况下，因为结点中包含数据项和指针，所以正常而言密度是小于1的。2.链队不是链表！ 对于链队而言，删除操作只能在对头操作，而插入只能在对位操作，这里需要注意的是当链队中只有一个元素的时候，那么在进行删除的时候，她的头尾指针都是需要修改的3.链表不能随机访问任何一个元素4.对于顺序表而言，每次进行删除某一个位置的元素（非末尾元素
【数据结构上机练习】5.栈的简单操作（2）
weixin_30797027的博客
10-30 198
上机3.2 2、编写一个函数SelectItem（Stack&s，intn），要求利用堆栈来查找n在栈中第一次出现的位置，并将该位置元素移至栈顶，同时其他元素次序不变。 注：栈类用了之前定义的 1 //============================================================================...
C语言实现顺序栈 和 链式栈
记录学习点滴
04-14 1514
栈：先进后出 1.顺序栈 #include <stdio.h> #include <stdlib.h> #define STACK_INIT_SIZE 100 //栈初始容量 #define STACKINCREMENT 10 //存储空间分配增量 typedef int dataType; typedef struct { dataType *base; .........
王道数据结构：栈顺序存储和链式存储以及基本操作的实现(C语言版）
知且行的博客
01-22 5605
栈 只允许在一端进行插入或删除操作的线性表。 对于n个不同元素进栈，出栈序列的个数为(卡特兰数) 顺序栈基本操作的实现代码如下： #include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h> #define MaxSize 10 //栈的顺序存储...
[小忆故乡随笔]故乡随笔.rar
03-11
该随笔集的PDF格式文件名为 "[小忆故乡随笔]故乡随笔.pdf"，这表明内容可能是文字形式的散文或者诗歌，也可能包含了一些插图或照片来增强读者对故乡场景的理解和感知。PDF是一种常用的文档格式，因其跨平台兼容性和...
Python｜初学练习小随笔①
12-22
在本文中，我们将探讨Python编程语言的一些基础概念，特别是针对初学者的练习。这涉及到`for`循环、`range()`函数以及如何进行余数运算，这些都是Python编程中的关键知识点。 首先，`for`循环是Python中的一种迭代...
关于我和我的小伙伴随笔散文_1.docx
12-01
这篇文档实际上是由四篇独立的随笔散文组成，每一篇都描述了作者与他的小伙伴之间的趣事和友谊。虽然这些故事并非直接与IT知识相关，但我们可以从中提取出一些关于人际关系和团队协作的重要概念，这些都是在IT行业中...
小女子的幸福指数_生活随笔.doc.pdf
12-20
在这个故事中，尽管标题“小女子的幸福指数_生活随笔”看似与“技术”标签无关，但我们可以从中提炼出一些关于生活智慧和技术之间隐含的联系。在现代社会，技术的发展为我们提供了各种便利，让我们可以更高效地处理...
设计小白的随笔
alicelmx的博客
12-12 643
我是一个设计小白呀，通过一个比赛开始接触设计，现在很有兴趣，还在学习中
数据结构-栈的实现和应用（day7）
楚子航
04-10 1265
一、顺序栈的原理 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈） 允许进行操作的一端称为“栈顶” 另一固定端称为“栈底” 当栈中没有元素时称为“空栈”。特点 ：后进先出（LIFO）。 1.栈的应用： 如何排课： 没有前驱的顶点可以通过一个栈去存储，借助于进栈出栈的操作，完成对图的特殊处理，检查它有没有回路。 先入后出 二、顺序栈的实现 它是顺序表的一种，具有顺序表同样的存储结构，由数组定义，配合用数组下标表示的栈顶指针top（相对指针）完成各种操作。 ...
数据结构作业_顺序表
Wu_JingYi0829的博客
10-22 2614
【项目1 – 顺序表的基本运算】 建立建立顺序表运算的算法库。 算法库包括两个文件： 头文件：list.h，包含定义顺序表数据结构的代码、宏定义、要实现算法的函数的声明； 源文件：list.cpp，包含实现各种算法的函数的定义 请采用程序的多文件组织形式，建立如上的两个文件，另外再建立一个源文件，编写main函数，完成相关的测试工作（以下操作在主函数中调用实现）。 创建一个顺序表，测试样例：5，9，6，7，4，8，1，3，2； 在已经建立的线性表的第8个位置插入一个元素x（10），测试样例：5，9，6，7
线性表的顺序实现——数据结构课堂作业
weixin_34137799的博客
11-04 818
/**********************************//*顺序表的头文件，文件名sequlist.h*//**********************************/ #include <stdio.h> #include <stdlib.h> /**********************************/ /*顺序...
顺序表的实现（python）
lxyh0000的博客
12-11 2812
利用python内置的list来实现顺序表 class SequenceList(object): &amp;quot;&amp;quot;&amp;quot;顺序表&amp;quot;&amp;quot;&amp;quot; def __init__(self, size=6): # 初始化顺序表 self.max = size self.num = 0 # 提前构建一个固定大小的列表 self.data = [Non
将顺序表里的数据存储位置倒置
Jjican的博客
03-02 3608
#include #include struct SeqList     {         int MAXNUM;         int n;         int *element;     };     typedef struct SeqList *PSeqList; PSeqList createNullList_seq(int m){    
数据结构算法之---顺序表逆置
小何才露尖尖角
09-29 4125
思路： 此种算法较为经典，可扫描该线性表的前半部分，然后把前半部分的每一个元素和后半部分进行交换。具体算法如下： void reverse(sqList s,int length)//传入一个线性表，length该表的长度 { int temp; for(int i=0;i<length/2;i++)//只扫描表的前半部分 { temp=s[i]; int s[i]=s[length-1-i]; s[length-i-1]=s[i
2021-10-25 数据结构顺序表算法题（逆置、查找值、负值在正值前、循环移动）
m0_52461904的博客
10-25 1732
先声明：本人是个初学者，本博客全为我自己写的，只是作为个人学习记录使用，很有可能不够规范或漏洞百出，请多包涵。 ps：有个小目标，大概就是之后输入数据能通过产生随机数实现，到时候再钻研，本博客还是手动输入的简单样例数据。 首先先简单定义一个用动态存储分配的顺序表以及初始化以及根据长度打印表的函数： #include<stdio.h> #include<malloc.h> #define initSize 100 typedef int ElemType; typedef s
【顺序表】顺序表的就地逆置
热门推荐
chaim16的博客
06-23 1万+
编写算法实现顺序表的就地逆置，即利用原顺序表的存储单位把数据元素顺序反向，例如：1,5,6,9,8逆置为 8,9,6,5,1 题目分析：   就地逆置，就是指借用顺序表自身实现顺序逆置，不借助其他线性表。   如果让你口算从1+2+3+4+5+……+99，你会怎么计算呢？很显然，折半加法，将1到99分成两半，1+99=10，2+98 = 100,3+97=100,4+96=100,……，49+51 = 100，50，所以一共49个100，加上最后50，最终答案为4950。 之所以和大家
顺序存储--顺序表
every_is_fine的博客
11-08 770
1.顺序表L #define InitSize 100 typedef struct{ ElemType *data; int MaxSize,Length; }SeqList; 2、 在顺序表L中第i个位置插入一个元素e 思路：第i个位置之后的元素后移，并将每一个元素都往后挪一个位置，在将e放入第i个位置，注意第i个位置的数组下标是i-1 bool ListInsert(SqList &L,int i,ElemType e ){ if(i<1||i>L.length+1)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值