LeetCode刷题--点滴记录004
Posted 鲁棒最小二乘支持向量机
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode刷题--点滴记录004相关的知识，希望对你有一定的参考价值。
4. 图解算法数据结构
数据结构是为实现对计算机数据有效使用的各种数据组织形式，服务于各类计算机操作。不同的数据结构具有各自对应的适用场景，旨在降低各种算法计算的时间与空间复杂度，达到最佳的任务执行效率。
常见的数据结构
线性数据结构 ： 数组(Array)；链表(Linked List)；栈(Stack)；队列(Queue)
非线性数据结构 ： 数(Tree)；堆(Heap)；散列表(Hashing)；图(Graph)
数组(Array)
数组是将相同类型的元素存储于连续内存空间的数据结构，其长度不可变。
C++版本
#include <iostream>
using namespace std;
#include <vector>
void printVector(vector<int>& v)
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
cout << *it << " ";
cout << endl;
template <class T>
void printArray(T& array)
for (int i = 0; i < sizeof(array)/sizeof(array[0]); i++)
cout << array[i] << " ";
cout << endl;
void test01()
// 初始化一个长度为 5 的数组
int array[5];
// 元素赋值
array[0] = 0;
array[1] = 1;
array[2] = 2;
array[3] = 3;
array[4] = 4;
printArray(array);
void test02()
int array[] = 0, 1, 2, 3, 4 ;
printArray(array);
void test03()
// 初始化可变数组
vector<int> array;
// 向尾部添加元素
array.push_back(0);
array.push_back(1);
array.push_back(2);
array.push_back(3);
array.push_back(4);
printVector(array);
int main()
test01();
cout << "------------------" << endl;
test02();
cout << "------------------" << endl;
test03();
system("pause");
return 0;
Python版本
def test01():
array = [1, 2, 3, 4, 5]
print(array)
def test02():
# 初始化可变数组
array = []
# 向尾部添加元素
array.append(1)
array.append(2)
array.append(3)
array.append(4)
array.append(5)
print(array)
# 切片
print(array[0:3])
print(array[:3])
print(array[1:4])
print(array[2:])
def test03():
array = list(range(1,6))
print(array)
arrayeven = list(range(2,6,2))
print(arrayeven)
arrayodd = list(range(1,6,2))
print(arrayodd)
if __name__=="__main__":
test01()
print("--------------")
test02()
print("--------------")
test03()
Java版本
package com.hailei_01;
import java.util.ArrayList;
import java.util.List;
public class array
public static void main(String[] args)
// 初始化一个长度为 5 的数组 array
int[] array1 = new int[5];
// 元素赋值
array1[0] = 1;
array1[1] = 2;
array1[2] = 3;
array1[3] = 4;
array1[4] = 5;
for(int i=0;i<array1.length;i++)
System.out.print(array1[i]+" ");
System.out.println("\\n------------");
int[] array2 = 1, 2, 3, 4, 5;
for(int a:array2) //增强for
System.out.print(a+" ");
System.out.println("\\n------------");
// 初始化可变数组
List<Integer> array3 = new ArrayList<>();
// 向尾部添加元素
array3.add(1);
array3.add(2);
array3.add(3);
array3.add(4);
array3.add(5);
System.out.println(array3);
链表(Linked List)
链表以节点为单位，每个元素都是一个独立对象，在内存空间的存储是非连续的。
C++版本
struct ListNode
int val; // 节点值
ListNode* next; // 后继节点引用
ListNode(int x) : val(x), next(NULL)
;
void print(ListNode* phead)//输出
ListNode* p = phead;
while (p != NULL)
cout << p->val << " ";
p = p->next;
cout << endl;
void test01()
// 实例化节点
ListNode* n1 = new ListNode(1); // 节点 head
ListNode* n2 = new ListNode(2);
ListNode* n3 = new ListNode(3);
// 构建引用指向
n1->next = n2;
n2->next = n3;
//打印输出
print(n1);
cout << "----------" << endl;
print(n2);
int main()
test01();
system("pause");
return 0;
Python版本
#include <iostream>
using namespace std;
class ListNode:
def __init__(self, x):
self.val = x # 节点值
self.next = None # 后继节点引用
def print_ListNode(node):
while node:
print(node.val, end=' ')
node = node.next
def test01():
# 实例化节点
n1 = ListNode(3) # 节点 head
n2 = ListNode(2)
n3 = ListNode(1)
# 构建引用指向
n1.next = n2
n2.next = n3
print_ListNode(n1)
print("\\n--------------")
print_ListNode(n2)
if __name__=="__main__":
test01()
Java版本
package com.hailei_02;
public class listNode
public static void main(String[] args)
// 实例化节点
ListNode n1 = new ListNode(9); // 节点 head
ListNode n2 = new ListNode(3);
ListNode n3 = new ListNode(6);
// 构建引用指向
n1.next = n2;
n2.next = n3;
printListNode(n1);
System.out.println("\\n-------------");
printListNode(n3);
public static class ListNode
int val; // 节点值
ListNode next; // 后继节点引用
ListNode(int x) val = x;
public static void printListNode(ListNode headNode)
ListNode listNode = headNode;
while(listNode!=null)
System.out.print(listNode.val+" ");
listNode = listNode.next;
栈(Stack)
栈是一种具有 先入后出 特点的抽象数据结构，可使用数组或链表实现。
C++版本
#include <iostream>
using namespace std;
#include <stack>
void test01()
stack<int> stk;
stk.push(1); // 元素 1 入栈
stk.push(2); // 元素 2 入栈
cout << "栈顶元素为：" << stk.size() << endl;
stk.push(3); // 元素 3 入栈
stk.push(4); // 元素 4 入栈
cout << "栈顶元素为：" << stk.size() << endl;
stk.pop(); // 出栈 -> 元素 4
stk.pop(); // 出栈 -> 元素 3
cout << "栈顶元素为：" << stk.size() << endl;
stk.pop(); // 出栈 -> 元素 2
stk.pop(); // 出栈 -> 元素 1
cout << "栈顶元素为：" << stk.size() << endl;
int main()
test01();
system("pause");
return 0;
Python版本
def test01():
stack = [] # Python 可将列表作为栈使用
stack.append(1) # 元素 1 入栈
stack.append(2) # 元素 2 入栈
print(stack)
stack.append(3) # 元素 3 入栈
stack.append(4) # 元素 4 入栈
print(stack)
stack.pop() # 出栈 -> 元素 4
stack.pop() # 出栈 -> 元素 3
print(stack)
stack.pop() # 出栈 -> 元素 2
stack.pop() # 出栈 -> 元素 1
print(stack)
if __name__=="__main__":
test01()
Java版本
package com.hailei_03;
import java.util.LinkedList;
public class stack
public static void main(String[] args)
LinkedList<Integer> stack = new LinkedList<>();
stack.addLast(1); // 元素 1 入栈
stack.addLast(2); // 元素 2 入栈
stack.addLast(3); // 元素 3入栈
stack.addLast(4); // 元素 4 入栈
System.out.println("第一个元素："+stack.getFirst());
System.out.println("最后一个元素："+stack.getLast());
stack.removeLast(); // 出栈 -> 元素 4
stack.removeLast(); // 出栈 -> 元素 3
System.out.println("第一个元素："+stack.getFirst());
System.out.println("最后一个元素："+stack.getLast());
stack.removeLast(); // 出栈 -> 元素 2
stack.removeLast(); // 出栈 -> 元素 1
队列(Queue)
队列是一种具有 先入先出 特点的抽象数据结构，可使用链表实现。
C++版本
#include <iostream>
using namespace std;
#include <queue>
void test01()
queue<int> que;
que.push(1); // 元素 1 入队
que.push(2); // 元素 2 入队
que.push(3); // 元素 3 入队
que.push(4); // 元素 4 入队
cout << "队头元素为：" << que.front() << endl;
cout << "队尾元素为：" << que.back() << endl;
que.pop(); // 出队 -> 元素 1
que.pop(); // 出队 -> 元素 2
cout << "队头元素为：" << que.front() << endl;
cout << "队尾元素为：" << que.back() << endl;
que.pop(); // 出队 -> 元素 3
que.pop(); // 出队 -> 元素 4
cout << "队列元素为：" << que.size() << endl;
int main()
test01();
system("pause");
return 0;
Python版本
from collections import deque
def test01():
que = deque()
que.append(1) # 元素 1 入队
que.append(2) # 元素 2 入队
que.append(3) # 元素 3 入队
que.append(以上是关于LeetCode刷题--点滴记录004的主要内容，如果未能解决你的问题，请参考以下文章