刪除排序數組中的重複元素

題目大意

　　給定一個排序的數組，將數組中的重複元素去掉，相同的只保留一個，而且返回數組新的元素個數，不要建立一個新的數組來保存結果。在常量時間內解決這個問題

解題思路

　　從第二個元素開始處理，記爲當前處理的元素，若是當前元素與他的前一個元素相同就刪除這個元素，若是不一樣就將它移動到正確的位置，返回最後數組元素人個數。

代碼實現

算法實現類

public class Solution {
    public int removeDuplicates(int[] A) {

        if (A.length == 0) {
            return 0;
        }

        int index = 0;//[0,index]只記錄數組中出現的按從小到大的惟一一個數，已經排好序了
        int next = 1;

        // 算法思想：找index以後的比A[index]大的數，如是找到就移動到A[index+1]處，
        // index移動到下一個位置，next移動到下一個位置，再找比A[index]大的數

        while (next < A.length) {
            while (next < A.length && A[index] == A[next] ) { // 找不等於數組中最
                next++;
            }

            if (next < A.length) {
                index++;
                A[index] = A[next];
                next++;
            }
        }
        return index + 1;
    }

    private void swap(int[] a, int x, int y) {
        int tmp = a[x];
        a[x] = a[y];
        a[y] = tmp;
    }
}

思路：一個數組是有序的，因此算法實現起來相對比較簡單，由於只需比較數組相鄰的兩個數字便可，存在兩種狀況

1：若是數組裏面不存在元素或者只存在一個元素，那麼就不須要進行比較，直接返回數組的長度便可；

2：數組長度大於一的話那麼就須要比較數組的相鄰的兩個元素，若是相等 的話那麼後一個元素的指針日後移一位，而後前一個元素的指針接着日後移一位，將當先後一個元素指針所指的數字賦給前一個元素指針所指的位置，而後後一元素指針繼續加一。若是相鄰倆個元素不等的話，則直接前一元素指針加一與後一元素重合，而後後一元素指針繼續加一。

代碼以下：

public class Solution {
    public int removeDuplicates(int[] A) {
        int i=0;
        int j=1;
        if(A.length==0||A.length==1){
            return A.length;
        }
        while(i<A.length&&j<A.length){
            if(A[i]==A[j]){
                j++;
            }else{
                A[++i]=A[j++];
            }
            
        }
        return i+1;
}
}

import java.util.List;

import java.util.ArrayList;

import java.util.Set;

import java.util.HashSet;

public class lzwCode {

  

  public static void main(String [] args) {

    testA();

    System.out.println("===========================");

    testB();

    System.out.println("===========================");

    testC();

  }

  

  //去掉數組中重複的值

  public static void testA() {

    String [] str = {"Java", "C++", "Php", "C#", "Python", "C++", "Java"};

    for (String elementA:str ) {

      System.out.print(elementA + " ");

    }

    List<String> list = new ArrayList<String>();

    for (int i=0; i<str.length; i++) {

      if(!list.contains(str[i])) {

        list.add(str[i]);

      }

    }

    /*

    Set<String> set = new HashSet<String>();

    for (int i=0; i<str.length; i++) {

      set.add(str[i]);

    }

    String[] newStr = set.toArray(new String[1]);

    */

    System.out.println();

    String[] newStr = list.toArray(new String[1]); //返回一個包含全部對象的指定類型的數組 

    for (String elementB:newStr ) {

      System.out.print(elementB + " ");

    }

    System.out.println();

  }

  

  //刪除數組中其中一個元素

  public static void testB() {

    String [] str = {"Java", "C++", "Php", "C#", "Python"};

    for (String elementA:str ) {

      System.out.print(elementA + " ");

    }

    //刪除php

    List<String> list = new ArrayList<String>();

    for (int i=0; i<str.length; i++) {

      list.add(str[i]);

    }

    list.remove(2); //list.remove("Php") 

    System.out.println();

    String[] newStr = list.toArray(new String[1]); //返回一個包含全部對象的指定類型的數組 

    for (String elementB:newStr ) {

      System.out.print(elementB + " ");

    }  

    System.out.println();

  }

  

  //在數組中增長一個元素

  public static void testC() {

    String [] str = {"Java", "C++", "Php", "C#", "Python"};

    for (String elementA:str ) {

      System.out.print(elementA + " ");

    }

    //增長ruby

    List<String> list = new ArrayList<String>();

    for (int i=0; i<str.length; i++) {

      list.add(str[i]);

    }

    list.add(2, "ruby"); //list.add("ruby") 

    System.out.println();

    String[] newStr = list.toArray(new String[1]); //返回一個包含全部對象的指定類型的數組 

    for (String elementB:newStr ) {

      System.out.print(elementB + " ");

    }  

    System.out.println();

  }

}