1.二维数组相乘(n*n)
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n;
cout << "请输入数组维度:";
cin >> n;
vector<vector<int>> c(n);
vector<vector<int>> b(n);
vector<vector<int>> a(n);
for (int i = 0; i < n; i++)
{
c[i].resize(n);
b[i].resize(n);
a[i].resize(n);
}
cout << "请输入数组a:";
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> a[i][j];
}
}
cout << "请输入数组b:";
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> b[i][j];
}
}
cout << "结果是:" << endl;
for (int i = 0; i < n; ++i)
{
cout << "[";
for (int j = 0; j < n; j++)
{
for (int k = 0; k < n; k++)
{
c[i][j] += a[i][k] * b[k][j];
}
cout << c[i][j] << " ";
}
cout << "]" << endl;
}
system("pause");
}
2.两数相加
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* head = new ListNode(0);
ListNode* cur = head;
int sum = 0;
int carry = 0;
while(l1 != NULL || l2 != NULL){
sum = 0;
int x,y;
if(l1 != NULL){
//sum += l1->val;
//l1 = l1 -> next;
x=(l1->val);
l1=l1->next;
}
else
{
x=0;
}
if(l2 != NULL){
//sum += l2->val;
//l2 = l2 -> next;
y=(l2->val);
l2=l2->next;
}
else{
y=0;
}
sum=x+y;
if(carry)
{
sum++;
}
cur -> next = new ListNode(sum%10);
cur = cur -> next;
carry = sum >= 10 ? 1: 0;
}
if(carry)
cur -> next = new ListNode(1);
return head -> next;
}
};
3.无重复字符的最长子串
class Solution {
public:
int lengthOfLongestSubstring(string s) {
int m=0;
int j;
int max=0;
for(int i=0;i<s.size();i++)
{
for(j=m;j<i;j++)
{
if(s[j]==s[i])
{
m=j+1;
break;
}
}
if(i-m+1>max) max=i-m+1;
}
return max;
}
};
4.最长回文子串
暴力法1:
class Solution {
public:
string longestPalindrome(string s) {
if(s.empty()) return "";
if(s.size()==1) return s;
int maxnum=1;
int start=0;
for(int i=0;i<s.size();i++){
for(int j=i+1;j<s.size();j++)
{
int temp1,temp2;
for(temp1=i,temp2=j;temp1<temp2;temp1++,temp2--)
{
if(s[temp1]!=s[temp2])
break;
}
if(temp1>=temp2&&j-i+1>maxnum)
{
maxnum=j-i+1;
start=i;
}
}
}
return s.substr(start,maxnum);
}
};
暴力法2:
class Solution {
public:
string longestPalindrome(string s) {
string temp;
string result; //存放结果
string res; //存放翻转后的字符串
for (int i = 0; i < s.length(); i++)
{
for (int j = i; j < s.length(); j++)
{
temp += s[j];
res = temp;
reverse(res.begin(), res.end());
if (res == temp)
{
result = result.size() > res.size() ? result : res;
}
}
temp="";
}
return result;
}
};
动态规划:
class Solution {
public:
string longestPalindrome(string s) {
int len=s.size();
int max=1,start;
if(len==0||len==1) return s;
vector<vector<int>> dp(len,vector<int>(len));
for(int i=0;i<len;i++) {
dp[i][i]=1;
if(i<len-1&&s[i]==s[i+1]) {
dp[i][i+1]=1;
max=2;
start=i;
}
}
for(int l=3;l<=len;l++) {
for(int i=0;i<len-l+1;i++) {
int j=l+i-1;
if(s[i]==s[j]&&dp[i+1][j-1]) {
dp[i][j]=1;
max=l;
start=i;
}
}
}
return s.substr(start,max);
}
};
5.有效的括号数
class·Solution·{
public:
····bool·isValid(string·s)·{
········stack<char>·cc;
········if(s=="")·return·true;
········for(auto·i:s)
········{
············if(i=='('||i=='['||i=='{')··cc.push(i);
············else·
············{
················if(cc.size()==0&&(i==')'||i==']'||i=='}'))···return·false;
················else·if(i==')'&&cc.top()!='('||i==']'&&cc.top()!='['||i=='}'&&cc
················else·cc.pop();
············}
············
········}
········if(cc.size()==0)·return·true;
············else··return·false;
················
····}
};
6.两个有序链表的拼接
a.递归的方式
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if(l1 == NULL) return l2;
else if(l2 == NULL) return l1;
if(l1->val < l2->val) {
l1->next = mergeTwoLists(l1->next, l2);
return l1;
}
else {
l2->next = mergeTwoLists(l2->next, l1);
return l2;
}
}
};
b.普通的比较方式
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* prehead = new ListNode(-1);
ListNode* prev = prehead;
while(l1 != NULL && l2 != NULL) {
if(l1->val <= l2->val) {
prev->next = l1;
l1 = l1->next;
} else {
prev->next = l2;
l2 = l2->next;
}
prev = prev->next;
}
prev->next = l1 != NULL ? l1 : l2;
return prehead->next;
}
};
7.删除排序中的重复项
双指针法,双指针逼近。。
int removeDuplicates(vector<int>& nums) {
if (nums.size() < 2) return nums.size();
int j = 0;
for (int i = 1; i < nums.size(); i++)
if (nums[j] != nums[i]) nums[++j] = nums[i];
return ++j;
}