面试题—小算法30题

1、和为S的连续正数序列

Java实现：

package com.mian.algorithm;

import java.util.ArrayList;

public class FindContinuousSequence {
    public static void main(String[] args) {
        FindContinuousSequence continuousSequence=new FindContinuousSequence();
        ArrayList<ArrayList<Integer>> list=continuousSequence.findContinuousSequence(100);
        for(int i=0;i<list.size();++i){
            for(int j=0;j<list.get(i).size();++j){
                System.out.print(list.get(i).get(j)+" ");
            }
            System.out.println();
        }
    }
    private ArrayList<ArrayList<Integer>> findContinuousSequence(int sum){
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
        if(sum<=1){
            return res;
        }
        int start=1;
        int end=2;
        while(start!=(1+sum)/2){
            int curSum=(start+end)*(end-start+1)/2;
            if(curSum==sum){
                ArrayList<Integer> list=new ArrayList<Integer>();
                for(int i=start;i<=end;++i){
                    list.add(i);
                }
                res.add(list);
                ++start;
                ++end;
            }else if(curSum<sum){
                ++end;
            }else{
                ++start;
            }
        }
        return res;
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

vector<vector<int>> findContinuousSequence(int sum)
{
    vector<vector<int>> res;
    if (sum <= 1)
        return res;
    int start = 1;
    int end = 2;
    while (start != (1 + sum) / 2)
    {
        int curSum = (start + end)*(end - start + 1) / 2;
        if (curSum == sum)
        {
            vector<int> tmp;
            for (int i = start; i <= end; ++i)
                tmp.push_back(i);
            res.push_back(tmp);
            tmp.clear();
            ++start;
            ++end;
        }
        else if (curSum < sum)
            ++end;
        else
            ++start;
    }
    return res;
}

int main()
{
    vector<vector<int>> res = findContinuousSequence(100);
    for (int i = 0; i < res.size(); ++i)
    {
        for (int j = 0; j < res[i].size(); ++j)
            cout << res[i][j] << " ";
        cout << endl;
    }

    return 0;
}

2、如何判断一个链表是否有环，如果有环，则返回第一个进入环的节点，没有则返回null。
第一步，找环中相汇点。分别用p1，p2指向链表头部，p1每次走一步，p2每次走二步，直到p1==p2找到在环中的相汇点。
第二步，找环的入口。接上步，当p1==p2时，p2所经过节点数为2x,p1所经过节点数为x,设环中有n个节点,p2比p1多走一圈，有2x=n+x;n=x; 可以看出p1实际走了一个环的步数，再让p2指向链表头部，p1位置不变，p1,p2每次走一步直到p1==p2; 此时p1指向环的入口。

Java实现：

package com.mian.algorithm;

import java.util.Scanner;

class ListNode{
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int x){
        this.val=x;
        this.next=null;
    }
}

public class GetLoopNode {
    public static void main(String[] args){
        GetLoopNode getLoopNode=new GetLoopNode();
        ListNode head=getLoopNode.createList();
        getLoopNode.printList(head);
        ListNode p=head.next.next;
        ListNode last=head;
        while(last.next!=null){
            last=last.next;
        }
        last.next=p;
        ListNode node=getLoopNode.getLoopNode(head);
        System.out.println(node.val);
    }
    private ListNode getLoopNode(ListNode head){
        if(head==null||head.next==null||head.next.next==null){
            return null;
        }
        ListNode slow=head;
        ListNode fast=head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){
                fast=head;
                while(slow!=fast){
                    slow=slow.next;
                    fast=fast.next;
                }
                return slow;
            }
        }
        return null;
    }
    private void printList(ListNode head){
        if(head==null){
            return;
        }
        ListNode p=head;
        while(p.next!=null){
            System.out.print(p.val+" ");
            p=p.next;
        }
        System.out.println(p.val);
    }
    private ListNode createList(){
        int val;
        ListNode head=null;
        System.out.println("enter list value (enter 100 to quit):");
        Scanner sc=new Scanner(System.in);
        val=sc.nextInt();
        if(val==100){
            return head;
        }else{
            head=new ListNode(val);
            head.next=createList();
        }
        return head;
    }
}

C++实现：

#include<iostream>

using namespace std;

class ListNode
{
public:
    int val;
    ListNode* next;
    ListNode() {}
    ListNode(int x) :val(x), next(nullptr) {}
};

ListNode* createNode()
{
    int in;
    ListNode* head = nullptr;
    cout << "enter list value (enter 100 to quit):";
    cin >> in;
    if (in == 100)
        return head;
    else
    {
        head = new ListNode(in);
        head->next = createNode();
    }
    return head;
}

void printList(ListNode* head)
{
    if (head == nullptr)
        return;
    ListNode* p = head;
    while (p)
    {
        cout << p->val << " ";
        p = p->next;
    }
    cout << endl;
}

ListNode* getLoopNode(ListNode* head)
{
    if (!head || !head->next || !head->next->next)
        return head;
    ListNode* n1 = head->next;
    ListNode* n2 = head->next->next;
    while (n1 != n2)
    {
        if (!n1->next || !n2->next->next)
            return nullptr;
        n1 = n1->next;
        n2 = n2->next->next;
    }
    n2 = head;
    while (n1 != n2)
    {
        n1 = n1->next;
        n2 = n2->next;
    }
    return n1;
}

int main()
{
    ListNode* head = createNode();
    printList(head);
    ListNode* p = head->next->next;
    ListNode* last = head;
    while (last->next)
        last = last->next;
    last->next = p;
    cout << getLoopNode(head)->val << endl;

    return 0;
}

3、回文字符串

Java实现：

package com.mian.algorithm;

public class IsPalindrome {
    public static void main(String[] args) {
        String str="abceda";
        String str2="";
        String str3="abdba";
        boolean flag=isPalindrome(str3);
        System.out.println(flag);
    }
    private static boolean isPalindrome(String str){
        int size=str.length();
        if(size==0||str.isEmpty()){
            return false;
        }
        int i=0;
        while(i<size/2){
            if(str.charAt(i)!=str.charAt(size-i-1)){
                return false;
            }
            ++i;
        }
        return true;
    }
}

C++实现：

#include<iostream>
#include<string>

using namespace std;

bool isPalindrome(string &str)
{
    int size = str.size();
    if (size == 0 || str.empty())
        return false;
    int i = 0;
    while (i < size / 2)
    {
        if (str[i] != str[size - i - 1])
            return false;
        ++i;
    }
    return true;
}

int main()
{
    string str = "abceba";
    cout << isPalindrome(str) << endl;

    return 0;
}

4、不使用循环，判断一个数是否是2的N次方
凡是2的N次方的整数，其二进制码只有一个1

Java实现：

package com.mian.algorithm;

public class Is2N {
    public static void main(String[] args) {
        boolean flag=is2N(16);
        System.out.println(flag);
    }
    private static boolean is2N(int n){
        if((n>0)&&((n&(n-1))==0)){
            return true;
        }
        return false;
    }
}

C++实现：

bool is2N(int n)
{
    if ((n > 0) && ((n&(n - 1)) == 0))
        return true;
    return false;
}

5、求1!+2!+3!+4!+...+n!的结果。

Java实现：

package com.mian.algorithm;

public class JieChengHe {
    public static void main(String[] args){
        int res=jieChengHe(4);
        System.out.println(res);
        System.out.println(jieChengHeNoRec(4));
    }
    private static long jieChengHeNoRec(int n){
        long sum=0,num=1;
        for(int i=1;i<=n;++i){
            num*=i;
            sum+=num;
        }
        return sum;
    }
    private static int jieChengHe(int n){
        if(n==1){
            return 1;
        }
        return jieChengHe(n-1)+jieCheng(n);
    }
    private static int jieCheng(int n){
        if(n==1){
            return 1;
        }
        return jieCheng(n-1)*n;
    }
}

C++实现：

int jieCheng(int n)
{
    if (n == 1)
        return 1;
    return n*jieCheng(n - 1);
}

int jieChengHe(int n)
{
    if (n == 1)
        return 1;
    return jieChengHe(n - 1) + jieCheng(n);
}

6、N的阶乘末尾有多少个0
分析：N的阶乘可以分解为： 2的X次方，3的Y次方，4的K次方，5次Z方，.....的乘积。由于10 = 2 * 5,所以M只能和X和Z有关，每一对2和5相乘就可以得到一个10，于是M = MIN(X,Z),不难看出X大于Z，因为被2整除的频率比被5整除的频率高的多。所以可以把公式简化为M=Z。

Java实现：

package com.mian.algorithm;

public class JieChengLastZero {
    public static void main(String[] args) {
        int res=jieChengLastZero(10);
        System.out.println(res);
    }
    private static int jieChengLastZero(int n){
        if(n<0){
            return 0;
        }
        int res=0;
        for(int i=5;i<=n;++i){
            int j=i;
            while(j%5==0){
                ++res;
                j=j/5;
            }
        }
        return res;
    }
}

C++实现：

int  jieChengLastZero(int n)
{
    if (n < 0)
        return;
    int res = 0;
    for (int i = 5; i <= n; ++i)
    {
        int j = i;
        while (j % 5 == 0)
        {
            ++res;
            j = j / 5;
        }
    }
    return res;
}

7、在字符串中求最长数字子序列的长度

Java实现：

package com.mian.algorithm;

public class LongestNumSubString {
    public static void main(String[] args){
        String str="ad3299adfa3239028903afd";
        System.out.println(longestNumSubString(str));
    }
    private static int longestNumSubString(String str){
        int size=str.length();
        if(size==0||str.isEmpty()){
            return 0;
        }
        int cnt=0;
        int num=0;
        for(int i=0;i<size;++i){
            if(isNumber(str.charAt(i))){
                ++cnt;
                if(cnt>num){
                    num=cnt;
                }
            }else{
                cnt=0;
            }
        }
        return num;
    }
    private static boolean isNumber(char c){
        int n=c-48;
        if(n>=0&&n<=9){
            return true;
        }
        return false;
    }
}

C++实现：

bool isNumber(char c)
{
    int d = c - 48;
    if (d >= 0 && d <= 9)
        return true;
    return false;
}

int longestNumSubString(string &str)
{
    int size = str.size();
    if (str.empty() || size == 0)
        return 0;
    int max = 0;
    int cnt = 0;
    for (int i = 0; i < size; ++i)
    {
        if (isNumber(str[i]))
        {
            cnt++;
            if (cnt > max)
                max = cnt;
        }
        else
            cnt = 0;
    }
    return max;
}

 8、最长递增子序列

Java实现：

package com.mian.algorithm;

public class LongestSequence {
    public static void main(String[] args) {
        int[] arr={ 4,1,2,5,0,3,6,8 };
        int[] res=longestSequence(arr);
        for(int i=0;i<res.length;++i){
            System.out.print(res[i]+" ");
        }
    }
    private static int[] longestSequence(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return null;
        }
        // 记录当前各元素作为最大元素的最长递增序列长度
        int[] maxLen=new int[size];
        // 记录当前以该元素作为最大元素的递增序列中该元素的前驱节点，用于打印序列用
        int[] pre=new int[size];
        for(int i=0;i<size;++i){
            maxLen[i]=1;
            pre[i]=i;
        }
        int k=0;
        int m=1;
        for(int i=0;i<size;++i){
            for(int j=0;j<i;++j){
                if(arr[j]<arr[i]&&maxLen[j]+1>maxLen[i]){
                    maxLen[i]=maxLen[j]+1;
                    pre[i]=j;
                }
                if(m<maxLen[i]){
                    m=maxLen[i];
                    k=i;
                }
            }
        }
        int i=m-1;
        int[] res=new int[m];
        while(pre[k]!=k){
            res[i--]=arr[k];
            k=pre[k];
        }
        res[i]=arr[k];
        return res;
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

vector<int> longestSequence(vector<int> &arr)
{
    int size = arr.size();
    if (arr.empty() || size == 0)
        return vector<int>();
    // 记录当前各元素作为最大元素的最长递增序列长度
    vector<int> maxLen(size);
    // 记录当前以该元素作为最大元素的递增序列中该元素的前驱节点，用于打印序列用
    vector<int> pre(size);
    for (int i = 0; i < size; ++i)
    {
        maxLen[i] = 1;
        pre[i] = i;
    }
    int k = 0;
    int max = 1;
    for (int i = 1; i < size; ++i)
    {
        // 找到以array[i]为最末元素的最长递增子序列
        for (int j = 0; j < i; ++j)
        {
            //如果求非递减子序列只需将array[j] < array[i]改成<=，如果要求递减子序列只需改为>
            if (arr[j]<arr[i] && maxLen[j] + 1>maxLen[i])
            {
                maxLen[i] = maxLen[j] + 1;
                pre[i] = j;
            }
            if (max < maxLen[i])
            {
                max = maxLen[i];
                k = i;
            }
        }
    }
    int i = max - 1;
    vector<int> res(max);
    while (pre[k] != k)
    {
        res[i--] = arr[k];
        k = pre[k];
    }
    res[i] = arr[k];
    return res;
}

int main()
{
    vector<int> arr{ 4,1,2,5,0,3,6,8 };
    vector<int> res = longestSequence(arr);
    for (int i = 0; i < res.size(); ++i)
        cout << res[i] << " ";
    cout << endl;

    return 0;
}

9、最长连续递增子序列的长度

Java实现：

package com.mian.algorithm;

public class LongestSerialSequence {
    public static void main(String[] args) {
        int[] arr={ 4,1,2,5,0,3,6,8 };
        System.out.println(longestSerialSequence(arr));
    }
    private static int longestSerialSequence(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return 0;
        }
        int curLen=1;
        int resLen=1;
        for(int i=1;i<size;++i){
            if(arr[i-1]<arr[i]){
                ++curLen;
                if(curLen>resLen){
                    resLen=curLen;
                }
            }else{
                curLen=1;
            }
        }
        int cur=1;
        for(int i=size-1;i>0;--i){
            if(arr[i]<arr[i-1]){
                ++cur;
                if(cur>resLen){
                    resLen=cur;
                }
            }else{
                cur=1;
            }
        }
        return resLen;
    }
}

C++实现：

int longestSerialSequence(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return -1;
    int curLen = 1;
    int resLen = 1;
    for (int i = 1; i < size; ++i)
    {
        if (arr[i] > arr[i - 1])
            curLen++;
        else
            curLen = 1;
        if (curLen > resLen)
            resLen = curLen;
    }
    curLen = 1;
    for (int i = size - 1; i >= 1; --i)
    {
        if (arr[i] < arr[i - 1])
            curLen++;
        else
            curLen = 1;
        if (curLen > resLen)
            resLen = curLen;
    }
    return resLen;
}

10、打印最长连续递增子序列

Java实现：

package com.mian.algorithm;

public class PrintLongestSerialSequence {
    public static void main(String[] args) {
        int[] arr={ 4,1,2,5,0,3,6,8 };
        printLongestSerialSequence(arr);
    }
    private static void printLongestSerialSequence(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        int curLen=1;
        int resLen=1;
        int index=0;
        for(int i=1;i<size;++i){
            if(arr[i]>arr[i-1]){
                ++curLen;
                if(curLen>resLen){
                    resLen=curLen;
                    index=i;
                }
            }else{
                curLen=1;
            }
        }
        int i=index-resLen+1;
        while(resLen!=0){
            System.out.print(arr[i]+" ");
            ++i;
            --resLen;
        }
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void longestSerialSequence(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    int curLen = 1;
    int resLen = 1;
    int index = 0;
    for (int i = 1; i < size; ++i)
    {
        if (arr[i] > arr[i - 1])
        {
            curLen++;
            index = i;
        }
        else
            curLen = 1;
        if (curLen > resLen)
            resLen = curLen;
    }
    int i = index - resLen + 1;
    while (resLen)
    {
        cout << arr[i] << " ";
        ++i;
        --resLen;
    }
    cout << endl;
}

int main()
{
    vector<int> kk = { 2, 13, 6, 8, 9, 1 };
    longestSerialSequence(kk);

    return 0;
}

11、最小的K个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

Java实现：

package com.mian.algorithm;

public class FindLowestK {
    public static void main(String[] args) {
        int[] arr={ 4, 5, 1, 6, 2, 7, 3, 8 };
        FindLowestK fk=new FindLowestK();
        int[] res=fk.findLowestK(arr,3);
        fk.printArray(res);
        int[] part=fk.findLowestKP(arr,3);
        fk.printArray(part);
    }
    //方法一：最大堆 时间复杂度O（nlogk）
    private int[] findLowestK(int[] arr,int k){
        int size=arr.length;
        if(size==0||arr==null||size<k||k<=0){
            return null;
        }
        int[] res=new int[k];
        for(int i=0;i<k;++i){
            res[i]=arr[i];
        }
        heapSort(res);
        for(int i=k;i<size;++i){
            if(res[k-1]>arr[i]){
                res[k-1]=arr[i];
                heapSort(res);
            }
        }
        return res;
    }
    private void heapSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=size/2-1;i>=0;--i){
            adjustMaxHeap(arr,i,size);
        }
        for(int i=size-1;i>0;--i){
            swap(arr,0,i);
            adjustMaxHeap(arr,0,--size);
        }
    }
    private void adjustMaxHeap(int[] arr,int i,int size){
        int left=2*i+1;
        int right=2*i+2;
        int largest=i;
        if(left<size&&arr[left]>arr[largest]){
            largest=left;
        }
        if(right<size&&arr[right]>arr[largest]){
            largest=right;
        }
        if(largest!=i){
            swap(arr,i,largest);
            adjustMaxHeap(arr,largest,size);
        }
    }
    private void swap(int[] arr,int i,int j){
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp;
    }
    //方法二：Partiton思想 时间复杂度O(n)
    private int[] findLowestKP(int[] arr,int k){
        int size=arr.length;
        if(size==0||arr==null){
            return null;
        }
        int low=0;
        int high=size-1;
        int index=partition(arr,low,high);
        while(index!=(k-1)){
            if(index>(k-1)){
                high=index-1;
                index=partition(arr,low,high);
            }else if(index<(k-1)){
                low=index+1;
                index=partition(arr,low,high);
            }
        }
        int[] res=new int[k];
        System.arraycopy(arr,0,res,0,k);
        return res;
    }
    private int partition(int[] arr,int low,int high){
        int pivot=arr[low];
        while(low<high){
            while(low<high&&arr[high]>=pivot){
                --high;
            }
            arr[low]=arr[high];
            while(low<high&&arr[low]<=pivot){
                ++low;
            }
            arr[high]=arr[low];
        }
        arr[low]=pivot;
        return low;
    }
    private void printArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[size-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>
#include<multiset>

using namespace std;

//方法一：最大堆 时间复杂度O（nlogk）
void swap(vector<int> &arr, int i, int j)
{
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

void adjustMaxHeap(vector<int> &arr, int i, int size)
{
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    int largest = i;
    if (left<size&&arr[left]>arr[largest])
        largest = left;
    if (right<size&&arr[right]>arr[largest])
        largest = right;
    if (largest != i)
    {
        swap(arr, largest, i);
        adjustMaxHeap(arr, largest, size);
    }
}

void heapSort(vector<int> &arr)
{
    int size = arr.size();
    if (arr.empty() || size == 0)
        return;
    for (int i = size / 2 - 1; i >= 0; --i)
        adjustMaxHeap(arr, i, size);
    for (int j = size - 1; j > 0; --j)
    {
        swap(arr, 0, j);
        adjustMaxHeap(arr, 0, --size);
    }
}

vector<int> findLowestK(vector<int> &arr, int k)
{
    int size = arr.size();
    if (arr.empty() || size == 0 || size < k || k <= 0)
        return vector<int>();
    vector<int> res(k);
    /*
    vector<int>::iterator it = arr.begin();
    copy(it, it+k,res);
    */
        for (int i = 0; i < k; ++i)
            res[i] = arr[i];
        heapSort(res);
        for (int i = k; i < size; ++i)
            if (arr[i] < res[k - 1])
            {
                res[k - 1] = arr[i];
                heapSort(res);
            }
    return res;
}

//方法二：Partiton思想 时间复杂度O(n)
int partition(vector<int> &arr, int low, int high)
{
    int pivot = arr[low];
    while (low < high)
    {
        while (low < high&&pivot <= arr[high])
            --high;
        arr[low] = arr[high];
        while (low < high&&pivot >= arr[low])
            ++low;
        arr[high] = arr[low];
    }
    arr[low] = pivot;
    return low;
}
vector<int> findLowestK2(vector<int> &arr, int k)
{
    int size = arr.size();
    if (size == 0 || arr.empty() || size < k || k <= 0)
        return vector<int>();
    int low = 0;
    int high = size - 1;
    int index = partition(arr, low, high);
    while (index != (k - 1))
    {
        if (index > (k - 1))
        {
            high = index - 1;
            partition(arr, low, high);
        }
        else
        {
            low = index + 1;
            partition(arr, low, high);
        }
    }
    return vector<int>(arr.begin(), arr.begin() + k);
}
//方法三：红黑树：multiset集合  利用仿函数改变排序顺序 时间复杂度O（nlogk）
vector<int> findLowestK3(vector<int> &arr, int k)
{
    int size = arr.size();
    if (size <= 0 || size < k || k <= 0)
        return vector<int>();
    //仿函数中的greater<T>模板，从大到小排序
    multiset<int, greater<int> > leastNums;
    vector<int>::iterator vec_it = input.begin();
    for (; vec_it != input.end(); vec_it++)
    {
        //将前k个元素插入集合
        if (leastNums.size()<k)
            leastNums.insert(*vec_it);
        else
        {
        //第一个元素是最大值
        multiset<int, greater<int> >::iterator greatest_it = leastNums.begin();
        //如果后续元素<第一个元素，删除第一个，加入当前元素
            if (*vec_it<*(leastNums.begin()))
            {
                leastNums.erase(greatest_it);
                leastNums.insert(*vec_it);
            }
    }
}

    return vector<int>(leastNums.begin(), leastNums.end());
}

int main()
{
    vector<int> ay = { 4, 5, 1, 6, 2, 7, 3, 8 };
    vector<int> fi = findLowestK(ay, 4);
    for (int i = 0; i < fi.size(); ++i)
        cout << fi[i] << " ";
    cout << endl;
    vector<int> fi2 = findLowestK2(ay, 4);
    for (int i = 0; i < fi2.size(); ++i)
        cout << fi[i] << " ";
    cout << endl;
    vector<int> fi3 = findLowestK3(ay, 4);
    for (int i = 0; i < fi3.size(); ++i)
        cout << fi[i] << " ";
    cout << endl;

    return 0;
}

12、没有优先级的"+","-","x"

Java实现：

package com.mian.algorithm;

import java.util.Scanner;

public class NoPriority {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        int res=noPriority(str);
        System.out.println(res);
    }
    private static int noPriority(String str){
        int size=str.length();
        if(size==0||str.isEmpty()){
            return 0;
        }
        int res=str.charAt(0)-'0';
        for(int i=1;i<size;++i){
            int cur=str.charAt(i)-'0';
            if(cur>=0&&cur<=9){
                char pre=str.charAt(i-1);
                if(pre=='+'){
                    res+=cur;
                }else if(pre=='-'){
                    res-=cur;
                }else if(pre=='*'){
                    res*=cur;
                }
            }
        }
        return res;
    }
}

C++实现：

#include<iostream>
#include<string>

using namespace std;

void noPriority()
{
    cout << "Enter a string:";
    string str;
    cin >> str;
    int size = str.size();
    if (str.empty()|| size == 0)
        return;
    int res = str[0] - '0';
    for (int i = 1; i < size; i++) {
        int cur = str[i] - '0';
        if (0 <= cur && cur <= 9) {
            char pre = str[i-1];
            if (pre == '+') {
                res += cur;
            }
            else if (pre == '-') {
                res -= cur;
            }
            else {
                res *= cur;
            }
        }
    }
    cout << res << endl;
}

int main()
{
    noPriority();

    return 0;
}

13、在不使用循环的条件下，如何计算出一个数其2的n次方的最大数字（这个比较绕，例如17-->16，31-- >16）。

Java实现：

package com.mian.algorithm;

public class Max2N {
    public static void main(String[] args) {
        System.out.println(max2N(31));
    }
    private static int max2N(int n){
        if((n>0)&&(n&(n-1))==0){
            return n;
        }
        return max2N(n-1);
    }
}

C++实现：

#include<iostream>

using namespace std;

int max2N(int n)
{
    if ((n > 0) && (n&(n - 1)) == 0)
        return n;
    return max2N(n - 1);
}

int main()
{
    cout << max2N(31) << endl;

    return 0;
}

14、未排序数组中累加和为给定值的最长子数组的长度

Java实现：

package com.mian.algorithm;

import java.util.HashMap;

public class MaxLength {
    public static void main(String[] args) {
        int[] arr={ 1,2,1,1,1 };
        int target=3;
        System.out.println(maxLength(arr,target));
        System.out.println(maxLength2(arr,target));
    }

    /**
     * 0到位置i的累加和我们用sum[0~i]，存在j使得sum[0~j] - sum[0~i] = k，则k = sum[i+1~j]
     * 补充题目1：给定一个无序数组 arr，其中元素可正、可负、可 0。
     * 求 arr 所有的子数组中正数与负数个数相等的最长子数组长度。
     * 要求：时间复杂度 O(N)
     * 分析：将数组中的正数变成1，负数变成-1,零仍然为零。然后求累加和为0的最长子数组，
     * 这样就将这个问题转化成未排序数组中累加和为给0的最长子数组问题了。
     * 补充题目2：给定一个无序数组 arr，其中元素只是 1 或 0。求 arr 所有的子数组中 0 和 1 个 数相等的最长子数组长度。
     * 要求：时间复杂度 O(N)
     * 分析：将数组中的0变成-1,1仍然为1，求累加和为0的最长子数组，可以求出1和-1个数相同，代表着0和1个数相同。
     *
     * 方法一：
     */
    private static int maxLength(int[] arr,int target){
        int size=arr.length;
        if(size==0||arr==null){
            return 0;
        }
        HashMap<Integer,Integer> map=new HashMap<>();
        map.put(0,-1);
        int len=0;
        int sum=0;
        for(int i=0;i<size;++i){
            sum+=arr[i];
            if(map.containsKey(sum-target)){
                len=(i-map.get(sum-target))>len?(i-map.get(sum-target)):len;
            }
            if(!map.containsKey(sum)){
                map.put(sum,i);
            }
        }
        return len;
    }
    /**
     * 方法二：使用两个指针left和right,记录从left到right之间的元素的值得和，使用一个变量len记录长度。
     * 如果这个和大于目标，那么left加1，如果这个和小于目标，那么right加1,如果这个值等于目标，那么比较并更新len，
     * 同时left++。right超过最右边的时候结束循环。
     */
    private static int maxLength2(int[] arr,int target){
        int size=arr.length;
        if(size==0||arr==null){
            return 0;
        }
        int left=0;
        int right=0;
        int len=0;
        int sum=0;
        while(right<size){
            if(sum<target){
                ++right;
                if(right==size){
                    break;
                }
                sum+=arr[right];
            }else if(sum>target){
                sum+=arr[left++];
            }else{
                len=Math.max(len,right-left+1);
                sum-=arr[left++];
            }
        }
        return len;
    }
}

C++实现：

0到位置i的累加和我们用sum[0~i]，存在j使得sum[0~j] - sum[0~i] = k，则k = sum[i+1~j]
补充题目1：给定一个无序数组 arr，其中元素可正、可负、可 0。求 arr 所有的子数组中正数与负数个数相等的最长子数组长度。
要求：时间复杂度 O(N)
分析：将数组中的正数变成1，负数变成-1,零仍然为零。然后求累加和为0的最长子数组，这样就将这个问题转化成未排序数组中累加和为给0的最长子数组问题了。
补充题目2：给定一个无序数组 arr，其中元素只是 1 或 0。求 arr 所有的子数组中 0 和 1 个 数相等的最长子数组长度。
要求：时间复杂度 O(N)
分析：将数组中的0变成-1,1仍然为1，求累加和为0的最长子数组，可以求出1和-1个数相同，代表着0和1个数相同。

方法一：

#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>

using namespace std;

int maxLength(vector<int> &arr, int target)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return 0;
    unordered_map<int, int> m;
    m[0] = -1;
    int len = 0;
    int sum = 0;
    for (int i = 0; i < size; ++i)
    {
        sum += arr[i];
        auto it = m.find(sum - target);
        if (it != m.end())
            len = (i - m[sum - target]) > len ? (i - m[sum - target]) : len;
        auto p = m.find(sum);
        if (p == m.end())
            m[sum] = i;
    }
    return len;
}

int main()
{
    vector<int> arr = { 1,2,1,1,1 };
    int target = 3;
    cout << maxLength(arr, target) << endl;

    return 0;
}

方法二：使用两个指针left和right,记录从left到right之间的元素的值得和，使用一个变量len记录长度。如果这个和大于目标，那么left加1，如果这个和小于目标，那么right加1,如果这个值等于目标，那么比较并更新len，同时left++。right超过最右边的时候结束循环。

#include<iostream>
#include<vector>
#include<unordered_map>
#include<algorithm>

using namespace std;

int maxLen(vector<int> &arr, int target)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return 0;
    int left = 0, right = 0;
    int sum = 0;
    int len = 0;
    while (right < size)
    {
        if (sum < target)
        {
            ++right;
            if (right == size)
                break;
            sum += arr[right];
        }
        else if (sum > target)
            sum += arr[left++];
        else
        {
            len = max(len, right - left + 1);
            sum -= arr[left++];
        }
    }
    return len;
}

int main()
{
    vector<int> arr = { 1,2,1,1,1 };
    int target = 3;
    cout << maxLen(arr, target) << endl;

    return 0;
}

15、连续子序列的最大和

Java实现：

package com.mian.algorithm;

public class MaxSum {
    public static void main(String[] args) {
        int[] arr={ 6,-3,-2,7,-15,1,2,2 };
        System.out.println(maxSum(arr));
        System.out.println(maxSum2(arr));
    }

    /**
     * 方法一：连续子序列的最大和只可能是以位置0～n-1中某个位置结尾。当遍历到第i个元素时，
     * 判断在它前面的连续子序列和是否大于0，如果大于0，则以位置i结尾的最大连续子序列和为元素i和前门的连续子序列和相加；
     * 否则，则以位置i结尾的最大连续子序列和为元素i。
     */
    private static int maxSum(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return 0;
        }
        int curSum=arr[0];
        int maxSum=arr[0];
        for(int i=1;i<size;++i){
            if(curSum<0){
                curSum=arr[i];
            }else{
                curSum+=arr[i];
            }
            if(curSum>maxSum){
                maxSum=curSum;
            }
        }
        return maxSum;
    }
    /**
     * 方法二：暴力解。时间复杂度O(n^2)，空间复杂度O(1)。
     */
    private static int maxSum2(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return 0;
        }
        int maxSum=Integer.MIN_VALUE;
        for(int i=0;i<size;++i){
            int curSum=0;
            for(int j=i;j<size;++j){
                curSum+=arr[j];
                if(curSum>maxSum){
                    maxSum=curSum;
                }
            }
        }
        return maxSum;
    }
}

C++实现：

方法一：连续子序列的最大和只可能是以位置0～n-1中某个位置结尾。当遍历到第i个元素时，判断在它前面的连续子序列和是否大于0，如果大于0，则以位置i结尾的最大连续子序列和为元素i和前门的连续子序列和相加；否则，则以位置i结尾的最大连续子序列和为元素i。

#include<iostream>
#include<vector>

using namespace std;

int maxSum(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return -1;
    int max = arr[0];
    int cur = arr[0];
    for (int i = 1; i < size; ++i)
    {
        if (cur <= 0)
            cur = arr[i];
        else
            cur += arr[i];
        if (cur > max)
            max = cur;
    }
    return max;
}

int main()
{
    vector<int> arr = { 6,-3,-2,7,-15,1,2,2 };
    cout << maxSum(arr) << endl;

    return 0;
}

方法二：暴力解。时间复杂度O(n^2)，空间复杂度O(1)。

#include<iostream>
#include<vector>

using namespace std;

int maxSum(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return -1;
    int max = INT_MIN;
    for (int i = 0; i < size; ++i)
    {
        int sum = 0;
        for (int j = i; j < size; ++j)
        {
            sum += arr[j];
            if (sum > max)
                max = sum;
        }
    }
    return max;
}

int main()
{
    vector<int> arr = { 6,-3,-2,7,-15,1,2,2 };
    cout << maxSum(arr) << endl;

    return 0;
}

16、合并两个有序数组

Java实现：

package com.mian.algorithm;

public class MergeArray {
    public static void main(String[] args) {
        int[] arr1={ 0,3,5,6,7,9 };
        int[] arr2= { 2,3,4,7,8,9 };
        int[] res=mergeArray(arr1,arr2);
        printArray(res);
        int[] res2=mergeArray2(arr1,arr2);
        printArray(res2);
    }
    private static int[] mergeArray(int[] arr1,int[] arr2){
        int size1=arr1.length;
        int size2=arr2.length;
        if(size1==0||arr1==null){
            return arr2;
        }
        if(size2==0||arr2==null){
            return arr1;
        }
        if((size1==0&&size2==0)||(arr1==null&&arr2==null)){
            return null;
        }
        int i=0,j=0,k=0;
        int[] res=new int[size1+size2];
        while (i<size1&&j<size2){
            if(arr1[i]<arr2[j]){
                res[k++]=arr1[i++];
            }else{
                res[k++]=arr2[j++];
            }
        }
        while(i<size1){
            res[k++]=arr1[i++];
        }
        while(j<size2){
            res[k++]=arr2[j++];
        }
        return res;
    }
    private static int[] mergeArray2(int[] arr1,int[] arr2){
        int size1=arr1.length;
        int size2=arr2.length;
        if(size1==0||arr1==null){
            return arr2;
        }
        if(size2==0||arr2==null){
            return arr1;
        }
        if((size1==0&&size2==0)||(arr1==null&&arr2==null)){
            return null;
        }
        int i=0,j=0,k=0;
        int[] res=new int[size1+size2];
        while(i<size1&&j<size2){
            if(arr1[i]<arr2[j]){
                res[k++]=arr1[i++];
            }else if(arr1[i]>arr2[j]){
                res[k++]=arr2[j++];
            }else{
                res[k++]=arr1[i++];
                res[k++]=arr2[j++];
            }
        }
        while(i<size1){
            res[k++]=arr1[i++];
        }
        while(j<size2){
            res[k++]=arr2[j++];
        }
        return res;
    }
    private static void printArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[size-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

vector<int> mergeArray(vector<int> &arr1, vector<int> &arr2)
{
    int size1 = arr1.size();
    int size2 = arr2.size();
    if (size1 == 0 || size2 == 0 || arr1.empty() || arr2.empty())
        return vector<int>();
    vector<int> res(size1 + size2);
    int i = 0, j = 0, k = 0;
    while (i < size1&&j < size2)
    {
        if (arr1[i] < arr2[j])
            res[k++] = arr1[i++];
        else if (arr1[i] > arr2[j])
            res[k++] = arr2[j++];
        else
        {
            res[k++] = arr1[i++];
            res[k++] = arr2[j++];
        }
    }
    while (i < size1)
        res[k++] = arr1[i++];
    while (j < size2)
        res[k++] = arr2[j++];
    return res;
}

int main()
{
    vector<int> arr1 = { 0,3,5,6,7,9 };
    vector<int> arr2 = { 2,3,4,7,8,9 };
    vector<int> res = mergeArray(arr1, arr2);
    for (int i = 0; i < res.size(); ++i)
        cout << res[i] << " ";
    cout << endl;

    return 0;
}

17、旋转数组的最小数字

Java实现：

package com.mian.algorithm;

public class MinNumberInRotateArray {
    public static void main(String[] args) {
        int[] arr={1,0,1,1,1};
        System.out.println(minNumberInRotateArray(arr));
    }
    private static int minNumberInRotateArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return 0;
        }
        int low=0;
        int high=size-1;
        int mid=low;
        while(arr[low]>=arr[high]){
            if(high-low==1){
                mid=high;
                break;
            }
            mid=(low+high)>>1;
            if(arr[low]==arr[mid]&&arr[mid]==arr[high]){
                int min=arr[low];
                for(int i=low+1;i<=high;++i){
                    if(min>arr[i]){
                        min=arr[i];
                    }
                }
                return min;
            }else if(arr[low]>=arr[mid]){
                low=mid;
            }else if(arr[mid]<=arr[high]){
                high=mid;
            }
        }
        return arr[mid];
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

int minNumberInRotateArray(vector<int> arr) {
    int low = 0;
    int high = arr.size() - 1;
    int mid = low;
    while (arr[low] >= arr[high])
    {
        if (high - low == 1)
        {
            mid = high;
            break;
        }
        mid = (low + high) / 2;
        if (arr[low] == arr[mid] && arr[mid] == arr[high])
        {
            int min = arr[low];
            for (int i = low + 1; i <= high; ++i)
                if (min>arr[i])
                    min = arr[i];
            return min;
        }
        if (arr[mid] >= arr[low])
            low = mid;
        else if (arr[mid] <= arr[high])
            high = mid;
    }
    return arr[mid];
}

int main()
{
    vector<int> arr = {1,0,1,1,1};
    cout << minNumberInRotateArray(arr) << endl;

    return 0;
}

18、数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。
由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

Java实现：

package com.mian.algorithm;

import java.util.HashMap;

public class MoreHalf {
    public static void main(String[] args) {
        int[] arr={1,2,3,2,2,2,5,4,2};
        System.out.println(moreHalf(arr));
        System.out.println(moreHalf2(arr));
        System.out.println(moreHalf3(arr));
    }
    private static int moreHalf(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return Integer.MIN_VALUE;
        }
        int cnt=0;
        int res=0;
        for(int i=0;i<size;++i){
            if(cnt==0){
                res=arr[i];
                ++cnt;
            }else{
                if(res==arr[i]){
                    ++cnt;
                }else{
                    --cnt;
                }
            }
        }
        cnt=0;
        for(int i=0;i<size;++i){
            if(arr[i]==res){
                ++cnt;
            }
        }
        if(cnt>size/2){
            return res;
        }
        return Integer.MIN_VALUE;
    }
    private static int moreHalf2(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return Integer.MIN_VALUE;
        }
        int res=Integer.MIN_VALUE;
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<size;++i){
            if(map.containsKey(arr[i])){
                map.put(arr[i],map.get(arr[i])+1);
            }else{
                map.put(arr[i],1);
            }
            if(map.get(arr[i])>size/2){
                res=arr[i];
            }
        }
        int cnt=0;
        for(int i=0;i<size;++i){
            if(arr[i]==res){
                ++cnt;
            }
        }
        if(cnt>size/2){
            return res;
        }
        return Integer.MIN_VALUE;
    }
    private static int moreHalf3(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return Integer.MIN_VALUE;
        }
        int mid=size>>1;
        int low=0;
        int high=size-1;
        int index=partition(arr,low,high);
        while(index!=mid){
            if(index>mid){
                high=index-1;
                index=partition(arr,low,high);
            }else if(index<mid){
                low=index+1;
                index=partition(arr,low,high);
            }
        }
        int res=arr[mid];
        int cnt=0;
        for(int i=0;i<size;++i){
            if(arr[i]==res){
                ++cnt;
            }
        }
        if(2*cnt>size){
            return res;
        }else{
            return Integer.MIN_VALUE;
        }
    }
    private static int partition(int[] arr,int low,int high){
        int pivot=arr[low];
        while(low<high){
            while(low<high&&arr[high]>=pivot){
                --high;
            }
            arr[low]=arr[high];
            while(low<high&&arr[low]<=pivot){
                ++low;
            }
            arr[high]=arr[low];
        }
        arr[low]=pivot;
        return low;
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

int moreHalf(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return -1;
    int candi = 0;
    int cnt = 0;
    for (int i = 0; i < size; ++i)
    {
        if (cnt == 0)
        {
            candi = arr[i];
            ++cnt;
        }
        else
        {
            if (arr[i] == candi)
                ++cnt;
            else
                --cnt;
        }
    }
    return candi;
}

int main()
{
    vector<int> arr = { 8,0,2,3,1,2,2,1,2,2 };
    cout << moreHalf(arr) << endl;

    return 0;
}

19、某一范围内的整数包含1的数量

Java实现：

package com.mian.algorithm;

public class NumberOf1Between1AndN {
    public static void main(String[] args) {
        System.out.println(numberOf1Between1AndN(34278));
        System.out.println(numberOf1Between1AndN2(34278));
    }

    /**
     * 方法一：暴力解
     */
    private static int numberOf1Between1AndN(int n){
        if(n<0){
            return 0;
        }
        if(n<9){
            return 1;
        }
        int cnt=1;
        for(int i=10;i<=n;++i){
            int tmp=i;
            while(tmp!=0){
                if(tmp%10==1){
                    ++cnt;
                }
                tmp/=10;
            }
        }
        return cnt;
    }
    private static int numberOf1Between1AndN2(int n){
        int cnt = 0;
        for (int m = 1; m <= n; m *= 10){
            int a = n / m, b = n%m;
            if (a % 10 == 0){
                cnt+=a/10*m;
            }else if (a % 10 == 1) {
                cnt += a / 10 * m + (b + 1);
            }else{
                cnt += (a / 10 + 1)*m;
            }
        }
        return cnt;
    }
}

C++实现：

方法一：暴力解

#include<iostream>

using namespace std;

int NumberOf1Between1AndN(int n)
{
    if (n <= 0)
        return 0;
    if (n < 9)
        return 1;
    int cnt = 1;
    for (int i = 10; i <= n; ++i)
    {
        int tmp = i;
        while (tmp)
        {
            if (tmp % 10 == 1)
                ++cnt;
            tmp /= 10;
        }
    }
    return cnt;
}

int main()
{
    cout << NumberOf1Between1AndN(34278) << endl;

    return 0;
}

方法二：

#include<iostream>

using namespace std;

int NumberOf1Between1AndN(int n)
{
    int cnt = 0;
    for (int m = 1; m <= n; m *= 10)
    {
        int a = n / m, b = n%m;
        if (a % 10 == 0)
            cnt += a / 10 * m;
        else if (a % 10 == 1)
            cnt += a / 10 * m + (b + 1);
        else
            cnt += (a / 10 + 1)*m;
    }
    return cnt;
}

int main()
{
    cout << NumberOf1Between1AndN(34278) << endl;

    return 0;
}

20、N的阶乘二进制表示的最低位1的位置
这个问题实际上等同于求N！含有质因数2的个数+1。即答案等于N！含有质因数2的个数加1。 如果一个质数是某个数的因数，那么就说这个质数是这个数的质因数。
因为每存在一个2，则在数的最低位多1个0。实际上N！都为偶数，因为质因数里面都有一个2，
除了1以外，因为1的阶乘是1，是个奇数，其他数的阶乘都是偶数。

Java实现：

package com.mian.algorithm;

public class PosOfOneBinary {
    public static void main(String[] args) {
        System.out.println(posOfOneBinary(3));
    }
    private static int posOfOneBinary(int n){
        if(n<0){
            return -1;
        }
        int res=0;
        while(n!=0){
            n>>=1;
            res+=n;
        }
        return (res+1);
    }
}

C++实现：

#include<iostream>

using namespace std;

int posOfOneBinary(int n)
{
    if (n < 0)
        return -1;
    int res = 0;
    while (n)
    {
        n >>= 1;
        res += n;
    }
    
    return (res + 1);
}

int main()
{
    cout << posOfOneBinary(3) << endl;

    return 0;
}

21、输入一个正整数N，输出大于N且最接近这个数的素数

Java实现：

package com.mian.algorithm;

public class FindPrime {
    public static void main(String[] args) {
        FindPrime findPrime=new FindPrime();
        findPrime.findPrime(34);
    }
    private static void findPrime(int n){
        if(n<=1){
            System.out.println(2);
        }
        while(n>0){
            if(!isPrime(n)){
                ++n;
            }else{
                System.out.println(n);
                break;
            }
        }
    }
    private static boolean isPrime(int n){
        if(n==0||n==1){
            return false;
        }
        for(int i=2;i<Math.sqrt(n);++i){
            if(n%i==0){
                return false;
            }
        }
        return true;
    }
}

C++实现：

#include<iostream>
#include<algorithm>

using namespace std;

bool isPrime(int n)
{
    if (n == 0 || n == 1)
        return false;
    for (int i = 2; i <= sqrt(n); ++i)
        if (n%i == 0)
            return false;
    return true;
}

void findPrime(int n)
{
    if (n <= 0)
        return;
    while (n > 0)
        if (!isPrime(n))
            ++n;
        else
        {
            cout << n << endl;
            break;
        }
}

int main()
{
    findPrime(34);

    return 0;
}

22、读取文件，每一行有一个字段为数字，按数字大小排序，输出整个文档

Java实现：

package com.mian.algorithm;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ReadWriteFile {
    public static void main(String[] args)throws IOException{
        ReadWriteFile rwf=new ReadWriteFile();
        rwf.readWriteFile("D:/lina/in.txt","D:/lina/out.txt");
    }
    private void readWriteFile(String in,String out){
        File inFile=null;
        BufferedReader br=null;
        List<Integer> nums=new ArrayList<>();
        try{
            inFile=new File(in);
            if(!inFile.exists()||inFile.isDirectory()){
                System.out.println("读入文件不存在!!!");
            }
            br=new BufferedReader(new FileReader(inFile));
            String tmp=br.readLine();
            while(tmp!=null){
                nums.add(Integer.parseInt(tmp));
                System.out.print(tmp+"	");
                tmp=br.readLine();
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                br.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }

        Collections.sort(nums,(a,b)->a.compareTo(b));
        BufferedWriter bw = null;
        try {
            File file = new File(out);
            if (!file.exists()) {
                file.createNewFile();
            }
            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            bw = new BufferedWriter(fw);
            for(int i=0;i<nums.size();++i){
                bw.write(nums.get(i).toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                bw.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

C++实现：

#include<iostream>
#include<fstream>
#include<vector>
#include<algorithm>
#include<string>

using namespace std;

void readWriteFile(string &in,string &out)
{
    ifstream infile(in);
    if (!infile.is_open())
    {
        cout << "can not open" << in << endl;
        EXIT_FAILURE;
    }
    vector<int> res;
    int tmp;
    while (!infile.eof())
    {
        infile >> tmp;
        res.push_back(tmp);
    }
    infile.close();
    sort(res.begin(), res.end());
    for (int i = 0; i < res.size(); ++i)
        cout << res[i] << " ";
    cout << endl;
    ofstream outfile(out, 'w');
    if (!outfile.is_open())
    {
        cout << "can not open" << out << endl;
        EXIT_FAILURE;
    }
    vector<int>::iterator it = res.begin();
    while (it != res.cend())
        outfile << *it++;
    outfile.close();
}

int main()
{
    string in = "num.txt";
    string out = "sort.txt";
    readWriteFile(in, out);
}

23、找出数组中重复的数
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是重复的数字2或者3。

Java实现：

package com.mian.algorithm;

import java.util.ArrayList;
import java.util.List;

public class DuplicateNum {
    public static void main(String[] args) {
        DuplicateNum dn=new DuplicateNum();
        int[] arr={ 2,3,1,0,2,5,3 };
        List<Integer> res=dn.duplicateNum(arr);
        for(int i=0;i<res.size();++i){
            System.out.print(res.get(i)+" ");
        }
    }
    private List<Integer> duplicateNum(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return null;
        }
        List<Integer> res=new ArrayList<>();
        int[] hash=new int[size];
        for(int i=0;i<size;++i){
            hash[arr[i]]++;
            if(hash[arr[i]]>1){
                res.add(arr[i]);
            }
        }
        return res;
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

vector<int> duplicateNum(vector<int> &arr)
{
    int size = arr.size();
    if (arr.empty() || size == 0)
        return vector<int>();
    vector<int> hash(size);
    vector<int> res;
    for (int i = 0; i < size; ++i)
    {
        hash[arr[i]]++;
        if (hash[arr[i]] > 1)
            res.push_back(arr[i]);
    }
    return res;
}

int main()
{
    vector<int> arr = { 2,3,1,0,2,5,3 };
    vector<int> res = duplicateNum(arr);
    for (int i = 0; i < res.size(); ++i)
        cout << res[i] << " ";
    cout << endl;

    return 0;
}

24、反转双链表

Java实现：

package com.mian.algorithm;

import java.util.Scanner;

public class ReverseDoubleList {
    public static void main(String[] args) {
        ReverseDoubleList rdl=new ReverseDoubleList();
        DoubleListNode head=rdl.createDoubleList();
        rdl.printDoubleList(head);
        System.out.println("------------------");
       DoubleListNode last= rdl.reverseDoubleList(head);
        rdl.printDoubleList(last);
    }
    private DoubleListNode createDoubleList(){
        int val;
        DoubleListNode head=null;
        DoubleListNode cur=null;
        DoubleListNode pre=null;
        System.out.println("enter list value (enter 100 to quit):");
        Scanner sc=new Scanner(System.in);
        val=sc.nextInt();
        while(val!=100){
            cur=new DoubleListNode(val);
            if(head==null){
                head=cur;
            }
            if(pre==null) {
                cur.last=null;
                cur.next=null;
            }else{
                cur.last=pre;
                pre.next=cur;
            }
            pre=cur;
            System.out.println("enter list value (enter 100 to quit):");
            val=sc.nextInt();
        }
        return head;
    }
    private DoubleListNode reverseDoubleList(DoubleListNode head){
        if(head==null){
            return head;
        }
        DoubleListNode pre=null;
        DoubleListNode next=null;
        while(head!=null){
            next=head.next;
            head.next=pre;
            head.last=next;
            pre=head;
            head=next;
        }
        return pre;
    }
    private void printDoubleList(DoubleListNode head){
        if(head==null){
            return;
        }
        DoubleListNode cur=head;
        while(cur.next!=null){
            System.out.print(cur.val+" ");
            cur=cur.next;
        }
        System.out.println(cur.val);
        while(cur!=null){
            System.out.print(cur.val+" ");
            cur=cur.last;
        }
        System.out.println();
    }
}

class DoubleListNode{
    public int val;
    DoubleListNode next;
    DoubleListNode last;
    DoubleListNode(){}
    DoubleListNode(int v){
        this.val=v;
        this.next=null;
        this.last=null;
    }
}

C++实现：

class DoubleListNode {
public:
    int val;
    DoubleListNode *next;
    DoubleListNode *last;
    DoubleListNode(int v):val(v),next(nullptr),last(nullptr){}
};

DoubleListNode *reverseDoubleList(DoubleListNode *head)
{
    if (head == nullptr)
        return head;
    DoubleListNode *pre = nullptr;
    DoubleListNode *next = nullptr;
    while (head)
    {
        next = head->next;
        head->next = pre;
        head->last = next;
        pre = head;
        head = next;
    }
    return pre;
}

25、字符串转整数

Java实现：

package com.mian.algorithm;

public class MyAtoi {
    public static void main(String[] args){

    }
    private int myAtoi(String str){
        str = str.trim();
        if(str.isEmpty()){
            return 0;
        }
        boolean isPositive = true;
        long num = 0;
        int i = 0;
        char firstChar = str.charAt(0);
        if(Character.isDigit(firstChar)) {
            i = 0;
            isPositive = true;
        }else if (firstChar == '+') {
            i = 1;
            isPositive = true;
        }else if (firstChar == '-'){
            i = 1;
            isPositive = false;
        }
        char c;
        for(; i < str.length(); i++) {
            c = str.charAt(i);
            if(Character.isDigit(c) && num < Integer.MAX_VALUE){
                num = num * 10 + (c - '0');
            }
            else{
                break;
            }
        }
        if(!isPositive) {
            num*=-1;
        }
        if(num < Integer.MIN_VALUE){
            return Integer.MIN_VALUE;
        }else if(num > Integer.MAX_VALUE){
            return Integer.MAX_VALUE;
        }else{
            return (int)num;
        }
    }
}

C++实现：

#include<iostream>
#include<string>

using namespace std;

int myAtoi(string &str)
{
    if (str.empty())
        return 0;
    int sign = 1, base = 0, i = 0, n = str.size();
    while (i < n&&str[i] == ' ')
        ++i;
    if (str[i] == '+' || str[i] == '-')
        sign = (str[i++] == '+') ? 1 : -1;
    while (i < n&&str[i] >= '0'&&str[i] <= '9')
    {
        if (base > INT_MAX / 10 || (base == INT_MAX / 10 && str[i] - '0' > 7))
            return (sign == 1) ? INT_MAX : INT_MIN;
        base = 10 * base + (str[i++] - '0');
    }
    return base*sign;
}

int main()
{
    string str = "-98384";
    cout << myAtoi(str) << endl;

    return 0;
}

26、字符串转换float

Java实现：

package com.mian.algorithm;

public class StringToFloat {
    public static void main(String[] args) {
        StringToFloat stf=new StringToFloat();
        float res=stf.stringToFloat("89.432");
        System.out.println(res);
    }
    private float stringToFloat(String str){
        int size=str.length();
        if(str.isEmpty()||size==0){
            return Float.MIN_VALUE;
        }
        float res=0;
        int sign=1;
        if(str.charAt(0)=='+'){
            sign=1;
        }else if(str.charAt(0)=='-'){
            sign=-1;
        }else if(str.charAt(0)>='0'&&str.charAt(0)<='9'){
            res+=str.charAt(0)-'0';
        }else{
            return Float.MIN_VALUE;
        }
        int index=str.indexOf('.');
        for(int i=1;i<index;++i){
            if(str.charAt(i)<'0'||str.charAt(i)>'9'){
                return Float.MIN_VALUE;
            }
            res=res*10+(str.charAt(i)-'0');
        }
        float total=0;
        for(int i=index+1;i<size;++i){
            if(str.charAt(i)<'0'||str.charAt(i)>'9'){
                return Float.MIN_VALUE;
            }
            total=total*10+(str.charAt(i)-'0');
        }
        int pos=1;
        for(int i=0;i<(size-index-1);++i){
            pos*=10;
        }
        total=total/pos;
        return sign==1?(res+total):-(res+total);
    }
}

C++实现：

#include<iostream>
#include<string>

using namespace std;

float str2float(string &str)
{
    int size = str.size();
    if (str.empty() || size == 0)
        return FLT_MIN;
    float sum = 0;
    int sign = 1;
    if (str[0] == '+')
        sign = 1;
    else if (str[0] == '-')
        sign = -1;
    else if (str[0] >= '0'&&str[0] <= '9')
        sum = str[0] - '0';
    else
        return FLT_MIN;
    size_t pos = str.find('.');
    cout << pos << endl;
    for (int i = 1; i < pos; ++i)
    {
        if (str[i]<'0' || str[i]>'9')
            return FLT_MIN;
        sum = sum * 10 + str[i] - '0';
    }
    float total = 0;
    for (int i = pos + 1; i < size; ++i)
    {
        if (str[i]<'0' || str[i]>'9')
            return FLT_MIN;
        total = total * 10 + str[i] - '0';
    }
    total = total / (pow(10,(size-pos-1)));
        return sign == 1 ? (sum + total) : -(sum + total);
}

int main()
{
    string str = "89.432";
    cout << str2float(str) << endl;

    return 0;
}

27、字符串数组的字符串是否都能首尾相接

Java实现：

package com.mian.algorithm;

import java.util.Arrays;

public class StrOrgEnd {
    public static void main(String[] args){
        String [] str = {"gj","jl","dg","ad","gg"};
        StrOrgEnd  sre=new StrOrgEnd();
        sre.strOrgEnd(str,0);
        sre.strOrgEnd2(str,0);
    }
    private void strOrgEnd(String[] str,int k){
        if(k==str.length){
            System.out.println(Arrays.toString(str));
            return;
        }
        for(int i=k;i<str.length;++i){
            /**
             *  交换k+1和i
             *  k=0,表明为第一个字符串，必须和自己以及后面每一个交换
             *  k>0时，假设0-(k-1)是排序好的，我们需比较k-1和i的顺序
             */
            if((k>0&&judge(str[k-1],str[i]))||k==0){
                swap(str,k,i);
                strOrgEnd(str,k+1);
                swap(str,k,i);
            }
        }
    }
    private void strOrgEnd2(String[] str,int k){
        if(k==str.length){
            System.out.println(Arrays.toString(str));
            return;
        }
        for(int i=k;i<str.length;++i){
            if(k>0&&judge(str[k-1],str[i])){
                swap(str,k,i);
                strOrgEnd(str,k+1);
                swap(str,k,i);
            }else if(k==0){
                swap(str,k,i);
                strOrgEnd(str,k+1);
                swap(str,k,i);
            }
        }
    }
    private boolean judge(String str1,String str2){
        if(str1.charAt(str1.length()-1)==str2.charAt(0)){
            return true;
        }
        return false;
    }
    private void swap(String[] str,int i,int j){
        String tmp=str[i];
        str[i]=str[j];
        str[j]=tmp;
    }
}

C++实现：

#include<iostream>
#include<string>
#include<vector>

using namespace std;

void swap(vector<string> &arr, int i, int j)
{
    string tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

bool judge(string &s1, string &s2)
{
    if (s1[s1.size() - 1] == s2[0])
        return true;
    return false;
}

void fun(vector<string> &arr, int k)
{
    int size = arr.size();
    if (k == size)
    {
        for (int i = 0; i < size; ++i)
            cout << arr[i] << " ";
        cout << endl;
    }
    for (int i = k; i < size; ++i)
    {
        // k>0时，之前的0-k-1个字符串已经排好序，则判断k-1号字符串与之后的字符串
        if (k > 0 && judge(arr[k - 1], arr[i]))
        {
            swap(arr, k, i);
            fun(arr, k + 1);
            swap(arr, k, i);
        }
        else if (k == 0)// k=0,表明为第一个字符串，必须和自己以及后面每一个交换并作出判断
        {
            swap(arr, k, i);
            fun(arr, k + 1);
            swap(arr, k, i);
        }
    }
}

int main()
{
    vector<string> arr = { "gj", "jl", "dg", "ad", "gg" };
    fun(arr, 0);

    return 0;
}

28、递归求和

Java实现：

package com.mian.algorithm;

public class SumWithRecur {
    public static void main(String[] args){
        SumWithRecur sw=new SumWithRecur();
        int sum=sw.sumWithRecur(5);
        System.out.println(sum);
    }
    private int sumWithRecur(int n){
        if(n==1){
            return 1;
        }
        return sumWithRecur(n-1)+n;
    }
}

C++实现：

#include<iostream>

using namespace std;

int sumWithRecur(int n)
{
    if (n == 1)
        return 1;
    return sumWithRecur(n - 1) + n;
}

int main()
{
    cout << sumWithRecur(5);

    return 0;
}

29、交替打印数组
已知一个数组a1,a2,... an,b1,b2,...,bn,设计一个算法把数组变成a1,b1,a2,b2,...,an,bn。

Java实现：

package com.mian.algorithm;

public class SwapPrintArray {
    public static void main(String[] args) {
        int a[]={ 1, 3, 4, 7, 9, 0 };
        int b[]={ 21, 23, 25, 27, 29 };
        int[] res=swapPrintArray(a,b);
        for(int i=0;i<res.length;++i){
            System.out.print(res[i]+" ");
        }
    }
    private static int[] swapPrintArray(int[] a,int[] b){
        int asize=a.length;
        int bsize=b.length;
        if(a==null&&b==null){
            return a;
        }
        if(asize==0||a==null){
            return b;
        }
        if(bsize==0||b==null){
            return a;
        }
        int[] res=new int[asize+bsize];
        int i=0;
        int j=0;
        int k=0;
        while(i<asize&&j<bsize){
            if(i==j){
                res[k++]=a[i++];
            }else if(i>j){
                res[k++]=b[j++];
            }
        }
        while(i<asize){
            res[k++]=a[i++];
        }
        while(j<bsize){
            res[k++]=b[j++];
        }
        return res;
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

vector<int> swapPrintArray(vector<int> &a, vector<int> &b)
{
    if (a.empty()&&b.empty())
        return vector<int>();
    if (a.empty())
        return b;
    if (b.empty())
        return a;
    vector<int> res(a.size() + b.size());
    int i = 0;
    int j = 0;
    int k = 0;
    while (i < a.size() && j < b.size())
    {
        if (i == j)
            res[k++] = a[i++];
        else if (i > j)
            res[k++] = b[j++];
    }
    while (i < a.size())
        res[k++] = a[i++];
    while (j < b.size())
        res[k++] = b[j++];
    return res;
}

int main()
{
    vector<int> tt = { 1, 3, 4, 7, 9, 0 };
    vector<int> rrr = { 21, 23, 25, 27, 29 };
    vector<int> res = swapPrintArray(tt, rrr);
    for (int i = 0; i < res.size(); ++i)
        cout << res[i] << " ";
    cout << endl;

    return 0;
}

30、输入一个递增排序的数组和一个数字S，在数组中查找两个数，是的他们的和正好是S。
如果有多对数字的和等于S，输出两个数的乘积最小的。

Java实现：

package com.mian.algorithm;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TwoSum {
    public static void main(String[] args){
        TwoSum twoSum=new TwoSum();
        int[] arr={ 3, 5, 8, 9, 12, 16, 20, 23, 29, 30, 35 };
        int target=38;
        //方法一
        List<List<Integer>> res=twoSum.twoSumMap(arr,target);
        for(int i=0;i<res.size();++i){
            for(int j=0;j<res.get(i).size();++j){
                System.out.print(res.get(i).get(j)+" ");
            }
            System.out.println();
        }
        //方法二
        twoSum.twoSum(arr,target);
        //方法三
        twoSum.twoSumFor(arr,target);
    }
    private List<List<Integer>> twoSumMap(int[] arr,int target){
        List<List<Integer>> res=new ArrayList<>();
        int size=arr.length;
        if(size==0||arr==null){
            return res;
        }
        Map<Integer,Integer> map=new HashMap<>();
        List<Integer> tmp=null;
        for(int i=0;i<size;++i){
            if(map.containsKey(target-arr[i])){
                tmp=new ArrayList<>();
                tmp.add(arr[i]);
                tmp.add((target-arr[i]));
                res.add(tmp);
            }
            map.put(arr[i],arr[i]);
        }
        return res;
    }
    private void twoSum(int[] arr,int target){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        int i=0;
        int j=size-1;
        while(i<j){
            if(arr[i]+arr[j]==target){
                System.out.println(arr[i]+" "+arr[j]);
                ++i;
                --j;
            }else if(arr[i]+arr[j]>target){
                --j;
            }else{
                ++i;
            }
        }
    }
    private void twoSumFor(int[] arr,int target){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size;++i){
            for(int j=i;j<size;++j){
                if(arr[j]==(target-arr[i])){
                    System.out.println(arr[i]+" "+arr[j]);
                }
            }
        }
    }
}

C++实现：

#include<iostream>
#include<vector>
#include<unordered_map>

using namespace std;

//方法一
vector<vector<int>> twoSumMap(vector<int> &arr, int target)
{
    vector<vector<int>> res;
    int size = arr.size();
    if (arr.empty() || size == 0)
        return res;
    unordered_map<int, int> m;
    for (int i = 0; i < size; ++i)
    {
        auto it = m.find(target - arr[i]);
        if (it != m.end())
        {
            vector<int> tmp;
            tmp.push_back(arr[i]);
            tmp.push_back(target - arr[i]);
            res.push_back(tmp);
            tmp.clear();
        }
        m[arr[i]] = arr[i];
    }
    return res;
}

//方法二
void twoSum(vector<int> &arr, int target)
{
    int size = arr.size();
    if (arr.empty() || size == 0)
        return;
    int i = 0;
    int j = size - 1;
    while (i < j)
    {
        if (arr[i] + arr[j] == target)
        {
            cout << arr[i] << " " << arr[j] << endl;
            ++i;
            --j;
        }
        else if (arr[i] + arr[j] > target)
            --j;
        else
            ++i;
    }
}
//方法三
void twoSum2(vector<int> &arr, int target)
{
    int size = arr.size();
    if (arr.empty() || size == 0)
        return;
    for (int i = 0; i < size; ++i)
        for (int j = i; j < size; ++j)
            if (arr[j] == target - arr[i])
                cout << arr[i] << " " << arr[j] << endl;
}

int main()
{
    vector<int> tet = { 3, 5, 8, 9, 12, 16, 20, 23, 29, 30, 35 };
    vector<vector<int>> vr = twoSumMap(tet, 38);
    for (int i = 0; i < vr.size(); ++i)
    {
        for (int j = 0; j < vr[i].size(); ++j)
            cout << vr[i][j] << " ";
        cout << endl;
    }

    twoSum(tet, 38);
    twoSum2(tet, 38);
}