算法——简单算法的实现

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;
}