删除排序数组中的重复元素

题目大意

　　给定一个排序的数组，将数组中的重复元素去掉，相同的只保留一个，而且返回数组新的元素个数，不要建立一个新的数组来保存结果。在常量时间内解决这个问题

解题思路

　　从第二个元素开始处理，记为当前处理的元素，若是当前元素与他的前一个元素相同就删除这个元素，若是不一样就将它移动到正确的位置，返回最后数组元素人个数。

代码实现

算法实现类

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();

  }

}