class Solution {
public int[] sortArray(int[] nums) {
//这种方法超时【快速排序】
for (int i=0;i<nums.length-1;i++){
int minIndex = i;//假设当前开始下标为最小元素下标
for (int j=i+1;j<nums.length;j++){
//从i到nums。length-1区间里找到最小值下标
if (nums[j]<nums[minIndex]) minIndex = j;
}
//交换i和真正的minIndex元素
int temp = nums[i];
nums[i] = nums[minIndex];
nums[minIndex] = temp;
}
return nums;
}
}
class Solution {
public int[] sortArray(int[] nums) {
//插入排序,但是效率比较低
for (int i=1;i<nums.length;i++){
int temp = nums[i];
int tempIndex = i;
//如过当前下标之前的元素大于当前值,则之前的元素后移,插入当前元素
while(tempIndex>0 && nums[tempIndex-1]>temp){
nums[tempIndex] = nums[tempIndex-1];
tempIndex--;
}
nums[tempIndex] = temp;
}
return nums;
}
}
class Solution {
public int[] sortArray(int[] nums) {
quickSort(nums,0,nums.length-1);
return nums;
}
private void quickSort(int[] nums, int left, int right){
//测试用例通过了,但是耗时太长,不应该选择最左边,应该随机选择
if (right==left) return;
//pivot[左边放小的,右边放大的,左右指标相等时放pivot]
//int pIndex = rand(right-left+1) + left;
int pivot = nums[left];
int l = left;
int r = right;
while(l<r){
//先看右边
while(l<r && nums[r]>=pivot) r--;
if (l<r && nums[r]<pivot){
nums[l] = nums[r];
l++;
}
//再看左边
while(l<r && nums[l]<=pivot) l++;
if (l<r && nums[l]>pivot){
nums[r] = nums[l];
r--;
}
if (l==r){
nums[l] = pivot;
break;
}
}
if (left<l){
quickSort(nums,left,l-1);
}
if (right>l){
quickSort(nums,l+1,right);
}
}
}
class Solution {
public int[] sortArray(int[] nums) {
quickSort(nums,0,nums.length-1);
return nums;
}
private void quickSort(int[] nums, int left, int right){
if (right==left) return;
//pivot[左边放小的,右边放大的,左右指标相等时放pivot]
int pIndex = (right+left)/2;
int pivot = nums[pIndex];
int l = left;
int r = right;
do{
//先看右边
while(nums[r]>pivot) r--;
//再看左边
while(nums[l]<pivot) l++;
//这是存在左右都不满足条件
//交换两个元素位置
if (l<=r){
int temp = nums[r];
nums[r] = nums[l];
nums[l] = temp;
l++;
r--;
}
}while(l<=r);
if (left<r) quickSort(nums,left,r);
if (right>l) quickSort(nums,l,right);
}
}
class Solution {
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
if (list1==null){
return list2;
}else if (list2==null){
return list1;
}else if (list1.val<=list2.val){
list1.next = mergeTwoLists(list1.next,list2);
return list1;
}else{
list2.next = mergeTwoLists(list2.next,list1);
return list2;
}
}
}
class Solution {
public int[] twoSum(int[] nums, int target) {
int[] result = new int[2];
HashMap<Integer,Integer> map = new HashMap<>();
for (int i=0;i<nums.length;i++){
if (map.containsKey(target-nums[i])){
result[0] = i;
result[1] = map.get(target-nums[i]);
return result;
}
map.put(nums[i],i);
}
return result;
}
}
class Solution {
public String longestPalindrome(String s) {
int left = 0;
int right = 0;
int cur = 0;
int len = 1;
int result = 0;
int maxStart = 0;
for (int i=0;i<s.length();i++){
left = i-1;
right = i+1;
while(left>=0 && s.charAt(left)==s.charAt(i)){
len++;
left--;
}
while(right<s.length() && s.charAt(i)==s.charAt(right)){
len++;
right++;
}
while(left>=0 && right<s.length() && s.charAt(right)==s.charAt(left)){
len += 2;
left--;
right++;
}
if (len>result){
result = len;
maxStart = left;
}
len = 1;
}
return s.substring(maxStart+1,maxStart+result+1);
}
}
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
if (root==null) return result;
Deque<TreeNode> que = new LinkedList<>();
que.add(root);
while(!que.isEmpty()){
List<Integer> path = new ArrayList<>();
int size = que.size();
for (int i=0;i<size;i++){
TreeNode node = que.poll();
path.add(node.val);
if (node.left!=null){
que.add(node.left);
}
if (node.right!=null){
que.add(node.right);
}
}
result.add(path);
}
return result;
}
}